Core/PacketIO: Converted BattlegroundPackets to classes

5 files changed, 675 insertions, 17 deletions

diff --git a/src/server/game/Server/Packets/AllPackets.h b/src/server/game/Server/Packets/AllPackets.h
index 041ea5b7599..de8cc0b7524 100644
--- a/src/server/game/Server/Packets/AllPackets.h
+++ b/src/server/game/Server/Packets/AllPackets.h
@@ -19,6 +19,7 @@
 #define AllPackets_h__
 
 #include "BankPackets.h"
+#include "BattlegroundPackets.h"
 #include "CalendarPackets.h"
 #include "CharacterPackets.h"
 #include "ChatPackets.h"
diff --git a/src/server/game/Server/Packets/BattlegroundPackets.cpp b/src/server/game/Server/Packets/BattlegroundPackets.cpp
new file mode 100644
index 00000000000..460820e900a
--- /dev/null
+++ b/src/server/game/Server/Packets/BattlegroundPackets.cpp
@@ -0,0 +1,272 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * 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 "BattlegroundPackets.h"
+#include "Battleground.h"
+
+void WorldPackets::Battleground::AreaSpiritHealerQuery::Read()
+{
+    _worldPacket >> HealerGuid;
+}
+
+void WorldPackets::Battleground::AreaSpiritHealerQueue::Read()
+{
+    _worldPacket >> HealerGuid;
+}
+
+WorldPacket const* WorldPackets::Battleground::AreaSpiritHealerTime::Write()
+{
+    _worldPacket << HealerGuid;
+    _worldPacket << int32(TimeLeft);
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::PVPLogData_RatingData const& ratingData)
+{
+    for (std::size_t i = 0; i < 2; ++i)
+    {
+        data << int32(ratingData.Prematch[i]);
+        data << int32(ratingData.Postmatch[i]);
+        data << int32(ratingData.PrematchMMR[i]);
+    }
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::PVPLogData_Arena const& arena)
+{
+    data << arena.Ratings;
+    for (std::string_view const& teamName : arena.TeamName)
+        data << teamName;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::PVPLogData_Honor const& honorData)
+{
+    data << uint32(honorData.HonorKills);
+    data << uint32(honorData.Deaths);
+    data << uint32(honorData.ContributionPoints);
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::PVPLogData_Player const& playerData)
+{
+    data << playerData.PlayerGUID;
+    data << uint32(playerData.Kills);
+    std::visit([&](auto const& v) { return data << v; }, playerData.HonorOrFaction);
+    data << uint32(playerData.DamageDone);
+    data << uint32(playerData.HealingDone);
+    data << uint32(playerData.Stats.size());
+    for (uint32 pvpStat : playerData.Stats)
+        data << uint32(pvpStat);
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::Battleground::PVPMatchStatistics::Write()
+{
+    _worldPacket.reserve(sizeof(PVPLogData_Arena) + 1 + 1 + 4 + Players.size() * sizeof(PVPLogData_Player));
+
+    _worldPacket << uint8(Arena.has_value());
+    if (Arena)
+        _worldPacket << *Arena;
+
+    _worldPacket << uint8(Winner.has_value());
+    if (Winner)
+        _worldPacket << uint8(*Winner);
+
+    _worldPacket << uint32(Players.size());
+    for (PVPLogData_Player const& player : Players)
+        _worldPacket << player;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Battleground::BattlemasterJoin::Read()
+{
+    _worldPacket >> BattlemasterGuid;
+    _worldPacket >> BattlemasterListID;
+    _worldPacket >> InstanceID;
+    _worldPacket >> JoinAsGroup;
+}
+
+void WorldPackets::Battleground::BattlemasterJoinArena::Read()
+{
+    _worldPacket >> BattlemasterGuid;
+    _worldPacket >> TeamSizeIndex;
+    _worldPacket >> JoinAsGroup;
+    _worldPacket >> IsRated;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::BattlefieldStatusHeader const& header)
+{
+    data << uint32(header.QueueSlot);
+    data << uint64(header.QueueID);
+    data << uint8(header.RangeMin);
+    data << uint8(header.RangeMax);
+    data << uint32(header.InstanceID);
+    data << uint8(header.RegisteredMatch);
+    return data;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlefieldStatusNone::Write()
+{
+    _worldPacket << uint32(QueueSlot);
+    _worldPacket << uint64(0);
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlefieldStatusNeedConfirmation::Write()
+{
+    _worldPacket << Hdr;
+    _worldPacket << uint32(STATUS_WAIT_JOIN);
+    _worldPacket << uint32(Mapid);
+    _worldPacket << uint64(RandomQueueID);
+    _worldPacket << uint32(Timeout);
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlefieldStatusActive::Write()
+{
+    _worldPacket << Hdr;
+    _worldPacket << uint32(STATUS_IN_PROGRESS);
+    _worldPacket << uint32(Mapid);
+    _worldPacket << uint64(RandomQueueID);
+    _worldPacket << uint32(ShutdownTimer);
+    _worldPacket << uint32(StartTimer);
+    _worldPacket << uint8(ArenaFaction);
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlefieldStatusQueued::Write()
+{
+    _worldPacket << Hdr;
+    _worldPacket << uint32(STATUS_WAIT_QUEUE);
+    _worldPacket << uint32(AverageWaitTime);
+    _worldPacket << uint32(WaitTime);
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::GroupJoinedBattleground::Write()
+{
+    _worldPacket << uint32(Reason);
+    if (Reason == ERR_BATTLEGROUND_JOIN_TIMED_OUT || Reason == ERR_BATTLEGROUND_JOIN_FAILED)
+        _worldPacket << ClientID;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Battleground::BattlefieldLeave::Read()
+{
+    _worldPacket >> QueueID;
+}
+
+void WorldPackets::Battleground::BattlefieldPort::Read()
+{
+    _worldPacket >> QueueID;
+    _worldPacket >> AcceptedInvite;
+}
+
+void WorldPackets::Battleground::BattlefieldListRequest::Read()
+{
+    _worldPacket >> ListID;
+    _worldPacket >> PvpAnywhere;
+    _worldPacket >> NoXpGain;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlefieldList::Write()
+{
+    _worldPacket << BattlemasterGuid;
+    _worldPacket << uint8(PvpAnywhere);
+    _worldPacket << int32(BattlemasterListID);
+    _worldPacket << uint8(MinLevel);
+    _worldPacket << uint8(MaxLevel);
+
+    _worldPacket << uint8(HasHolidayWinToday);
+    _worldPacket << uint32(HolidayWinHonorCurrencyBonus);
+    _worldPacket << uint32(HolidayFirstWinArenaCurrencyBonus);
+    _worldPacket << uint32(HolidayLossHonorCurrencyBonus);
+
+    _worldPacket << uint8(BattlemasterListID == BATTLEGROUND_RB);
+    if (BattlemasterListID == BATTLEGROUND_RB)
+    {
+        _worldPacket << uint8(HasRandomWinToday);
+        _worldPacket << uint32(RandomWinHonorCurrencyBonus);
+        _worldPacket << uint32(RandomFirstWinArenaCurrencyBonus);
+        _worldPacket << uint32(RandomLossHonorCurrencyBonus);
+    }
+
+    _worldPacket << uint32(Battlefields ? Battlefields->size() : 0);
+    if (Battlefields)
+        for (uint32 battlefield : *Battlefields)
+            _worldPacket << uint32(battlefield);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Battleground::ReportPvPPlayerAFK::Read()
+{
+    _worldPacket >> Offender;
+}
+
+WorldPacket const* WorldPackets::Battleground::ReportPvPPlayerAFKResult::Write()
+{
+    _worldPacket << uint8(Result);
+    _worldPacket << uint8(NumBlackMarksOnOffender);
+    _worldPacket << uint8(NumPlayersIHaveReported);
+    _worldPacket << Offender;
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::BattlegroundPlayerPosition const& playerPosition)
+{
+    data << playerPosition.Guid;
+    data << playerPosition.Pos;
+    return data;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlegroundPlayerPositions::Write()
+{
+    _worldPacket << uint32(Players.size());
+    for (BattlegroundPlayerPosition const& pos : Players)
+        _worldPacket << pos;
+
+    _worldPacket << uint32(FlagCarriers.size());
+    for (BattlegroundPlayerPosition const& pos : FlagCarriers)
+        _worldPacket << pos;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlegroundPlayerJoined::Write()
+{
+    _worldPacket << Guid;
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::BattlegroundPlayerLeft::Write()
+{
+    _worldPacket << Guid;
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Battleground::DestroyArenaUnit::Write()
+{
+    _worldPacket << Guid;
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/BattlegroundPackets.h b/src/server/game/Server/Packets/BattlegroundPackets.h
new file mode 100644
index 00000000000..ce143b83ad0
--- /dev/null
+++ b/src/server/game/Server/Packets/BattlegroundPackets.h
@@ -0,0 +1,372 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * 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/>.
+ */
+
+#ifndef BattlegroundPackets_h__
+#define BattlegroundPackets_h__
+
+#include "Packet.h"
+#include "ObjectGuid.h"
+#include "Optional.h"
+#include "Position.h"
+#include <array>
+#include <variant>
+
+namespace WorldPackets
+{
+    namespace Battleground
+    {
+        class AreaSpiritHealerQuery final : public ClientPacket
+        {
+        public:
+            AreaSpiritHealerQuery(WorldPacket&& packet) : ClientPacket(CMSG_AREA_SPIRIT_HEALER_QUERY, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid HealerGuid;
+        };
+
+        class AreaSpiritHealerQueue final : public ClientPacket
+        {
+        public:
+            AreaSpiritHealerQueue(WorldPacket&& packet) : ClientPacket(CMSG_AREA_SPIRIT_HEALER_QUEUE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid HealerGuid;
+        };
+
+        class AreaSpiritHealerTime final : public ServerPacket
+        {
+        public:
+            AreaSpiritHealerTime() : ServerPacket(SMSG_AREA_SPIRIT_HEALER_TIME, 8 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid HealerGuid;
+            int32 TimeLeft = 0;
+        };
+
+        class HearthAndResurrect final : public ClientPacket
+        {
+        public:
+            HearthAndResurrect(WorldPacket&& packet) : ClientPacket(CMSG_HEARTH_AND_RESURRECT, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class PVPLogDataRequest final : public ClientPacket
+        {
+        public:
+            PVPLogDataRequest(WorldPacket&& packet) : ClientPacket(MSG_PVP_LOG_DATA, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct PVPLogData_RatingData
+        {
+            std::array<int32,2 > Prematch = { };
+            std::array<int32,2 > Postmatch = { };
+            std::array<int32,2 > PrematchMMR = { };
+        };
+
+        struct PVPLogData_Arena
+        {
+            PVPLogData_RatingData Ratings;
+            std::array<std::string_view, 2> TeamName;
+        };
+
+        struct PVPLogData_Honor
+        {
+            uint32 HonorKills = 0;
+            uint32 Deaths = 0;
+            uint32 ContributionPoints = 0;
+        };
+
+        struct PVPLogData_Player
+        {
+            ObjectGuid PlayerGUID;
+            uint32 Kills = 0;
+            std::variant<PVPLogData_Honor, uint8> HonorOrFaction;
+            uint32 DamageDone = 0;
+            uint32 HealingDone = 0;
+            std::vector<uint32> Stats;
+        };
+
+        class PVPMatchStatistics final : public ServerPacket
+        {
+        public:
+            PVPMatchStatistics() : ServerPacket(MSG_PVP_LOG_DATA, 0) { }
+
+            WorldPacket const* Write() override;
+
+            Optional<uint8> Winner;
+            std::vector<PVPLogData_Player> Players;
+            Optional<PVPLogData_Arena> Arena;
+        };
+
+        struct BattlefieldStatusHeader
+        {
+            uint32 QueueSlot = 0;
+            uint64 QueueID = 0;
+            uint8 RangeMin = 0;
+            uint8 RangeMax = 0;
+            uint32 InstanceID = 0;
+            bool RegisteredMatch = false;
+        };
+
+        class BattlefieldStatusNone final : public ServerPacket
+        {
+        public:
+            BattlefieldStatusNone() : ServerPacket(SMSG_BATTLEFIELD_STATUS, 4 + 8) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 QueueSlot = 0;
+        };
+
+        class BattlefieldStatusNeedConfirmation final : public ServerPacket
+        {
+        public:
+            BattlefieldStatusNeedConfirmation() : ServerPacket(SMSG_BATTLEFIELD_STATUS, 4 + 4 + sizeof(BattlefieldStatusHeader) + 8) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 Timeout = 0;
+            uint32 Mapid = 0;
+            BattlefieldStatusHeader Hdr;
+            uint64 RandomQueueID = 0;
+        };
+
+        class BattlefieldStatusActive final : public ServerPacket
+        {
+        public:
+            BattlefieldStatusActive() : ServerPacket(SMSG_BATTLEFIELD_STATUS, sizeof(BattlefieldStatusHeader) + 4 + 1 + 4 + 4 + 8) { }
+
+            WorldPacket const* Write() override;
+
+            BattlefieldStatusHeader Hdr;
+            uint32 ShutdownTimer = 0;
+            uint8 ArenaFaction = 0;
+            uint32 StartTimer = 0;
+            uint32 Mapid = 0;
+            uint64 RandomQueueID = 0;
+        };
+
+        class BattlefieldStatusQueued final : public ServerPacket
+        {
+        public:
+            BattlefieldStatusQueued() : ServerPacket(SMSG_BATTLEFIELD_STATUS, 4 + sizeof(BattlefieldStatusHeader) + 4) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 AverageWaitTime = 0;
+            BattlefieldStatusHeader Hdr;
+            uint32 WaitTime = 0;
+        };
+
+        class GroupJoinedBattleground final : public ServerPacket
+        {
+        public:
+            GroupJoinedBattleground() : ServerPacket(SMSG_GROUP_JOINED_BATTLEGROUND, 8 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid ClientID;
+            int32 Reason = 0;
+        };
+
+        using BattlefieldStatusFailed = GroupJoinedBattleground;
+
+        class BattlemasterJoin final : public ClientPacket
+        {
+        public:
+            BattlemasterJoin(WorldPacket&& packet) : ClientPacket(CMSG_BATTLEMASTER_JOIN, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid BattlemasterGuid;
+            uint32 BattlemasterListID = 0;
+            uint32 InstanceID = 0;
+            bool JoinAsGroup = false;
+        };
+
+        class BattlemasterJoinArena final : public ClientPacket
+        {
+        public:
+            BattlemasterJoinArena(WorldPacket&& packet) : ClientPacket(CMSG_BATTLEMASTER_JOIN_ARENA, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid BattlemasterGuid;
+            uint8 TeamSizeIndex = 0;
+            bool JoinAsGroup = false;
+            bool IsRated = false;
+        };
+
+        class BattlefieldLeave final : public ClientPacket
+        {
+        public:
+            BattlefieldLeave(WorldPacket&& packet) : ClientPacket(CMSG_LEAVE_BATTLEFIELD, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 QueueID = 0;
+        };
+
+        class BattlefieldPort final : public ClientPacket
+        {
+        public:
+            BattlefieldPort(WorldPacket&& packet) : ClientPacket(CMSG_BATTLEFIELD_PORT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint64 QueueID = 0;
+            bool AcceptedInvite = false;
+        };
+
+        class BattlefieldListRequest final : public ClientPacket
+        {
+        public:
+            BattlefieldListRequest(WorldPacket&& packet) : ClientPacket(CMSG_BATTLEFIELD_LIST, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 ListID = 0;
+            bool PvpAnywhere = false;
+            bool NoXpGain = false;
+        };
+
+        class BattlefieldList final : public ServerPacket
+        {
+        public:
+            BattlefieldList() : ServerPacket(SMSG_BATTLEFIELD_LIST, 8 + 1 + 4 + 1 + 1 + 1 + 4 + 4 + 4 + 1 + 1 + 4 + 4 + 4 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid BattlemasterGuid;
+            int32 BattlemasterListID = 0;
+            uint8 MinLevel = 0;
+            uint8 MaxLevel = 0;
+            std::set<uint32> const* Battlefields = nullptr;
+            bool PvpAnywhere = false;
+            bool HasHolidayWinToday = false;
+            uint32 HolidayWinHonorCurrencyBonus = 0;
+            uint32 HolidayFirstWinArenaCurrencyBonus = 0;
+            uint32 HolidayLossHonorCurrencyBonus = 0;
+            bool HasRandomWinToday = false;
+            uint32 RandomWinHonorCurrencyBonus = 0;
+            uint32 RandomFirstWinArenaCurrencyBonus = 0;
+            uint32 RandomLossHonorCurrencyBonus = 0;
+        };
+
+        class RequestBattlefieldStatus final : public ClientPacket
+        {
+        public:
+            RequestBattlefieldStatus(WorldPacket&& packet) : ClientPacket(CMSG_BATTLEFIELD_STATUS, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class ReportPvPPlayerAFK final : public ClientPacket
+        {
+        public:
+            ReportPvPPlayerAFK(WorldPacket&& packet) : ClientPacket(CMSG_REPORT_PVP_AFK, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Offender;
+        };
+
+        class ReportPvPPlayerAFKResult final : public ServerPacket
+        {
+        public:
+            ReportPvPPlayerAFKResult() : ServerPacket(SMSG_REPORT_PVP_AFK_RESULT, 8 + 1 + 1 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            enum ResultCode : uint8
+            {
+                PVP_REPORT_AFK_SUCCESS = 0,
+                PVP_REPORT_AFK_GENERIC_FAILURE = 1, // there are more error codes but they are impossible to receive without modifying the client
+                PVP_REPORT_AFK_SYSTEM_ENABLED = 5,
+                PVP_REPORT_AFK_SYSTEM_DISABLED = 6
+            };
+
+            ObjectGuid Offender;
+            uint8 NumPlayersIHaveReported = 0;
+            uint8 NumBlackMarksOnOffender = 0;
+            uint8 Result = PVP_REPORT_AFK_GENERIC_FAILURE;
+        };
+
+        class BattlegroundPlayerPositionsRequest final : public ClientPacket
+        {
+        public:
+            BattlegroundPlayerPositionsRequest(WorldPacket&& packet) : ClientPacket(MSG_BATTLEGROUND_PLAYER_POSITIONS, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct BattlegroundPlayerPosition
+        {
+            ObjectGuid Guid;
+            TaggedPosition<Position::XY> Pos;
+        };
+
+        class BattlegroundPlayerPositions final : public ServerPacket
+        {
+        public:
+            BattlegroundPlayerPositions() : ServerPacket(MSG_BATTLEGROUND_PLAYER_POSITIONS, 4 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<BattlegroundPlayerPosition> Players;
+            std::vector<BattlegroundPlayerPosition> FlagCarriers;
+        };
+
+        class BattlegroundPlayerJoined final : public ServerPacket
+        {
+        public:
+            BattlegroundPlayerJoined() : ServerPacket(SMSG_BATTLEGROUND_PLAYER_JOINED, 8) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Guid;
+        };
+
+        class BattlegroundPlayerLeft final : public ServerPacket
+        {
+        public:
+            BattlegroundPlayerLeft() : ServerPacket(SMSG_BATTLEGROUND_PLAYER_LEFT, 8) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Guid;
+        };
+
+        class DestroyArenaUnit final : public ServerPacket
+        {
+        public:
+            DestroyArenaUnit() : ServerPacket(SMSG_ARENA_UNIT_DESTROYED, 8) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Guid;
+        };
+    }
+}
+
+#endif // BattlegroundPackets_h__
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 34710741eca..4b10b53f56f 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -851,7 +851,7 @@ void OpcodeTable::Initialize()
     /*0x2D0*/ DEFINE_HANDLER(CMSG_MOVE_WATER_WALK_ACK,                     STATUS_LOGGEDIN, PROCESS_THREADSAFE,   &WorldSession::HandleMoveWaterWalkAck          );
     /*0x2D1*/ DEFINE_HANDLER(CMSG_MOVE_NOT_ACTIVE_MOVER,                   STATUS_LOGGEDIN, PROCESS_THREADSAFE,   &WorldSession::HandleMoveNotActiveMover        );
     /*0x2D2*/ DEFINE_SERVER_OPCODE_HANDLER(SMSG_PLAY_SOUND,                STATUS_NEVER);
-    /*0x2D3*/ DEFINE_HANDLER(CMSG_BATTLEFIELD_STATUS,                      STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleBattlefieldStatusOpcode   );
+    /*0x2D3*/ DEFINE_HANDLER(CMSG_BATTLEFIELD_STATUS,                      STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestBattlefieldStatusOpcode);
     /*0x2D4*/ DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLEFIELD_STATUS,        STATUS_NEVER);
     /*0x2D5*/ DEFINE_HANDLER(CMSG_BATTLEFIELD_PORT,                        STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleBattleFieldPortOpcode     );
     /*0x2D6*/ DEFINE_HANDLER(MSG_INSPECT_HONOR_STATS,                      STATUS_LOGGEDIN, PROCESS_INPLACE,      &WorldSession::HandleInspectHonorStatsOpcode   );
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index 8b34a4ee0bf..a8c5a892f87 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -88,6 +88,22 @@ namespace WorldPackets
         class BuyBankSlot;
     }
 
+    namespace Battleground
+    {
+        class AreaSpiritHealerQuery;
+        class AreaSpiritHealerQueue;
+        class HearthAndResurrect;
+        class PVPLogDataRequest;
+        class BattlemasterJoin;
+        class BattlemasterJoinArena;
+        class BattlefieldLeave;
+        class BattlefieldPort;
+        class BattlefieldListRequest;
+        class RequestBattlefieldStatus;
+        class ReportPvPPlayerAFK;
+        class BattlegroundPlayerPositionsRequest;
+    }
+
     namespace Calendar
     {
         class CalendarAddEvent;
@@ -541,8 +557,6 @@ class TC_GAME_API WorldSession
 
         void SendAttackStop(Unit const* enemy);
 
-        void SendBattleGroundList(ObjectGuid guid, BattlegroundTypeId bgTypeId = BATTLEGROUND_RB);
-
         void SendTradeStatus(TradeStatusInfo const& status);
         void SendUpdateTrade(bool trader_data = true);
         void SendCancelTrade(TradeStatus status);
@@ -789,8 +803,6 @@ class TC_GAME_API WorldSession
 
         void HandleRequestRaidInfoOpcode(WorldPacket& recvData);
 
-        void HandleBattlefieldStatusOpcode(WorldPacket& recvData);
-
         void HandleGroupInviteOpcode(WorldPackets::Party::PartyInviteClient& packet);
         void HandleGroupAcceptOpcode(WorldPacket& recvPacket);
         void HandleGroupDeclineOpcode(WorldPacket& recvPacket);
@@ -1023,15 +1035,19 @@ class TC_GAME_API WorldSession
         void HandleDismissCritter(WorldPackets::Pet::DismissCritter& dismissCritter);
 
         //Battleground
-        void HandleBattlemasterHelloOpcode(WorldPacket& recvData);
-        void HandleBattlemasterJoinOpcode(WorldPacket& recvData);
-        void HandleBattlegroundPlayerPositionsOpcode(WorldPacket& recvData);
-        void HandlePVPLogDataOpcode(WorldPacket& recvData);
-        void HandleBattleFieldPortOpcode(WorldPacket& recvData);
-        void HandleBattlefieldListOpcode(WorldPacket& recvData);
-        void HandleBattlefieldLeaveOpcode(WorldPacket& recvData);
-        void HandleBattlemasterJoinArena(WorldPacket& recvData);
-        void HandleReportPvPAFK(WorldPacket& recvData);
+        void HandleBattlemasterHelloOpcode(WorldPackets::NPC::Hello& hello);
+        void HandleBattlemasterJoinOpcode(WorldPackets::Battleground::BattlemasterJoin& battlemasterJoin);
+        void HandleBattlegroundPlayerPositionsOpcode(WorldPackets::Battleground::BattlegroundPlayerPositionsRequest& battlegroundPlayerPositionsRequest);
+        void HandlePVPLogDataOpcode(WorldPackets::Battleground::PVPLogDataRequest& pvpLogDataRequest);
+        void HandleBattleFieldPortOpcode(WorldPackets::Battleground::BattlefieldPort& battlefieldPort);
+        void HandleBattlefieldListOpcode(WorldPackets::Battleground::BattlefieldListRequest& battlefieldList);
+        void HandleBattlefieldLeaveOpcode(WorldPackets::Battleground::BattlefieldLeave& battlefieldLeave);
+        void HandleBattlemasterJoinArena(WorldPackets::Battleground::BattlemasterJoinArena& packet);
+        void HandleReportPvPAFK(WorldPackets::Battleground::ReportPvPPlayerAFK& reportPvPPlayerAFK);
+        void HandleAreaSpiritHealerQueryOpcode(WorldPackets::Battleground::AreaSpiritHealerQuery& areaSpiritHealerQuery);
+        void HandleAreaSpiritHealerQueueOpcode(WorldPackets::Battleground::AreaSpiritHealerQueue& areaSpiritHealerQueue);
+        void HandleHearthAndResurrect(WorldPackets::Battleground::HearthAndResurrect& hearthAndResurrect);
+        void HandleRequestBattlefieldStatusOpcode(WorldPackets::Battleground::RequestBattlefieldStatus& requestBattlefieldStatus);
 
         // Battlefield
         void SendBfInvitePlayerToWar(uint32 battleId, uint32 zoneId, uint32 time);
@@ -1055,7 +1071,6 @@ class TC_GAME_API WorldSession
         void HandleTimeSyncResponse(WorldPacket& recvData);
         void HandleWhoIsOpcode(WorldPacket& recvData);
         void HandleResetInstancesOpcode(WorldPacket& recvData);
-        void HandleHearthAndResurrect(WorldPacket& recvData);
         void HandleInstanceLockResponse(WorldPacket& recvPacket);
 
         // Looking for Dungeon/Raid
@@ -1098,8 +1113,6 @@ class TC_GAME_API WorldSession
         void HandleArenaTeamDisbandOpcode(WorldPacket& recvData);
         void HandleArenaTeamLeaderOpcode(WorldPacket& recvData);
 
-        void HandleAreaSpiritHealerQueryOpcode(WorldPacket& recvData);
-        void HandleAreaSpiritHealerQueueOpcode(WorldPacket& recvData);
         void HandleSelfResOpcode(WorldPacket& recvData);
         void HandleComplainOpcode(WorldPacket& recvData);
         void HandleRequestPetInfo(WorldPackets::Pet::RequestPetInfo& packet);