Merge pull request #14710 from et65/6.x

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

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