Core/PacketsIO: Implemented or updated most of party related packets.

Packets updated or implemented :
- SMSG_INSTANCE_INFO : updated

- CMSG_SAVE_CUF_PROFILES : updated
- SMSG_LOAD_CUF_PROFILES : updated

- SMSG_PARTY_COMMAND_RESULT : updated

- CMSG_PARTY_INVITE : updated
- SMSG_PARTY_INVITE : updated
- CMSG_PARTY_INVITE_RESPONSE : updated
- CMSG_PARTY_UNINVITE : updated
- SMSG_GROUP_UNINVITE : updated
- CMSG_LEAVE_GROUP : updated
- SMSG_GROUP_DECLINE : updated

- SMSG_GROUP_DESTROYED : updated

- CMSG_MINIMAP_PING : updated
- SMSG_MINIMAP_PING : updated

- CMSG_CONVERT_RAID : updated
- CMSG_SET_EVERYONE_IS_ASSISTANT

- CMSG_DO_READY_CHECK : updated
- CMSG_READY_CHECK_RESPONSE : updated
- SMSG_READY_CHECK_COMPLETED : updated
- SMSG_READY_CHECK_RESPONSE : updated
- SMSG_READY_CHECK_STARTED : updated

- CMSG_REQUEST_PARTY_JOIN_UPDATES : implemented (source : sniffs)
- CMSG_REQUEST_PARTY_MEMBER_STATE : updated
- SMSG_PARTY_MEMBER_STATE : updated
- SMSG_PARTY_UPDATE : updated

- CMSG_REQUEST_RAID_INFO : updated

- CMSG_INITIATE_ROLE_POLL : updated
- SMSG_ROLE_POLL_INFORM : updated
- CMSG_SET_ROLE : updated
- SMSG_ROLE_CHANGED_INFORM : updated

- CMSG_CHANGE_SUB_GROUP : updated
- CMSG_SWAP_SUB_GROUPS : implemented

- CMSG_SET_ASSISTANT_LEADER : updated
- CMSG_SET_PARTY_LEADER : updated
- SMSG_GROUP_NEW_LEADER : updated

- CMSG_CLEAR_RAID_MARKER : implemented
- SMSG_RAID_MARKERS_CHANGED : implemented

- CMSG_UPDATE_RAID_TARGET : updated
- SMSG_SEND_RAID_TARGET_UPDATE_ALL : updated
- SMSG_SEND_RAID_TARGET_UPDATE_SINGLE : updated

- CMSG_OPT_OUT_OF_LOOT : updated
- CMSG_SET_LOOT_METHOD : updated

About group update flags:
- Not sure they are use for now.
- Pets now have their group update flags.
- Pets'power is no send to client anymore.
- Changes about them are inspired from SMSG_PARTY_MEMBER_STATS parsing of WowPacketParser, but it seems this packet is not use anymore.

CHAT_MSG_RAID has been fixed.

About Ready check:
- Correctly implemented this function.
- An update function has been added to Group class, and to GroupMgr class in order to manage the ready check expiration (when 35 seconds were gone, players who have not answered must be reported as AFK)

About Raid markers:
- Old spell effect SPELL_EFFECT_SUMMON_OBJECT_SLOT3 has been renamed to SPELL_EFFECT_CHANGE_RAID_MARKER and implemented. I'm sure about that because raid markers spells are the only spells that have this effect type.

Source: WowPacketParser, and sniffs from official.

10 files changed, 1591 insertions, 66 deletions

diff --git a/src/server/game/Server/Packets/ChatPackets.cpp b/src/server/game/Server/Packets/ChatPackets.cpp
index 260770e65fe..e3df4f5a15d 100644
--- a/src/server/game/Server/Packets/ChatPackets.cpp
+++ b/src/server/game/Server/Packets/ChatPackets.cpp
@@ -92,7 +92,7 @@ void WorldPackets::Chat::ChatMessageEmote::Read()
     Text = _worldPacket.ReadString(len);
 }
 
-void WorldPackets::Chat::Chat::Initalize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message,
+void WorldPackets::Chat::Chat::Initialize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message,
     uint32 achievementId /*= 0*/, std::string channelName /*= ""*/, LocaleConstant locale /*= DEFAULT_LOCALE*/, std::string addonPrefix /*= ""*/)
 {
     // Clear everything because same packet can be used multiple times
diff --git a/src/server/game/Server/Packets/ChatPackets.h b/src/server/game/Server/Packets/ChatPackets.h
index 5bc55952168..3bfac840ecc 100644
--- a/src/server/game/Server/Packets/ChatPackets.h
+++ b/src/server/game/Server/Packets/ChatPackets.h
@@ -151,7 +151,7 @@ namespace WorldPackets
         public:
             Chat() : ServerPacket(SMSG_CHAT, 100) { }
 
-            void Initalize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message, uint32 achievementId = 0, std::string channelName = "", LocaleConstant locale = DEFAULT_LOCALE, std::string addonPrefix = "");
+            void Initialize(ChatMsg chatType, Language language, WorldObject const* sender, WorldObject const* receiver, std::string message, uint32 achievementId = 0, std::string channelName = "", LocaleConstant locale = DEFAULT_LOCALE, std::string addonPrefix = "");
             WorldPacket const* Write() override;
 
             uint8 SlashCmd = 0;     ///< @see enum ChatMsg
diff --git a/src/server/game/Server/Packets/InstancePackets.cpp b/src/server/game/Server/Packets/InstancePackets.cpp
index 50b2a66a8b8..db5bdcbd9e8 100644
--- a/src/server/game/Server/Packets/InstancePackets.cpp
+++ b/src/server/game/Server/Packets/InstancePackets.cpp
@@ -30,3 +30,29 @@ WorldPacket const* WorldPackets::Instance::UpdateInstanceOwnership::Write()
 
     return &_worldPacket;
 }
+
+WorldPacket const* WorldPackets::Instance::InstanceInfo::Write()
+{
+    _worldPacket << int32(LockList.size());
+
+    for (InstanceLockInfos const& lockInfos : LockList)
+        _worldPacket << lockInfos;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInfos const& lockInfos)
+{
+    data << lockInfos.MapID;
+    data << lockInfos.DifficultyID;
+    data << lockInfos.InstanceID;
+    data << lockInfos.TimeRemaining;
+    data << lockInfos.CompletedMask;
+
+    data.WriteBit(lockInfos.Locked);
+    data.WriteBit(lockInfos.Extended);
+
+    data.FlushBits();
+
+    return data;
+}
diff --git a/src/server/game/Server/Packets/InstancePackets.h b/src/server/game/Server/Packets/InstancePackets.h
index 09f6c1efdcb..e38bcb97462 100644
--- a/src/server/game/Server/Packets/InstancePackets.h
+++ b/src/server/game/Server/Packets/InstancePackets.h
@@ -46,7 +46,31 @@ namespace WorldPackets
             int32 IOwnInstance = 0; // Used to control whether "Reset all instances" button appears on the UI - Script_CanShowResetInstances()
                                     // but it has been deperecated in favor of simply checking group leader, being inside an instance or using dungeon finder
         };
+
+        struct InstanceLockInfos
+        {
+            uint64 InstanceID = 0u;
+            uint32 MapID = 0u;
+            uint32 DifficultyID = 0u;
+            int32 TimeRemaining = 0;
+            uint32 CompletedMask = 0u;
+
+            bool Locked = false;
+            bool Extended = false;
+        };
+
+        class InstanceInfo final : public ServerPacket
+        {
+        public:
+            InstanceInfo() : ServerPacket(SMSG_INSTANCE_INFO, 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<InstanceLockInfos> LockList;
+        };
     }
 }
 
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInfos const& lockInfos);
+
 #endif // InstancePackets_h__
diff --git a/src/server/game/Server/Packets/MiscPackets.cpp b/src/server/game/Server/Packets/MiscPackets.cpp
index a12ff537050..bbd3fcb2ba7 100644
--- a/src/server/game/Server/Packets/MiscPackets.cpp
+++ b/src/server/game/Server/Packets/MiscPackets.cpp
@@ -451,3 +451,72 @@ WorldPacket const* WorldPackets::Misc::Dismount::Write()
 
     return &_worldPacket;
 }
+
+void WorldPackets::Misc::SaveCUFProfiles::Read()
+{
+    uint32 count;
+    _worldPacket >> count;
+
+    for (uint8 i = 0; i < count && i < MAX_CUF_PROFILES; i++)
+    {
+        std::unique_ptr<CUFProfile> cufProfile = Trinity::make_unique<CUFProfile>();
+
+        uint8 strLen = _worldPacket.ReadBits(7);
+
+        // Bool Options
+        for (uint8 option = 0; option < CUF_BOOL_OPTIONS_COUNT; option++)
+            cufProfile->BoolOptions.set(option, _worldPacket.ReadBit());
+
+        // Other Options
+        _worldPacket >> cufProfile->FrameHeight;
+        _worldPacket >> cufProfile->FrameWidth;
+
+        _worldPacket >> cufProfile->SortBy;
+        _worldPacket >> cufProfile->HealthText;
+
+        _worldPacket >> cufProfile->TopPoint;
+        _worldPacket >> cufProfile->BottomPoint;
+        _worldPacket >> cufProfile->LeftPoint;
+
+        _worldPacket >> cufProfile->TopOffset;
+        _worldPacket >> cufProfile->BottomOffset;
+        _worldPacket >> cufProfile->LeftOffset;
+
+        cufProfile->ProfileName = _worldPacket.ReadString(strLen);
+
+        CUFProfiles.push_back(std::move(cufProfile));
+    }
+}
+
+WorldPacket const* WorldPackets::Misc::LoadCUFProfiles::Write()
+{
+    _worldPacket << uint32(CUFProfiles.size());
+
+    for (CUFProfile const* cufProfile : CUFProfiles)
+    {
+        _worldPacket.WriteBits(cufProfile->ProfileName.size(), 7);
+
+        // Bool Options
+        for (uint8 option = 0; option < CUF_BOOL_OPTIONS_COUNT; option++)
+            _worldPacket.WriteBit(cufProfile->BoolOptions[option]);
+
+        // Other Options
+        _worldPacket << cufProfile->FrameHeight;
+        _worldPacket << cufProfile->FrameWidth;
+
+        _worldPacket << cufProfile->SortBy;
+        _worldPacket << cufProfile->HealthText;
+
+        _worldPacket << cufProfile->TopPoint;
+        _worldPacket << cufProfile->BottomPoint;
+        _worldPacket << cufProfile->LeftPoint;
+
+        _worldPacket << cufProfile->TopOffset;
+        _worldPacket << cufProfile->BottomOffset;
+        _worldPacket << cufProfile->LeftOffset;
+
+        _worldPacket.WriteString(cufProfile->ProfileName);
+    }
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/MiscPackets.h b/src/server/game/Server/Packets/MiscPackets.h
index fda0e44990e..93bac0d208b 100644
--- a/src/server/game/Server/Packets/MiscPackets.h
+++ b/src/server/game/Server/Packets/MiscPackets.h
@@ -24,6 +24,7 @@
 #include "G3D/Vector3.h"
 #include "Object.h"
 #include "Unit.h"
+#include "Player.h"
 #include "Weather.h"
 
 namespace WorldPackets
@@ -642,6 +643,26 @@ namespace WorldPackets
 
             ObjectGuid Guid;
         };
+
+        class SaveCUFProfiles final : public ClientPacket
+        {
+        public:
+            SaveCUFProfiles(WorldPacket&& packet) : ClientPacket(CMSG_SAVE_CUF_PROFILES, std::move(packet)) { }
+
+            void Read() override;
+
+            std::vector<std::unique_ptr<CUFProfile>> CUFProfiles;
+        };
+
+        class LoadCUFProfiles final : public ServerPacket
+        {
+        public:
+            LoadCUFProfiles() : ServerPacket(SMSG_LOAD_CUF_PROFILES, 20) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<CUFProfile const*> CUFProfiles;
+        };
     }
 }
 
diff --git a/src/server/game/Server/Packets/PartyPackets.cpp b/src/server/game/Server/Packets/PartyPackets.cpp
new file mode 100644
index 00000000000..9696cb6a3fc
--- /dev/null
+++ b/src/server/game/Server/Packets/PartyPackets.cpp
@@ -0,0 +1,716 @@
+/*
+ * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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 "PartyPackets.h"
+
+#include "Player.h"
+#include "Pet.h"
+#include "Vehicle.h"
+#include "SpellAuras.h"
+#include "SpellAuraEffects.h"
+
+WorldPacket const* WorldPackets::Party::PartyCommandResult::Write()
+{
+    _worldPacket.WriteBits(Name.size(), 9);
+
+    _worldPacket.WriteBits(Command, 4);
+    _worldPacket.WriteBits(Result, 6);
+
+    _worldPacket << ResultData;
+    _worldPacket << ResultGUID;
+    _worldPacket.WriteString(Name);
+
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::PartyInviteClient::Read()
+{
+    uint32 targetNameLen, targetRealmLen;
+
+    _worldPacket >> PartyIndex;
+    _worldPacket >> ProposedRoles;
+    _worldPacket >> TargetGUID;
+    _worldPacket >> TargetCfgRealmID;
+
+    targetNameLen = _worldPacket.ReadBits(9);
+    targetRealmLen = _worldPacket.ReadBits(9);
+
+    TargetName = _worldPacket.ReadString(targetNameLen);
+    TargetRealm = _worldPacket.ReadString(targetRealmLen);
+}
+
+WorldPacket const* WorldPackets::Party::PartyInvite::Write()
+{
+    // Order guessed
+    _worldPacket.WriteBit(CanAccept);
+    _worldPacket.WriteBit(MightCRZYou);
+    _worldPacket.WriteBit(MustBeBNetFriend);
+    _worldPacket.WriteBit(AllowMultipleRoles);
+    _worldPacket.WriteBit(IsXRealm);
+
+    _worldPacket.WriteBits(InviterName.size(), 6);
+
+    _worldPacket << InviterGUID;
+    _worldPacket << InviterBNetAccountId;
+
+    _worldPacket << InviterVirtualRealmAddress;
+    _worldPacket << Unk1;
+
+    _worldPacket.WriteBit(IsLocal);
+    _worldPacket.WriteBit(Unk2);
+
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteBits(InviterRealmNameActual.size(), 8);
+    _worldPacket.WriteBits(InviterRealmNameNormalized.size(), 8);
+    _worldPacket.WriteString(InviterRealmNameActual);
+    _worldPacket.WriteString(InviterRealmNameNormalized);
+
+    _worldPacket << ProposedRoles;
+    _worldPacket << int32(LfgSlots.size());
+    _worldPacket << LfgCompletedMask;
+
+    _worldPacket.WriteString(InviterName);
+
+    for (int32 LfgSlot : LfgSlots)
+        _worldPacket << LfgSlot;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::PartyInvite::Initialize(Player* const inviter, int32 proposedRoles, bool canAccept)
+{
+    CanAccept = canAccept;
+
+    InviterName = inviter->GetName();
+    InviterGUID = inviter->GetGUID();
+    InviterBNetAccountId = inviter->GetSession()->GetAccountGUID();
+
+    ProposedRoles = proposedRoles;
+
+    std::string realmName = sObjectMgr->GetRealmName(realmHandle.Index);
+
+    InviterVirtualRealmAddress = GetVirtualRealmAddress();
+    InviterRealmNameActual = realmName;
+    InviterRealmNameNormalized = realmName;
+}
+
+void WorldPackets::Party::PartyInviteResponse::Read()
+{
+    _worldPacket >> PartyIndex;
+
+    Accept = _worldPacket.ReadBit();
+
+    bool hasRolesDesired = _worldPacket.ReadBit();
+    if (hasRolesDesired)
+    {
+        RolesDesired = boost::in_place();
+        _worldPacket >> *RolesDesired;
+    }
+}
+
+void WorldPackets::Party::PartyUninvite::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> TargetGUID;
+
+    uint8 reasonLen = _worldPacket.ReadBits(8);
+    Reason = _worldPacket.ReadString(reasonLen);
+}
+
+WorldPacket const* WorldPackets::Party::GroupDecline::Write()
+{
+    _worldPacket.WriteBits(Name.length(), 9);
+    _worldPacket.FlushBits();
+    _worldPacket.WriteString(Name);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::RequestPartyMemberStats::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> TargetGUID;
+}
+
+WorldPacket const* WorldPackets::Party::PartyMemberStats::Write()
+{
+    _worldPacket.WriteBit(ForEnemy);
+
+    _worldPacket << MemberStats;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::SetPartyLeader::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> TargetGUID;
+}
+
+void WorldPackets::Party::SetRole::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> TargetGUID;
+    _worldPacket >> Role;
+}
+
+WorldPacket const* WorldPackets::Party::RoleChangedInform::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket << From;
+    _worldPacket << ChangedUnit;
+    _worldPacket << OldRole;
+    _worldPacket << NewRole;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::LeaveGroup::Read()
+{
+    _worldPacket >> PartyIndex;
+}
+
+void WorldPackets::Party::SetLootMethod::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> LootMethod;
+    _worldPacket >> LootMasterGUID;
+    _worldPacket >> LootThreshold;
+}
+
+void WorldPackets::Party::MinimapPingClient::Read()
+{
+    _worldPacket >> PositionX;
+    _worldPacket >> PositionY;
+    _worldPacket >> PartyIndex;
+}
+
+WorldPacket const* WorldPackets::Party::MinimapPing::Write()
+{
+    _worldPacket << Sender;
+    _worldPacket << PositionX;
+    _worldPacket << PositionY;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::UpdateRaidTarget::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> Target;
+    _worldPacket >> Symbol;
+}
+
+WorldPacket const* WorldPackets::Party::SendRaidTargetUpdateSingle::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket << Symbol;
+    _worldPacket << Target;
+    _worldPacket << ChangedBy;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Party::SendRaidTargetUpdateAll::Write()
+{
+    _worldPacket << PartyIndex;
+
+    _worldPacket << int32(TargetIcons.size());
+
+    std::map<uint8, ObjectGuid>::const_iterator itr;
+    for (itr = TargetIcons.begin(); itr != TargetIcons.end(); itr++)
+    {
+        _worldPacket << itr->second;
+        _worldPacket << itr->first;
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::ConvertRaid::Read()
+{
+    Raid = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Party::RequestPartyJoinUpdates::Read()
+{
+    _worldPacket >> PartyIndex;
+}
+
+void WorldPackets::Party::SetAssistantLeader::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> Target;
+    Apply = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Party::DoReadyCheck::Read()
+{
+    _worldPacket >> PartyIndex;
+}
+
+WorldPacket const* WorldPackets::Party::ReadyCheckStarted::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket << PartyGUID;
+    _worldPacket << InitiatorGUID;
+    _worldPacket << Duration;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::ReadyCheckResponseClient::Read()
+{
+    _worldPacket >> PartyIndex;
+    IsReady = _worldPacket.ReadBit();
+}
+
+WorldPacket const* WorldPackets::Party::ReadyCheckResponse::Write()
+{
+    _worldPacket << PartyGUID;
+    _worldPacket << Player;
+
+    _worldPacket.WriteBit(IsReady);
+
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Party::ReadyCheckCompleted::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket << PartyGUID;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::OptOutOfLoot::Read()
+{
+    PassOnLoot = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Party::InitiateRolePoll::Read()
+{
+    _worldPacket >> PartyIndex;
+}
+
+WorldPacket const* WorldPackets::Party::RolePollInform::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket << From;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Party::GroupNewLeader::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket.WriteBits(Name.size(), 6);
+    _worldPacket.WriteString(Name);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Party::PartyUpdate::Write()
+{
+    _worldPacket << PartyType;
+    _worldPacket << PartyIndex;
+    _worldPacket << PartyFlags;
+
+    _worldPacket << MyIndex;
+    _worldPacket << PartyGUID;
+    _worldPacket << SequenceNum;
+    _worldPacket << LeaderGUID;
+
+    _worldPacket << PlayerList;
+
+    _worldPacket.WriteBit(LfgInfos.is_initialized());
+    _worldPacket.WriteBit(LootSettings.is_initialized());
+    _worldPacket.WriteBit(DifficultySettings.is_initialized());
+
+    _worldPacket.FlushBits();
+
+    if (LfgInfos.is_initialized())
+        _worldPacket << *LfgInfos;
+
+    if (LootSettings.is_initialized())
+        _worldPacket << *LootSettings;
+
+    if (DifficultySettings.is_initialized())
+        _worldPacket << *DifficultySettings;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::SetEveryoneIsAssistant::Read()
+{
+    _worldPacket >> PartyIndex;
+    EveryoneIsAssistant = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Party::ChangeSubGroup::Read()
+{
+    _worldPacket >> TargetGUID;
+    _worldPacket >> PartyIndex;
+    _worldPacket >> NewSubGroup;
+}
+
+void WorldPackets::Party::SwapSubGroups::Read()
+{
+    _worldPacket >> PartyIndex;
+    _worldPacket >> FirstTarget;
+    _worldPacket >> SecondTarget;
+}
+
+void WorldPackets::Party::ClearRaidMarker::Read()
+{
+    _worldPacket >> MarkerId;
+}
+
+WorldPacket const* WorldPackets::Party::RaidMarkersChanged::Write()
+{
+    _worldPacket << PartyIndex;
+    _worldPacket << ActiveMarkers;
+
+    _worldPacket.WriteBits(RaidMarkers.size(), 4);
+    _worldPacket.FlushBits();
+
+    for (RaidMarker* raidMarker : RaidMarkers)
+    {
+        _worldPacket << raidMarker->TransportGUID;
+        _worldPacket << raidMarker->Location.GetMapId();
+        _worldPacket << raidMarker->Location.PositionXYZStream();
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Party::PartyMemberStats::Initialize(Player const* player)
+{
+    ForEnemy = false;
+
+    MemberStats.GUID = player->GetGUID();
+
+    // Status
+    MemberStats.Status = MEMBER_STATUS_ONLINE;
+
+    if (player->IsPvP())
+        MemberStats.Status |= MEMBER_STATUS_PVP;
+
+    if (!player->IsAlive())
+    {
+        if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
+            MemberStats.Status |= MEMBER_STATUS_GHOST;
+        else
+            MemberStats.Status |= MEMBER_STATUS_DEAD;
+    }
+
+    if (player->IsFFAPvP())
+        MemberStats.Status |= MEMBER_STATUS_PVP_FFA;
+
+    if (player->isAFK())
+        MemberStats.Status |= MEMBER_STATUS_AFK;
+
+    if (player->isDND())
+        MemberStats.Status |= MEMBER_STATUS_DND;
+
+    // Level
+    MemberStats.Level = player->getLevel();
+
+    // Health
+    MemberStats.CurrentHealth = player->GetHealth();
+    MemberStats.MaxHealth = player->GetMaxHealth();
+
+    // Power
+    MemberStats.PowerType = player->getPowerType();
+    MemberStats.CurrentPower = player->GetPower(player->getPowerType());
+    MemberStats.MaxPower = player->GetMaxPower(player->getPowerType());
+
+    // Position
+    MemberStats.ZoneID = player->GetZoneId();
+    MemberStats.PositionX = int16(player->GetPositionX());
+    MemberStats.PositionY = int16(player->GetPositionY());
+    MemberStats.PositionZ = int16(player->GetPositionZ());
+
+    // Unk
+    MemberStats.Unk322 = 0;             // Always 0
+    MemberStats.Unk704[0] = 1;          // Always 1
+    MemberStats.Unk704[1] = 0;          // Always 0
+    MemberStats.Unk200000 = 0;          // Always 0
+
+    MemberStats.Unk2000000 = 0;
+    MemberStats.Unk4000000 = 0;
+
+    // Vehicle
+    if (player->GetVehicle() && player->GetVehicle()->GetVehicleInfo())
+        MemberStats.VehicleSeat = player->GetVehicle()->GetVehicleInfo()->SeatID[player->m_movementInfo.transport.seat];
+
+    // Auras
+    for (uint8 i = 0; i < MAX_AURAS; ++i)
+    {
+        if (AuraApplication const* aurApp = player->GetVisibleAura(i))
+        {
+            WorldPackets::Party::GroupAura aura;
+
+            aura.SpellId = aurApp->GetBase()->GetId();
+            aura.EffectMask = aurApp->GetEffectMask();
+            aura.Scalings = aurApp->GetFlags(); // ??
+
+            if (aurApp->GetFlags() & AFLAG_SCALABLE)
+            {
+                for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
+                {
+                    float scale = 0.f;
+                    if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
+                        scale = float(eff->GetAmount());
+                    aura.EffectScales.push_back(scale);
+                }
+            }
+
+            MemberStats.AuraList.push_back(aura);
+        }
+    }
+
+    // Phases
+    std::set<uint32> const& phases = player->GetPhases();
+    MemberStats.Phases.PhaseShiftFlags = 0x08 | (phases.size() ? 0x10 : 0);
+    MemberStats.Phases.PersonalGUID = ObjectGuid::Empty;
+    for (uint32 phaseId : phases)
+    {
+        WorldPackets::Party::GroupPhase phase;
+        phase.Id = phaseId;
+        phase.Flags = 1;
+        MemberStats.Phases.List.push_back(phase);
+    }
+
+    // Pet
+    if (player->GetPet())
+    {
+        Pet* pet = player->GetPet();
+
+        MemberStats.PetStats = boost::in_place();
+
+        MemberStats.PetStats->GUID = pet->GetGUID();
+        MemberStats.PetStats->Name = pet->GetName();
+        MemberStats.PetStats->ModelId = pet->GetDisplayId();
+
+        MemberStats.PetStats->CurrentHealth = pet->GetHealth();
+        MemberStats.PetStats->MaxHealth = pet->GetMaxHealth();
+
+        for (uint8 i = 0; i < MAX_AURAS; ++i)
+        {
+            if (AuraApplication const* aurApp = pet->GetVisibleAura(i))
+            {
+                WorldPackets::Party::GroupAura aura;
+
+                aura.SpellId = aurApp->GetBase()->GetId();
+                aura.EffectMask = aurApp->GetEffectMask();
+                aura.Scalings = aurApp->GetFlags(); // ??
+
+                if (aurApp->GetFlags() & AFLAG_SCALABLE)
+                {
+                    for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
+                    {
+                        float scale = 0.f;
+                        if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
+                            scale = float(eff->GetAmount());
+                        aura.EffectScales.push_back(scale);
+                    }
+                }
+
+                MemberStats.PetStats->AuraList.push_back(aura);
+            }
+        }
+    }
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhase const& phase)
+{
+    data << phase.Flags;
+    data << phase.Id;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhases const& phases)
+{
+    data << phases.PhaseShiftFlags;
+    data << int32(phases.List.size());
+    data << phases.PersonalGUID;
+
+    for (WorldPackets::Party::GroupPhase const& phase : phases.List)
+        data << phase;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupAura const& aura)
+{
+    data << aura.SpellId;
+    data << aura.Scalings;
+    data << aura.EffectMask;
+
+    data << int32(aura.EffectScales.size());
+    for (float scale : aura.EffectScales)
+        data << scale;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupAura> const& auraList)
+{
+    data << int32(auraList.size());
+    for (WorldPackets::Party::GroupAura const& aura : auraList)
+        data << aura;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPetStats const& petStats)
+{
+    data << petStats.GUID;
+
+    data << petStats.ModelId;
+
+    data << petStats.CurrentHealth;
+    data << petStats.MaxHealth;
+
+    data << petStats.AuraList;
+
+    data.WriteBits(petStats.Name.size(), 8);
+    data.FlushBits();
+    data.WriteString(petStats.Name);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupMemberStats const& memberStats)
+{
+    data << memberStats.GUID;
+
+    for (uint8 i = 0; i < 2; i++)
+        data << memberStats.Unk704[i];
+
+    data << memberStats.Status;
+
+    data << memberStats.PowerType;
+
+    data << memberStats.Unk322;
+
+    data << memberStats.CurrentHealth;
+    data << memberStats.MaxHealth;
+
+    data << memberStats.CurrentPower;
+    data << memberStats.MaxPower;
+
+    data << memberStats.Level;
+
+    data << memberStats.Unk200000;
+
+    data << memberStats.ZoneID;
+
+    data << memberStats.Unk2000000;
+    data << memberStats.Unk4000000;
+
+    data << memberStats.PositionX;
+    data << memberStats.PositionY;
+    data << memberStats.PositionZ;
+
+    data << memberStats.VehicleSeat;
+
+    data << int32(memberStats.AuraList.size());
+
+    data << memberStats.Phases;
+
+    for (WorldPackets::Party::GroupAura const& aura : memberStats.AuraList)
+        data << aura;
+
+    data.WriteBit(memberStats.PetStats.is_initialized());
+    data.FlushBits();
+
+    if (memberStats.PetStats.is_initialized())
+        data << *memberStats.PetStats;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupPlayerInfos> const& playerList)
+{
+    data << int32(playerList.size());
+
+    for (WorldPackets::Party::GroupPlayerInfos const& playerInfos : playerList)
+        data << playerInfos;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPlayerInfos const& playerInfos)
+{
+    data.WriteBits(playerInfos.Name.size(), 6);
+    data.FlushBits();
+    
+    data << playerInfos.GUID;
+    data << playerInfos.Status;
+    data << playerInfos.Subgroup;
+    data << playerInfos.Flags;
+    data << playerInfos.RolesAssigned;
+    data << playerInfos.Class;
+
+    data.WriteString(playerInfos.Name);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLfgInfos const& lfgInfos)
+{
+    data << lfgInfos.MyFlags;
+    data << lfgInfos.Slot;
+    data << lfgInfos.MyRandomSlot;
+    data << lfgInfos.MyPartialClear;
+    data << lfgInfos.MyGearDiff;
+    data << lfgInfos.MyStrangerCount;
+    data << lfgInfos.MyKickVoteCount;
+    data << lfgInfos.BootCount;
+
+    data.WriteBit(lfgInfos.Aborted);
+    data.WriteBit(lfgInfos.MyFirstReward);
+    data.FlushBits();
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLootSettings const& lootSettings)
+{
+    data << lootSettings.Method;
+    data << lootSettings.LootMaster;
+    data << lootSettings.Threshold;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupDifficultySettings const& difficultySettings)
+{
+    data << difficultySettings.DungeonDifficultyID;
+    data << difficultySettings.RaidDifficultyID;
+    data << difficultySettings.LegacyRaidDifficultyID;
+
+    return data;
+}
diff --git a/src/server/game/Server/Packets/PartyPackets.h b/src/server/game/Server/Packets/PartyPackets.h
new file mode 100644
index 00000000000..ed3eed60ef4
--- /dev/null
+++ b/src/server/game/Server/Packets/PartyPackets.h
@@ -0,0 +1,616 @@
+/*
+ * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
+ *
+ * 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 PartyPackets_h__
+#define PartyPackets_h__
+
+#include "Packet.h"
+#include "ObjectGuid.h"
+#include "Group.h"
+
+namespace WorldPackets
+{
+    namespace Party
+    {
+        class PartyCommandResult final : public ServerPacket
+        {
+        public:
+            PartyCommandResult() : ServerPacket(SMSG_PARTY_COMMAND_RESULT, 23) { }
+
+            WorldPacket const* Write() override;
+
+            std::string Name;
+            uint8 Command = 0u;
+            uint8 Result = 0u;
+            uint32 ResultData = 0u;
+            ObjectGuid ResultGUID;
+        };
+
+        class PartyInviteClient final : public ClientPacket
+        {
+        public:
+            PartyInviteClient(WorldPacket&& packet) : ClientPacket(CMSG_PARTY_INVITE, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            int32 ProposedRoles = 0;
+            int32 TargetCfgRealmID = 0;
+            std::string TargetName;
+            std::string TargetRealm;
+            ObjectGuid TargetGUID;
+        };
+
+        class PartyInvite final : public ServerPacket
+        {
+        public:
+            PartyInvite() : ServerPacket(SMSG_PARTY_INVITE, 55) { }
+
+            WorldPacket const* Write() override;
+            void Initialize(Player* const inviter, int32 proposedRoles, bool canAccept);
+
+            bool MightCRZYou = false;
+            bool MustBeBNetFriend = false;
+            bool AllowMultipleRoles = false;
+            bool Unk2 = false;
+            int16 Unk1 = 0;
+
+            bool CanAccept = false;
+
+            // Inviter
+            ObjectGuid InviterGUID;
+			ObjectGuid InviterBNetAccountId;
+            std::string InviterName;
+            
+            // Realm
+            bool IsXRealm = false;
+            bool IsLocal = true;
+            uint32 InviterVirtualRealmAddress = 0u;
+            std::string InviterRealmNameActual;
+            std::string InviterRealmNameNormalized;
+
+            // Lfg
+            int32 ProposedRoles = 0;
+            int32 LfgCompletedMask = 0;
+            std::vector<int32> LfgSlots;
+        };
+
+        class PartyInviteResponse final : public ClientPacket
+        {
+        public:
+            PartyInviteResponse(WorldPacket&& packet) : ClientPacket(CMSG_PARTY_INVITE_RESPONSE, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            bool Accept = false;
+            Optional<int32> RolesDesired;
+        };
+
+        class PartyUninvite final : public ClientPacket
+        {
+        public:
+            PartyUninvite(WorldPacket&& packet) : ClientPacket(CMSG_PARTY_UNINVITE, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid TargetGUID;
+            std::string Reason;
+        };
+
+        class GroupDecline final : public ServerPacket
+        {
+        public:
+            GroupDecline(std::string const& name) : ServerPacket(SMSG_GROUP_DECLINE, 2 + name.size()), Name(name) { }
+
+            WorldPacket const* Write() override;
+
+            std::string Name;
+        };
+
+        class RequestPartyMemberStats final : public ClientPacket
+        {
+        public:
+            RequestPartyMemberStats(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_PARTY_MEMBER_STATS, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid TargetGUID;
+        };
+
+        struct GroupPhase
+        {
+            uint16 Flags = 0u;
+            uint16 Id = 0u;
+        };
+
+        struct GroupPhases
+        {
+            int32 PhaseShiftFlags = 0;
+            ObjectGuid PersonalGUID;
+            std::vector<GroupPhase> List;
+        };
+
+        struct GroupAura
+        {
+            uint32 SpellId = 0u;
+            uint8 Scalings = 0;
+            uint32 EffectMask = 0u;
+            std::vector<float> EffectScales;
+        };
+
+        struct GroupPetStats
+        {
+            ObjectGuid GUID;
+            std::string Name;
+            int16 ModelId = 0;
+
+            int32 CurrentHealth = 0;
+            int32 MaxHealth = 0;
+
+            std::vector<GroupAura> AuraList;
+        };
+        
+        struct GroupMemberStats
+        {
+            ObjectGuid GUID;
+            int16 Level = 0;
+            int16 Status = 0;
+
+            int32 CurrentHealth = 0;
+            int32 MaxHealth;
+
+            uint8 PowerType = 0u;
+            int16 CurrentPower = 0;
+            int16 MaxPower = 0;
+
+            int16 ZoneID = 0;
+            int16 PositionX = 0;
+            int16 PositionY = 0;
+            int16 PositionZ = 0;
+
+            int32 VehicleSeat = 0;
+
+            GroupPhases Phases;
+            std::vector<GroupAura> AuraList;
+            Optional<GroupPetStats> PetStats;
+
+            int16 Unk322 = 0;
+            int16 Unk200000 = 0;
+            int16 Unk2000000 = 0;
+            int32 Unk4000000 = 0;
+            int8 Unk704[2];
+        };
+
+        class PartyMemberStats final : public ServerPacket
+        {
+        public:
+            PartyMemberStats() : ServerPacket(SMSG_PARTY_MEMBER_STATE, 80) { }
+
+            WorldPacket const* Write() override;
+            void Initialize(Player const* player);
+
+            GroupMemberStats MemberStats;
+            bool ForEnemy = false;
+        };
+
+        class SetPartyLeader final : public ClientPacket
+        {
+        public:
+            SetPartyLeader(WorldPacket&& packet) : ClientPacket(CMSG_SET_PARTY_LEADER, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid TargetGUID;
+        };
+
+        class SetRole final : public ClientPacket
+        {
+        public:
+            SetRole(WorldPacket&& packet) : ClientPacket(CMSG_SET_ROLE, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid TargetGUID;
+            int32 Role = 0;
+        };
+
+        class RoleChangedInform final : public ServerPacket
+        {
+        public:
+            RoleChangedInform() : ServerPacket(SMSG_ROLE_CHANGED_INFORM, 41) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid From;
+            ObjectGuid ChangedUnit;
+            int32 OldRole = 0;
+            int32 NewRole = 0;
+        };
+
+        class LeaveGroup final : public ClientPacket
+        {
+        public:
+            LeaveGroup(WorldPacket&& packet) : ClientPacket(CMSG_LEAVE_GROUP, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+        };
+
+        class SetLootMethod final : public ClientPacket
+        {
+        public:
+            SetLootMethod(WorldPacket&& packet) : ClientPacket(CMSG_SET_LOOT_METHOD, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid LootMasterGUID;
+            uint8 LootMethod = 0u;
+            uint32 LootThreshold = 0u;
+        };
+
+        class MinimapPingClient final : public ClientPacket
+        {
+        public:
+            MinimapPingClient(WorldPacket&& packet) : ClientPacket(CMSG_MINIMAP_PING, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            float PositionX = 0.f;
+            float PositionY = 0.f;
+        };
+
+        class MinimapPing final : public ServerPacket
+        {
+        public:
+            MinimapPing() : ServerPacket(SMSG_MINIMAP_PING, 24) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Sender;
+            float PositionX = 0.f;
+            float PositionY = 0.f;
+        };
+
+        class UpdateRaidTarget final : public ClientPacket
+        {
+        public:
+            UpdateRaidTarget(WorldPacket&& packet) : ClientPacket(CMSG_UPDATE_RAID_TARGET, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid Target;
+            int8 Symbol = 0;
+        };
+
+        class SendRaidTargetUpdateSingle final : public ServerPacket
+        {
+        public:
+            SendRaidTargetUpdateSingle() : ServerPacket(SMSG_SEND_RAID_TARGET_UPDATE_SINGLE, 34) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid Target;
+            ObjectGuid ChangedBy;
+            int8 Symbol = 0;
+        };
+
+        class SendRaidTargetUpdateAll final : public ServerPacket
+        {
+        public:
+            SendRaidTargetUpdateAll() : ServerPacket(SMSG_SEND_RAID_TARGET_UPDATE_ALL, 1 + TARGET_ICONS_COUNT * (1 + 16)) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            std::map<uint8, ObjectGuid> TargetIcons;
+        };
+
+        class ConvertRaid final : public ClientPacket
+        {
+        public:
+            ConvertRaid(WorldPacket&& packet) : ClientPacket(CMSG_CONVERT_RAID, std::move(packet)) { }
+
+            void Read() override;
+
+            bool Raid = false;
+        };
+
+        class RequestPartyJoinUpdates final : public ClientPacket
+        {
+        public:
+            RequestPartyJoinUpdates(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_PARTY_JOIN_UPDATES, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+        };
+
+        class SetAssistantLeader final : public ClientPacket
+        {
+        public:
+            SetAssistantLeader(WorldPacket&& packet) : ClientPacket(CMSG_SET_ASSISTANT_LEADER, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Target;
+            int8 PartyIndex = 0;
+            bool Apply = false;
+        };
+
+        class DoReadyCheck final : public ClientPacket
+        {
+        public:
+            DoReadyCheck(WorldPacket&& packet) : ClientPacket(CMSG_DO_READY_CHECK, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+        };
+
+        class ReadyCheckStarted final : public ServerPacket
+        {
+        public:
+            ReadyCheckStarted() : ServerPacket(SMSG_READY_CHECK_STARTED, 37) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid PartyGUID;
+            ObjectGuid InitiatorGUID;
+            uint32 Duration = 0u;
+        };
+
+        class ReadyCheckResponseClient final : public ClientPacket
+        {
+        public:
+            ReadyCheckResponseClient(WorldPacket&& packet) : ClientPacket(CMSG_READY_CHECK_RESPONSE, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            bool IsReady = false;
+        };
+
+        class ReadyCheckResponse final : public ServerPacket
+        {
+        public:
+            ReadyCheckResponse() : ServerPacket(SMSG_READY_CHECK_RESPONSE, 19) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid PartyGUID;
+            ObjectGuid Player;
+            bool IsReady = false;
+        };
+
+        class ReadyCheckCompleted final : public ServerPacket
+        {
+        public:
+            ReadyCheckCompleted() : ServerPacket(SMSG_READY_CHECK_COMPLETED, 17) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid PartyGUID;
+        };
+
+        class RequestRaidInfo final : public ClientPacket
+        {
+        public:
+            RequestRaidInfo(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_RAID_INFO, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class OptOutOfLoot final : public ClientPacket
+        {
+        public:
+            OptOutOfLoot(WorldPacket&& packet) : ClientPacket(CMSG_OPT_OUT_OF_LOOT, std::move(packet)) { }
+
+            void Read() override;
+
+            bool PassOnLoot = false;
+        };
+
+        class InitiateRolePoll final : public ClientPacket
+        {
+        public:
+            InitiateRolePoll(WorldPacket&& packet) : ClientPacket(CMSG_INITIATE_ROLE_POLL, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+        };
+
+        class RolePollInform final : public ServerPacket
+        {
+        public:
+            RolePollInform() : ServerPacket(SMSG_ROLE_POLL_INFORM, 17) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            ObjectGuid From;
+        };
+
+        class GroupNewLeader final : public ServerPacket
+        {
+        public:
+            GroupNewLeader() : ServerPacket(SMSG_GROUP_NEW_LEADER, 14) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            std::string Name;
+        };
+
+        struct GroupPlayerInfos
+        {
+            ObjectGuid GUID;
+            std::string Name;
+            uint8 Class = 0;
+
+            uint8 Status = 0u;
+            uint8 Subgroup = 0u;
+            uint8 Flags = 0u;
+            uint8 RolesAssigned = 0u;
+        };
+
+        struct GroupLfgInfos
+        {
+            int32 Slot = 0u;
+            int8 BootCount = 0;
+
+            bool Aborted = false;
+
+            int32 MyRandomSlot = 0;
+            uint8 MyFlags = 0u;
+            uint8 MyPartialClear = 0u;
+            float MyGearDiff = 0.f;
+
+            int8 MyStrangerCount = 0;
+            int8 MyKickVoteCount = 0;
+
+            bool MyFirstReward = false;
+        };
+
+        struct GroupLootSettings
+        {
+            uint8 Method = 0u;
+            ObjectGuid LootMaster;
+            uint8 Threshold = 0u;
+        };
+
+        struct GroupDifficultySettings
+        {
+            uint32 DungeonDifficultyID = 0u;
+            uint32 RaidDifficultyID = 0u;
+            uint32 LegacyRaidDifficultyID = 0u;
+        };
+
+        class PartyUpdate final : public ServerPacket
+        {
+        public:
+            PartyUpdate() : ServerPacket(SMSG_PARTY_UPDATE, 200) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyFlags = 0;
+            int8 PartyIndex = 0;
+            int8 PartyType = 0;
+            
+            ObjectGuid PartyGUID;
+            ObjectGuid LeaderGUID;
+
+            int32 MyIndex = 0;
+            int32 SequenceNum = 0;
+
+            std::vector<GroupPlayerInfos> PlayerList;
+
+            Optional<GroupLfgInfos> LfgInfos;
+            Optional<GroupLootSettings> LootSettings;
+            Optional<GroupDifficultySettings> DifficultySettings;
+        };
+
+        class SetEveryoneIsAssistant final : public ClientPacket
+        {
+        public:
+            SetEveryoneIsAssistant(WorldPacket&& packet) : ClientPacket(CMSG_SET_EVERYONE_IS_ASSISTANT, std::move(packet)) { }
+
+            void Read() override;
+
+            int8 PartyIndex = 0;
+            bool EveryoneIsAssistant = false;
+        };
+
+        class ChangeSubGroup final : public ClientPacket
+        {
+        public:
+            ChangeSubGroup(WorldPacket&& packet) : ClientPacket(CMSG_CHANGE_SUB_GROUP, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid TargetGUID;
+            int8 PartyIndex = 0;
+            uint8 NewSubGroup = 0u;
+        };
+
+        class SwapSubGroups final : public ClientPacket
+        {
+        public:
+            SwapSubGroups(WorldPacket&& packet) : ClientPacket(CMSG_SWAP_SUB_GROUPS, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid FirstTarget;
+            ObjectGuid SecondTarget;
+            int8 PartyIndex = 0;
+        };
+
+        class ClearRaidMarker final : public ClientPacket
+        {
+        public:
+            ClearRaidMarker(WorldPacket&& packet) : ClientPacket(CMSG_CLEAR_RAID_MARKER, std::move(packet)) { }
+
+            void Read() override;
+
+            uint8 MarkerId = 0u;
+        };
+
+        class RaidMarkersChanged final : public ServerPacket
+        {
+        public:
+            RaidMarkersChanged() : ServerPacket(SMSG_RAID_MARKERS_CHANGED, 6) { }
+
+            WorldPacket const* Write() override;
+
+            int8 PartyIndex = 0;
+            uint32 ActiveMarkers = 0u;
+
+            std::vector<RaidMarker*> RaidMarkers;
+        };
+    }
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhase const& phase);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPhases const& phases);
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupAura const& aura);
+ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupAura> const& auraList);
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPetStats const& petStats);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupMemberStats const& memberStats);
+
+ByteBuffer& operator<<(ByteBuffer& data, std::vector<WorldPackets::Party::GroupPlayerInfos> const& playerList);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupPlayerInfos const& playerInfos);
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLfgInfos const& lfgInfos);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupLootSettings const& lootSettings);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::GroupDifficultySettings const& difficultySettings);
+
+#endif // PartyPackets_h__
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 4c87e00fc91..9b30be91ee3 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -33,6 +33,7 @@
 #include "Packets/GameObjectPackets.h"
 #include "Packets/GarrisonPackets.h"
 #include "Packets/GuildPackets.h"
+#include "Packets/PartyPackets.h"
 #include "Packets/InspectPackets.h"
 #include "Packets/InstancePackets.h"
 #include "Packets/ItemPackets.h"
@@ -259,7 +260,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CHALLENGE_MODE_REQUEST_MAP_STATS,                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHANGE_BAG_SLOT_FLAG,                               STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHANGE_MONUMENT_APPEARANCE,                         STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CHANGE_SUB_GROUP,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupChangeSubGroupOpcode );
+    DEFINE_HANDLER(CMSG_CHANGE_SUB_GROUP,                                   STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::ChangeSubGroup, &WorldSession::HandleChangeSubGroupOpcode);
     DEFINE_HANDLER(CMSG_CHARACTER_RENAME_REQUEST,                           STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::Character::CharacterRenameRequest, &WorldSession::HandleCharRenameOpcode);
     DEFINE_HANDLER(CMSG_CHAR_CUSTOMIZE,                                     STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::Character::CharCustomize, &WorldSession::HandleCharCustomizeOpcode);
     DEFINE_HANDLER(CMSG_CHAR_DELETE,                                        STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::Character::CharDelete, &WorldSession::HandleCharDeleteOpcode);
@@ -315,7 +316,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CHECK_RAF_EMAIL_ENABLED,                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHECK_WOW_TOKEN_VETERAN_ELIGIBILITY,                STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHOICE_RESPONSE,                                    STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_CLEAR_RAID_MARKER,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_CLEAR_RAID_MARKER,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::ClearRaidMarker, &WorldSession::HandleClearRaidMarker);
     DEFINE_HANDLER(CMSG_CLEAR_TRADE_ITEM,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Trade::ClearTradeItem, &WorldSession::HandleClearTradeItemOpcode);
     DEFINE_HANDLER(CMSG_CLIENT_PORT_GRAVEYARD,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::PortGraveyard, &WorldSession::HandlePortGraveyard);
     DEFINE_HANDLER(CMSG_CLOSE_INTERACTION,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -331,7 +332,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_COMPLETE_MOVIE,                                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CONFIRM_RESPEC_WIPE,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleConfirmRespecWipeOpcode   );
     DEFINE_HANDLER(CMSG_CONNECT_TO_FAILED,                                  STATUS_NEVER,     PROCESS_INPLACE,      WorldPacket, &WorldSession::Handle_EarlyProccess);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CONVERT_RAID,                            STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupRaidConvertOpcode    );
+    DEFINE_HANDLER(CMSG_CONVERT_RAID,                                       STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::ConvertRaid, &WorldSession::HandleConvertRaidOpcode);
     DEFINE_HANDLER(CMSG_CREATE_CHARACTER,                                   STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::Character::CreateCharacter, &WorldSession::HandleCharCreateOpcode);
     DEFINE_HANDLER(CMSG_CREATE_SHIPMENT,                                    STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_DB_QUERY_BULK,                                      STATUS_AUTHED,    PROCESS_INPLACE,      WorldPackets::Query::DBQueryBulk, &WorldSession::HandleDBQueryBulk);
@@ -357,7 +358,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_DISCARDED_TIME_SYNC_ACKS,                           STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_DISMISS_CRITTER,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleDismissCritter            );
     DEFINE_HANDLER(CMSG_DO_MASTER_LOOT_ROLL,                                STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_DO_READY_CHECK,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRaidReadyCheckOpcode      );
+    DEFINE_HANDLER(CMSG_DO_READY_CHECK,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::DoReadyCheck, &WorldSession::HandleDoReadyCheckOpcode);
     DEFINE_HANDLER(CMSG_DUEL_RESPONSE,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Duel::DuelResponse, &WorldSession::HandleDuelResponseOpcode);
     DEFINE_HANDLER(CMSG_EJECT_PASSENGER,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Vehicle::EjectPassenger, &WorldSession::HandleEjectPassenger);
     DEFINE_HANDLER(CMSG_EMOTE,                                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Chat::EmoteClient, &WorldSession::HandleEmoteOpcode);
@@ -458,7 +459,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_HEARTH_AND_RESURRECT,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Battleground::HearthAndResurrect, &WorldSession::HandleHearthAndResurrect);
     DEFINE_HANDLER(CMSG_IGNORE_TRADE,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Trade::IgnoreTrade, &WorldSession::HandleIgnoreTradeOpcode);
     DEFINE_HANDLER(CMSG_INCREASE_CAST_TIME_FOR_SPELL,                       STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_INITIATE_ROLE_POLL,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRolePollBeginOpcode);
+    DEFINE_HANDLER(CMSG_INITIATE_ROLE_POLL,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::InitiateRolePoll, &WorldSession::HandleInitiateRolePoll);
     DEFINE_HANDLER(CMSG_INITIATE_TRADE,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Trade::InitiateTrade, &WorldSession::HandleInitiateTradeOpcode);
     DEFINE_HANDLER(CMSG_INSPECT,                                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Inspect::Inspect, &WorldSession::HandleInspectOpcode);
     DEFINE_HANDLER(CMSG_INSPECT_PVP,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Inspect::InspectPVPRequest, &WorldSession::HandleInspectPVP);
@@ -471,7 +472,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_KEYBOUND_OVERRIDE,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_LEARN_PET_SPECIALIZATION_GROUP,                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_LEARN_TALENTS,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Talent::LearnTalents, &WorldSession::HandleLearnTalentsOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_LEAVE_GROUP,                             STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupDisbandOpcode        );
+    DEFINE_HANDLER(CMSG_LEAVE_GROUP,                                        STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::LeaveGroup, &WorldSession::HandleLeaveGroupOpcode);
     DEFINE_HANDLER(CMSG_LEAVE_PET_BATTLE_QUEUE,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_LFG_LIST_APPLY_TO_GROUP,                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_LFG_LIST_CANCEL_APPLICATION,                        STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -514,7 +515,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_MAIL_TAKE_ITEM,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Mail::MailTakeItem, &WorldSession::HandleMailTakeItem);
     DEFINE_HANDLER(CMSG_MAIL_TAKE_MONEY,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Mail::MailTakeMoney, &WorldSession::HandleMailTakeMoney);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_MASTER_LOOT_ITEM,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLootMasterGiveOpcode      );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_MINIMAP_PING,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleMinimapPingOpcode         );
+    DEFINE_HANDLER(CMSG_MINIMAP_PING,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::MinimapPingClient, &WorldSession::HandleMinimapPingOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_MISSILE_TRAJECTORY_COLLISION,            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleUpdateProjectilePosition  );
     DEFINE_HANDLER(CMSG_MOUNT_SET_FAVORITE,                                 STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_MOUNT_SPECIAL_ANIM,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleMountSpecialAnimOpcode    );
@@ -590,10 +591,10 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_OPEN_MISSION_NPC,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_OPEN_SHIPMENT_NPC,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_OPEN_TRADESKILL_NPC,                                STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_OPT_OUT_OF_LOOT,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleOptOutOfLootOpcode        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_INVITE,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupInviteOpcode         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_INVITE_RESPONSE,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupInviteResponseOpcode );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_UNINVITE,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupUninviteOpcode       );
+    DEFINE_HANDLER(CMSG_OPT_OUT_OF_LOOT,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::OptOutOfLoot, &WorldSession::HandleOptOutOfLootOpcode);
+    DEFINE_HANDLER(CMSG_PARTY_INVITE,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::PartyInviteClient, &WorldSession::HandlePartyInviteOpcode);
+    DEFINE_HANDLER(CMSG_PARTY_INVITE_RESPONSE,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::PartyInviteResponse, &WorldSession::HandlePartyInviteResponseOpcode);
+    DEFINE_HANDLER(CMSG_PARTY_UNINVITE,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::PartyUninvite, &WorldSession::HandlePartyUninviteOpcode);
     DEFINE_HANDLER(CMSG_PETITION_BUY,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionBuy, &WorldSession::HandlePetitionBuy);
     DEFINE_HANDLER(CMSG_PETITION_RENAME_GUILD,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionRenameGuild, &WorldSession::HandlePetitionRenameGuild);
     DEFINE_HANDLER(CMSG_PETITION_SHOW_LIST,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionShowList, &WorldSession::HandlePetitionShowList);
@@ -655,7 +656,7 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_QUEST_PUSH_RESULT,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleQuestPushResult           );
     DEFINE_HANDLER(CMSG_QUEUED_MESSAGES_END,                                STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_RANDOM_ROLL,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::RandomRollClient, &WorldSession::HandleRandomRollOpcode);
-    DEFINE_HANDLER(CMSG_READY_CHECK_RESPONSE,                               STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_READY_CHECK_RESPONSE,                               STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::ReadyCheckResponseClient, &WorldSession::HandleReadyCheckResponseOpcode);
     DEFINE_HANDLER(CMSG_READ_ITEM,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::ReadItem, &WorldSession::HandleReadItem);
     DEFINE_HANDLER(CMSG_RECLAIM_CORPSE,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::ReclaimCorpse, &WorldSession::HandleReclaimCorpse);
     DEFINE_HANDLER(CMSG_RECRUIT_A_FRIEND,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -676,12 +677,12 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_REQUEST_GUILD_REWARDS_LIST,                         STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Guild::RequestGuildRewardsList, &WorldSession::HandleRequestGuildRewardsList);
     DEFINE_HANDLER(CMSG_REQUEST_HONOR_STATS,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Inspect::RequestHonorStats, &WorldSession::HandleRequestHonorStatsOpcode);
     DEFINE_HANDLER(CMSG_REQUEST_LFG_LIST_BLACKLIST,                         STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PARTY_JOIN_UPDATES,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupRequestJoinUpdates);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PARTY_MEMBER_STATS,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestPartyMemberStatsOpcode);
+    DEFINE_HANDLER(CMSG_REQUEST_PARTY_JOIN_UPDATES,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::RequestPartyJoinUpdates, &WorldSession::HandleRequestPartyJoinUpdates);
+    DEFINE_HANDLER(CMSG_REQUEST_PARTY_MEMBER_STATS,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::RequestPartyMemberStats, &WorldSession::HandleRequestPartyMemberStatsOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PET_INFO,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestPetInfoOpcode      );
     DEFINE_HANDLER(CMSG_REQUEST_PLAYED_TIME,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Character::RequestPlayedTime, &WorldSession::HandlePlayedTime);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PVP_REWARDS,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleRequestPvpReward          );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_RAID_INFO,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestRaidInfoOpcode     );
+    DEFINE_HANDLER(CMSG_REQUEST_RAID_INFO,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::RequestRaidInfo, &WorldSession::HandleRequestRaidInfoOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_RATED_BATTLEFIELD_INFO,          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRequestRatedBattlefieldInfo);
     DEFINE_HANDLER(CMSG_REQUEST_RESEARCH_HISTORY,                           STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_STABLED_PETS,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleListStabledPetsOpcode     );
@@ -695,7 +696,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_RESURRECT_RESPONSE,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::ResurrectResponse, &WorldSession::HandleResurrectResponse);
     DEFINE_HANDLER(CMSG_REVERT_MONUMENT_APPEARANCE,                         STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_RIDE_VEHICLE_INTERACT,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Vehicle::RideVehicleInteract, &WorldSession::HandleRideVehicleInteract);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SAVE_CUF_PROFILES,                       STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleSaveCUFProfiles           );
+    DEFINE_HANDLER(CMSG_SAVE_CUF_PROFILES,                                  STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Misc::SaveCUFProfiles, &WorldSession::HandleSaveCUFProfiles);
     DEFINE_HANDLER(CMSG_SAVE_EQUIPMENT_SET,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::EquipmentSet::SaveEquipmentSet, &WorldSession::HandleEquipmentSetSave);
     DEFINE_HANDLER(CMSG_SAVE_GUILD_EMBLEM,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::SaveGuildEmblem, &WorldSession::HandleSaveGuildEmblem);
     DEFINE_HANDLER(CMSG_SCENE_PLAYBACK_CANCELED,                            STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Scenes::ScenePlaybackCanceled, &WorldSession::HandleScenePlaybackCanceled);
@@ -716,7 +717,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SET_ACTIVE_MOVER,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Movement::SetActiveMover, &WorldSession::HandleSetActiveMoverOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_ACTIVE_VOICE_CHANNEL,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetActiveVoiceChannel     );
     DEFINE_HANDLER(CMSG_SET_ADVANCED_COMBAT_LOGGING,                        STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_ASSISTANT_LEADER,                    STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupAssistantLeaderOpcode);
+    DEFINE_HANDLER(CMSG_SET_ASSISTANT_LEADER,                               STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::SetAssistantLeader, &WorldSession::HandleSetAssistantLeaderOpcode);
     DEFINE_HANDLER(CMSG_SET_BACKPACK_AUTOSORT_DISABLED,                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_BANK_AUTOSORT_DISABLED,                         STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_BANK_BAG_SLOT_FLAG,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -724,22 +725,22 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SET_CURRENCY_FLAGS,                                 STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_DIFFICULTY_ID,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_DUNGEON_DIFFICULTY,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::SetDungeonDifficulty, &WorldSession::HandleSetDungeonDifficultyOpcode);
-    DEFINE_HANDLER(CMSG_SET_EVERYONE_IS_ASSISTANT,                          STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_SET_EVERYONE_IS_ASSISTANT,                          STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::SetEveryoneIsAssistant, &WorldSession::HandleSetEveryoneIsAssistant);
     DEFINE_HANDLER(CMSG_SET_FACTION_AT_WAR,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Character::SetFactionAtWar, &WorldSession::HandleSetFactionAtWar);
     DEFINE_HANDLER(CMSG_SET_FACTION_INACTIVE,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Character::SetFactionInactive, &WorldSession::HandleSetFactionInactiveOpcode);
     DEFINE_HANDLER(CMSG_SET_FACTION_NOT_AT_WAR,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Character::SetFactionNotAtWar, &WorldSession::HandleSetFactionNotAtWar);
     DEFINE_HANDLER(CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT,                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_LFG_BONUS_FACTION_ID,                           STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_LOOT_METHOD,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLootMethodOpcode          );
+    DEFINE_HANDLER(CMSG_SET_LOOT_METHOD,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::SetLootMethod, &WorldSession::HandleSetLootMethodOpcode);
     DEFINE_HANDLER(CMSG_SET_LOOT_SPECIALIZATION,                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_PARTY_ASSIGNMENT,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePartyAssignmentOpcode     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_PARTY_LEADER,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupSetLeaderOpcode      );
+    DEFINE_HANDLER(CMSG_SET_PARTY_LEADER,                                   STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::SetPartyLeader, &WorldSession::HandleSetPartyLeaderOpcode);
     DEFINE_HANDLER(CMSG_SET_PET_SLOT,                                       STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_PLAYER_DECLINED_NAMES,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetPlayerDeclinedNames    );
     DEFINE_HANDLER(CMSG_SET_PREFERRED_CEMETERY,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_PVP,                                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_RAID_DIFFICULTY,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::SetRaidDifficulty, &WorldSession::HandleSetRaidDifficultyOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_ROLE,                                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupSetRolesOpcode       );
+    DEFINE_HANDLER(CMSG_SET_ROLE,                                           STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::SetRole, &WorldSession::HandleSetRoleOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_SAVED_INSTANCE_EXTEND,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetSavedInstanceExtend    );
     DEFINE_HANDLER(CMSG_SET_SELECTION,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::SetSelection, &WorldSession::HandleSetSelectionOpcode);
     DEFINE_HANDLER(CMSG_SET_SHEATHED,                                       STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Combat::SetSheathed, &WorldSession::HandleSetSheathedOpcode);
@@ -775,7 +776,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SUSPEND_TOKEN_RESPONSE,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SWAP_INV_ITEM,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::SwapInvItem, &WorldSession::HandleSwapInvItemOpcode);
     DEFINE_HANDLER(CMSG_SWAP_ITEM,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::SwapItem, &WorldSession::HandleSwapItem);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SWAP_SUB_GROUPS,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupSwapSubGroupOpcode   );
+    DEFINE_HANDLER(CMSG_SWAP_SUB_GROUPS,                                    STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Party::SwapSubGroups, &WorldSession::HandleSwapSubGroupsOpcode);
     DEFINE_HANDLER(CMSG_SWAP_VOID_ITEM,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::VoidStorage::SwapVoidItem, &WorldSession::HandleVoidSwapItem);
     DEFINE_HANDLER(CMSG_TABARD_VENDOR_ACTIVATE,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleTabardVendorActivateOpcode);
     DEFINE_HANDLER(CMSG_TALK_TO_GOSSIP,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleGossipHelloOpcode);
@@ -809,7 +810,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_UPDATE_ACCOUNT_DATA,                                STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::ClientConfig::UserClientUpdateAccountData, &WorldSession::HandleUpdateAccountData);
     DEFINE_HANDLER(CMSG_UPDATE_CLIENT_SETTINGS,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_UPDATE_MISSILE_TRAJECTORY,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleUpdateMissileTrajectory   );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_UPDATE_RAID_TARGET,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRaidTargetUpdateOpcode    );
+    DEFINE_HANDLER(CMSG_UPDATE_RAID_TARGET,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::UpdateRaidTarget, &WorldSession::HandleUpdateRaidTargetOpcode);
     DEFINE_HANDLER(CMSG_UPDATE_WOW_TOKEN_AUCTIONABLE_LIST,                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Token::UpdateListedAuctionableTokens, &WorldSession::HandleUpdateListedAuctionableTokens);
     DEFINE_HANDLER(CMSG_UPDATE_WOW_TOKEN_COUNT,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_UPGRADE_GARRISON,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -1169,10 +1170,10 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_MESSAGE,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_POI,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_ACTION_THROTTLED,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DECLINE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DESTROYED,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_NEW_LEADER,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_UNINVITE,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DECLINE,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DESTROYED,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_NEW_LEADER,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_UNINVITE,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ACHIEVEMENT_DELETED,               STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ACHIEVEMENT_EARNED,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ACHIEVEMENT_MEMBERS,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1248,7 +1249,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_START,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_ENCOUNTER_TIMER_START,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_GROUP_SIZE_CHANGED,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_INFO,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_INFO,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_RESET,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_RESET_FAILED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INSTANCE_SAVE_CREATED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1298,7 +1299,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_ACCOUNT_RESTORE_RESULT,      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_CHARACTER_COPY_RESULT,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST_RESULT, STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_CUF_PROFILES,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_CUF_PROFILES,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_EQUIPMENT_SET,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOAD_SELECTED_TROPHY_RESULT,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOGIN_SET_TIME_SPEED,                    STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1327,7 +1328,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MAP_OBJ_EVENTS,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MASTER_LOOT_CANDIDATE_LIST,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MESSAGE_BOX,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MINIMAP_PING,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MINIMAP_PING,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_COMPONENTED_DATA,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_CREATURE_DATA,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MISSILE_CANCEL,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1431,11 +1432,11 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_OPEN_SHIPMENT_NPC_RESULT,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_OVERRIDE_LIGHT,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PAGE_TEXT,                               STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_COMMAND_RESULT,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_INVITE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_COMMAND_RESULT,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_INVITE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_KILL_LOG,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_UPDATE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_UPDATE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PAUSE_MIRROR_TIMER,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PENDING_RAID_LOCK,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_ALREADY_SIGNED,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1539,12 +1540,12 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_DIFFICULTY_SET,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_GROUP_ONLY,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_INSTANCE_MESSAGE,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_MARKERS_CHANGED,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RAID_MARKERS_CHANGED,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RANDOM_ROLL,                             STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RATED_BATTLEFIELD_INFO,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_COMPLETED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_RESPONSE,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_STARTED,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_COMPLETED,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_RESPONSE,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_READY_CHECK_STARTED,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_READ_ITEM_RESULT_FAILED,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_READ_ITEM_RESULT_OK,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_REALM_QUERY_RESPONSE,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1573,9 +1574,9 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESUME_TOKEN,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESURRECT_REQUEST,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESYNC_RUNES,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHANGED_INFORM,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHANGED_INFORM,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHOSEN,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_INFORM,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_INFORM,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RUNE_REGEN_DEBUG,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SCENARIO_BOOT,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SCENARIO_COMPLETED,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1594,8 +1595,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SELL_RESPONSE,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_ITEM_PASSIVES,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_KNOWN_SPELLS,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_ALL,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_SINGLE,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_ALL,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_RAID_TARGET_UPDATE_SINGLE,          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_SPELL_CHARGES,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_SPELL_HISTORY,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_UNLEARN_SPELLS,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index bd4fefdd665..d8bad3d4933 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -171,6 +171,9 @@ namespace WorldPackets
         class ChannelPlayerCommand;
         class JoinChannel;
         class LeaveChannel;
+        class UserlistAdd;
+        class UserlistRemove;
+        class UserlistUpdate;
     }
 
     namespace Chat
@@ -275,6 +278,11 @@ namespace WorldPackets
         class RequestHonorStats;
     }
 
+    namespace Instance
+    {
+        class InstanceInfo;
+    }
+
     namespace Item
     {
         class AutoEquipItem;
@@ -338,6 +346,8 @@ namespace WorldPackets
         class CompleteCinematic;
         class NextCinematicCamera;
         class FarSight;
+        class LoadCUFProfiles;
+        class SaveCUFProfiles;
     }
 
     namespace Movement
@@ -360,6 +370,47 @@ namespace WorldPackets
         class TrainerBuySpell;
     }
 
+    namespace Party
+    {
+        class PartyCommandResult;
+        class PartyInviteClient;
+        class PartyInvite;
+        class PartyInviteResponse;
+        class PartyUninvite;
+        class GroupDecline;
+        class RequestPartyMemberStats;
+        class PartyMemberStats;
+        class SetPartyLeader;
+        class SetRole;
+        class RoleChangedInform;
+        class SetLootMethod;
+        class LeaveGroup;
+        class MinimapPingClient;
+        class MinimapPing;
+        class UpdateRaidTarget;
+        class SendRaidTargetUpdateSingle;
+        class SendRaidTargetUpdateAll;
+        class ConvertRaid;
+        class RequestPartyJoinUpdates;
+        class SetAssistantLeader;
+        class DoReadyCheck;
+        class ReadyCheckStarted;
+        class ReadyCheckResponseClient;
+        class ReadyCheckResponse;
+        class ReadyCheckCompleted;
+        class RequestRaidInfo;
+        class OptOutOfLoot;
+        class InitiateRolePoll;
+        class RolePollInform;
+        class GroupNewLeader;
+        class PartyUpdate;
+        class SetEveryoneIsAssistant;
+        class ChangeSubGroup;
+        class SwapSubGroups;
+        class RaidMarkersChanged;
+        class ClearRaidMarker;
+    }
+
     namespace Petition
     {
         class DeclinePetition;
@@ -855,8 +906,6 @@ class WorldSession
         void SendNotInArenaTeamPacket(uint8 type);
         void SendPetitionShowList(ObjectGuid guid);
 
-        void BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data);
-
         void DoLootRelease(ObjectGuid lguid);
 
         // Account mute time
@@ -1051,28 +1100,31 @@ class WorldSession
         void HandleMoveTimeSkippedOpcode(WorldPackets::Movement::MoveTimeSkipped& moveTimeSkipped);
         void HandleMovementAckMessage(WorldPackets::Movement::MovementAckMessage& movementAck);
 
-        void HandleRequestRaidInfoOpcode(WorldPacket& recvData);
+        void HandleRequestRaidInfoOpcode(WorldPackets::Party::RequestRaidInfo& packet);
 
-        void HandleGroupInviteOpcode(WorldPacket& recvPacket);
+        void HandlePartyInviteOpcode(WorldPackets::Party::PartyInviteClient& packet);
         //void HandleGroupCancelOpcode(WorldPacket& recvPacket);
-        void HandleGroupInviteResponseOpcode(WorldPacket& recvPacket);
-        void HandleGroupUninviteOpcode(WorldPacket& recvPacket);
-        void HandleGroupSetLeaderOpcode(WorldPacket& recvPacket);
-        void HandleGroupSetRolesOpcode(WorldPacket& recvData);
-        void HandleGroupDisbandOpcode(WorldPacket& recvPacket);
-        void HandleOptOutOfLootOpcode(WorldPacket& recvData);
-        void HandleLootMethodOpcode(WorldPacket& recvPacket);
+        void HandlePartyInviteResponseOpcode(WorldPackets::Party::PartyInviteResponse& packet);
+        void HandlePartyUninviteOpcode(WorldPackets::Party::PartyUninvite& packet);
+        void HandleSetPartyLeaderOpcode(WorldPackets::Party::SetPartyLeader& packet);
+        void HandleSetRoleOpcode(WorldPackets::Party::SetRole& packet);
+        void HandleLeaveGroupOpcode(WorldPackets::Party::LeaveGroup& packet);
+        void HandleOptOutOfLootOpcode(WorldPackets::Party::OptOutOfLoot& packet);
+        void HandleSetLootMethodOpcode(WorldPackets::Party::SetLootMethod& packet);
         void HandleLootRoll(WorldPackets::Loot::LootRoll& packet);
-        void HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData);
-        void HandleRaidTargetUpdateOpcode(WorldPacket& recvData);
-        void HandleRaidReadyCheckOpcode(WorldPacket& recvData);
-        void HandleGroupRaidConvertOpcode(WorldPacket& recvData);
-        void HandleGroupRequestJoinUpdates(WorldPacket& recvData);
-        void HandleGroupChangeSubGroupOpcode(WorldPacket& recvData);
-        void HandleGroupSwapSubGroupOpcode(WorldPacket& recvData);
-        void HandleGroupAssistantLeaderOpcode(WorldPacket& recvData);
+        void HandleRequestPartyMemberStatsOpcode(WorldPackets::Party::RequestPartyMemberStats& packet);
+        void HandleUpdateRaidTargetOpcode(WorldPackets::Party::UpdateRaidTarget& packet);
+        void HandleDoReadyCheckOpcode(WorldPackets::Party::DoReadyCheck& packet);
+        void HandleReadyCheckResponseOpcode(WorldPackets::Party::ReadyCheckResponseClient& packet);
+        void HandleConvertRaidOpcode(WorldPackets::Party::ConvertRaid& packet);
+        void HandleRequestPartyJoinUpdates(WorldPackets::Party::RequestPartyJoinUpdates& packet);
+        void HandleChangeSubGroupOpcode(WorldPackets::Party::ChangeSubGroup& packet);
+        void HandleSwapSubGroupsOpcode(WorldPackets::Party::SwapSubGroups& packet);
+        void HandleSetAssistantLeaderOpcode(WorldPackets::Party::SetAssistantLeader& packet);
         void HandlePartyAssignmentOpcode(WorldPacket& recvData);
-        void HandleRolePollBeginOpcode(WorldPacket& recvData);
+        void HandleInitiateRolePoll(WorldPackets::Party::InitiateRolePoll& packet);
+        void HandleSetEveryoneIsAssistant(WorldPackets::Party::SetEveryoneIsAssistant& packet);
+        void HandleClearRaidMarker(WorldPackets::Party::ClearRaidMarker& packet);
 
         void HandleDeclinePetition(WorldPackets::Petition::DeclinePetition& packet);
         void HandleOfferPetition(WorldPackets::Petition::OfferPetition& packet);
@@ -1337,7 +1389,7 @@ class WorldSession
 
         void HandleWardenDataOpcode(WorldPacket& recvData);
         void HandleWorldTeleportOpcode(WorldPacket& recvData);
-        void HandleMinimapPingOpcode(WorldPacket& recvData);
+        void HandleMinimapPingOpcode(WorldPackets::Party::MinimapPingClient& packet);
         void HandleRandomRollOpcode(WorldPackets::Misc::RandomRollClient& packet);
         void HandleFarSightOpcode(WorldPackets::Misc::FarSight& packet);
         void HandleSetDungeonDifficultyOpcode(WorldPackets::Misc::SetDungeonDifficulty& setDungeonDifficulty);
@@ -1470,7 +1522,7 @@ class WorldSession
         void HandleRequestWowTokenMarketPrice(WorldPackets::Token::RequestWowTokenMarketPrice& requestWowTokenMarketPrice);
 
         // Compact Unit Frames (4.x)
-        void HandleSaveCUFProfiles(WorldPacket& recvPacket);
+        void HandleSaveCUFProfiles(WorldPackets::Misc::SaveCUFProfiles& packet);
         void SendLoadCUFProfiles();
 
         // Garrison