Core/PacketIO: Updated and enabled LFG packets

6 files changed, 849 insertions, 39 deletions

diff --git a/src/server/game/Server/Packets/LFGPackets.cpp b/src/server/game/Server/Packets/LFGPackets.cpp
index 4ec8178035c..ddc18719815 100644
--- a/src/server/game/Server/Packets/LFGPackets.cpp
+++ b/src/server/game/Server/Packets/LFGPackets.cpp
@@ -16,3 +16,392 @@
  */
 
 #include "LFGPackets.h"
+
+void WorldPackets::LFG::DFJoin::Read()
+{
+    QueueAsGroup = _worldPacket.ReadBit();
+    Unknown = _worldPacket.ReadBit();
+    _worldPacket >> PartyIndex;
+    _worldPacket >> Roles;
+    Slots.resize(_worldPacket.read<uint32>());
+    for (uint32& slot : Slots)
+        _worldPacket >> slot;
+}
+
+void WorldPackets::LFG::DFLeave::Read()
+{
+    _worldPacket >> Ticket;
+}
+
+void WorldPackets::LFG::DFProposalResponse::Read()
+{
+    _worldPacket >> Ticket;
+    _worldPacket >> InstanceID;
+    _worldPacket >> InstanceID;
+    Accepted = _worldPacket.ReadBit();
+}
+
+void WorldPackets::LFG::DFSetRoles::Read()
+{
+    _worldPacket >> RolesDesired;
+    _worldPacket >> PartyIndex;
+}
+
+void WorldPackets::LFG::DFBootPlayerVote::Read()
+{
+    Vote = _worldPacket.ReadBit();
+}
+
+void WorldPackets::LFG::DFTeleport::Read()
+{
+    TeleportOut = _worldPacket.ReadBit();
+}
+
+void WorldPackets::LFG::DFGetSystemInfo::Read()
+{
+    Player = _worldPacket.ReadBit();
+    _worldPacket >> PartyIndex;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGBlackListSlot const& lfgBlackListSlot)
+{
+    data << uint32(lfgBlackListSlot.Slot);
+    data << uint32(lfgBlackListSlot.Reason);
+    data << int32(lfgBlackListSlot.SubReason1);
+    data << int32(lfgBlackListSlot.SubReason2);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGBlackList const& blackList)
+{
+    data.WriteBit(blackList.PlayerGuid.is_initialized());
+    data << uint32(blackList.Slot.size());
+    if (blackList.PlayerGuid)
+        data << *blackList.PlayerGuid;
+
+    for (WorldPackets::LFG::LFGBlackListSlot const& slot : blackList.Slot)
+        data << slot;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LfgPlayerQuestRewardItem const& playerQuestRewardItem)
+{
+    data << int32(playerQuestRewardItem.ItemID);
+    data << int32(playerQuestRewardItem.Quantity);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LfgPlayerQuestRewardCurrency const& playerQuestRewardCurrency)
+{
+    data << int32(playerQuestRewardCurrency.CurrencyID);
+    data << int32(playerQuestRewardCurrency.Quantity);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LfgPlayerQuestReward const& playerQuestReward)
+{
+    data << uint32(playerQuestReward.Mask);
+    data << int32(playerQuestReward.RewardMoney);
+    data << int32(playerQuestReward.RewardXP);
+    data << uint32(playerQuestReward.Item.size());
+    data << uint32(playerQuestReward.Currency.size());
+    data << uint32(playerQuestReward.BonusCurrency.size());
+
+    for (WorldPackets::LFG::LfgPlayerQuestRewardItem const& item : playerQuestReward.Item)
+        data << item;
+
+    for (WorldPackets::LFG::LfgPlayerQuestRewardCurrency const& currency : playerQuestReward.Currency)
+        data << currency;
+
+    for (WorldPackets::LFG::LfgPlayerQuestRewardCurrency const& bonusCurrency : playerQuestReward.BonusCurrency)
+        data << bonusCurrency;
+
+    data.WriteBit(playerQuestReward.RewardSpellID.is_initialized());
+    data.WriteBit(playerQuestReward.Unused1.is_initialized());
+    data.WriteBit(playerQuestReward.Unused2.is_initialized());
+    data.WriteBit(playerQuestReward.Honor.is_initialized());
+    data.FlushBits();
+
+    if (playerQuestReward.RewardSpellID)
+        data << int32(*playerQuestReward.RewardSpellID);
+
+    if (playerQuestReward.Unused1)
+        data << int32(*playerQuestReward.Unused1);
+
+    if (playerQuestReward.Unused2)
+        data << uint64(*playerQuestReward.Unused2);
+
+    if (playerQuestReward.Honor)
+        data << int32(*playerQuestReward.Honor);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LfgPlayerDungeonInfo const& playerDungeonInfo)
+{
+    data << uint32(playerDungeonInfo.Slot);
+    data << int32(playerDungeonInfo.CompletionQuantity);
+    data << int32(playerDungeonInfo.CompletionLimit);
+    data << int32(playerDungeonInfo.CompletionCurrencyID);
+    data << int32(playerDungeonInfo.SpecificQuantity);
+    data << int32(playerDungeonInfo.SpecificLimit);
+    data << int32(playerDungeonInfo.OverallQuantity);
+    data << int32(playerDungeonInfo.OverallLimit);
+    data << int32(playerDungeonInfo.PurseWeeklyQuantity);
+    data << int32(playerDungeonInfo.PurseWeeklyLimit);
+    data << int32(playerDungeonInfo.PurseQuantity);
+    data << int32(playerDungeonInfo.PurseLimit);
+    data << int32(playerDungeonInfo.Quantity);
+    data << uint32(playerDungeonInfo.CompletedMask);
+    data << uint32(playerDungeonInfo.EncounterMask);
+    data << uint32(playerDungeonInfo.ShortageReward.size());
+    data.WriteBit(playerDungeonInfo.FirstReward);
+    data.WriteBit(playerDungeonInfo.ShortageEligible);
+    data.FlushBits();
+
+    data << playerDungeonInfo.Rewards;
+    for (WorldPackets::LFG::LfgPlayerQuestReward const& shortageReward : playerDungeonInfo.ShortageReward)
+        data << shortageReward;
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::LFG::LfgPlayerInfo::Write()
+{
+    _worldPacket << uint32(Dungeon.size());
+    _worldPacket << BlackList;
+    for (LfgPlayerDungeonInfo const& playerDungeonInfo : Dungeon)
+        _worldPacket << playerDungeonInfo;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::LFG::LfgPartyInfo::Write()
+{
+    _worldPacket << uint32(Player.size());
+    for (WorldPackets::LFG::LFGBlackList const& player : Player)
+        _worldPacket << player;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGUpdateStatus::Write()
+{
+    _worldPacket << Ticket;
+    _worldPacket << uint8(SubType);
+    _worldPacket << uint8(Reason);
+    _worldPacket << uint32(Slots.size());
+    _worldPacket << uint32(RequestedRoles);
+    _worldPacket << uint32(SuspendedPlayers.size());
+
+    for (uint32 slot : Slots)
+        _worldPacket << uint32(slot);
+
+    for (ObjectGuid const& suspendedPlayer : SuspendedPlayers)
+        _worldPacket << suspendedPlayer;
+
+    _worldPacket.WriteBit(IsParty);
+    _worldPacket.WriteBit(NotifyUI);
+    _worldPacket.WriteBit(Joined);
+    _worldPacket.WriteBit(LfgJoined);
+    _worldPacket.WriteBit(Queued);
+    _worldPacket.WriteBit(Unused);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::LFG::RoleChosen::Write()
+{
+    _worldPacket << Player;
+    _worldPacket << uint32(RoleMask);
+    _worldPacket.WriteBit(Accepted);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGRoleCheckUpdateMember const& lfgRoleCheckUpdateMember)
+{
+    data << lfgRoleCheckUpdateMember.Guid;
+    data << uint32(lfgRoleCheckUpdateMember.RolesDesired);
+    data << uint8(lfgRoleCheckUpdateMember.Level);
+    data.WriteBit(lfgRoleCheckUpdateMember.RoleCheckComplete);
+    data.FlushBits();
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGRoleCheckUpdate::Write()
+{
+    _worldPacket << uint8(PartyIndex);
+    _worldPacket << uint8(RoleCheckStatus);
+    _worldPacket << uint32(JoinSlots.size());
+    _worldPacket << uint64(BgQueueID);
+    _worldPacket << int32(GroupFinderActivityID);
+    _worldPacket << uint32(Members.size());
+
+    for (uint32 slot : JoinSlots)
+        _worldPacket << uint32(slot);
+
+    _worldPacket.WriteBit(IsBeginning);
+    _worldPacket.WriteBit(IsRequeue);
+    _worldPacket.FlushBits();
+
+    for (LFGRoleCheckUpdateMember const& member : Members)
+        _worldPacket << member;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGJoinBlackListSlot const& lfgBlackListSlot)
+{
+    data << int32(lfgBlackListSlot.Slot);
+    data << int32(lfgBlackListSlot.Reason);
+    data << int32(lfgBlackListSlot.SubReason1);
+    data << int32(lfgBlackListSlot.SubReason2);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGJoinBlackList const& blackList)
+{
+    data << blackList.Guid;
+    data << uint32(blackList.Slots.size());
+
+    for (WorldPackets::LFG::LFGJoinBlackListSlot const& slot : blackList.Slots)
+        data << slot;
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGJoinResult::Write()
+{
+    _worldPacket << Ticket;
+    _worldPacket << uint8(Result);
+    _worldPacket << uint8(ResultDetail);
+    _worldPacket << uint32(BlackList.size());
+
+    for (LFGJoinBlackList const& blackList : BlackList)
+        _worldPacket << blackList;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGQueueStatus::Write()
+{
+    _worldPacket << Ticket;
+    _worldPacket << uint32(Slot);
+    _worldPacket << uint32(AvgWaitTimeMe);
+    _worldPacket << uint32(AvgWaitTime);
+
+    for (uint32 i = 0; i < 3; ++i)
+    {
+        _worldPacket << uint32(AvgWaitTimeByRole[i]);
+        _worldPacket << uint8(LastNeeded[i]);
+    }
+    _worldPacket << uint32(QueuedTime);
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGPlayerRewards const& lfgPlayerRewards)
+{
+    data << int32(lfgPlayerRewards.RewardItem);
+    data << uint32(lfgPlayerRewards.RewardItemQuantity);
+    data << int32(lfgPlayerRewards.BonusCurrency);
+    data.WriteBit(lfgPlayerRewards.IsCurrency);
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGPlayerReward::Write()
+{
+    _worldPacket << uint32(QueuedSlot);
+    _worldPacket << uint32(ActualSlot);
+    _worldPacket << int32(RewardMoney);
+    _worldPacket << int32(AddedXP);
+    _worldPacket << uint32(Rewards.size());
+
+    for (LFGPlayerRewards const& reward : Rewards)
+        _worldPacket << reward;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LfgBootInfo const& lfgBootInfo)
+{
+    data.WriteBit(lfgBootInfo.VoteInProgress);
+    data.WriteBit(lfgBootInfo.VotePassed);
+    data.WriteBit(lfgBootInfo.MyVoteCompleted);
+    data.WriteBit(lfgBootInfo.MyVote);
+    data.WriteBits(lfgBootInfo.Reason.length(), 8);
+    data << lfgBootInfo.Target;
+    data << uint32(lfgBootInfo.TotalVotes);
+    data << uint32(lfgBootInfo.BootVotes);
+    data << int32(lfgBootInfo.TimeLeft);
+    data << uint32(lfgBootInfo.VotesNeeded);
+    data.WriteString(lfgBootInfo.Reason);
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::LFG::LfgBootPlayer::Write()
+{
+    _worldPacket << Info;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGProposalUpdatePlayer const& lfgProposalUpdatePlayer)
+{
+    data << uint32(lfgProposalUpdatePlayer.Roles);
+    data.WriteBit(lfgProposalUpdatePlayer.Me);
+    data.WriteBit(lfgProposalUpdatePlayer.SameParty);
+    data.WriteBit(lfgProposalUpdatePlayer.MyParty);
+    data.WriteBit(lfgProposalUpdatePlayer.Responded);
+    data.WriteBit(lfgProposalUpdatePlayer.Accepted);
+    data.FlushBits();
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGProposalUpdate::Write()
+{
+    _worldPacket << Ticket;
+    _worldPacket << uint64(InstanceID);
+    _worldPacket << uint32(ProposalID);
+    _worldPacket << uint32(Slot);
+    _worldPacket << int8(State);
+    _worldPacket << uint32(CompletedMask);
+    _worldPacket << uint32(Players.size());
+    _worldPacket << uint8(Unused);
+    _worldPacket.WriteBit(ValidCompletedMask);
+    _worldPacket.WriteBit(ProposalSilent);
+    _worldPacket.WriteBit(IsRequeue);
+    _worldPacket.FlushBits();
+
+    for (LFGProposalUpdatePlayer const& player : Players)
+        _worldPacket << player;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGOfferContinue::Write()
+{
+    _worldPacket << uint32(Slot);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::LFG::LFGTeleportDenied::Write()
+{
+    _worldPacket.WriteBits(Reason, 4);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/LFGPackets.h b/src/server/game/Server/Packets/LFGPackets.h
index 18b8ef8620a..e0958a9daea 100644
--- a/src/server/game/Server/Packets/LFGPackets.h
+++ b/src/server/game/Server/Packets/LFGPackets.h
@@ -20,11 +20,414 @@
 
 #include "Packet.h"
 #include "LFGPacketsCommon.h"
+#include "Optional.h"
+
+namespace lfg
+{
+    enum LfgTeleportResult : uint8;
+}
 
 namespace WorldPackets
 {
     namespace LFG
     {
+        class DFJoin final : public ClientPacket
+        {
+        public:
+            DFJoin(WorldPacket&& packet) : ClientPacket(CMSG_DF_JOIN, std::move(packet)) { }
+
+            void Read() override;
+
+            bool QueueAsGroup = false;
+            bool Unknown = false;       // Always false in 7.2.5
+            uint8 PartyIndex = 0;
+            uint32 Roles = 0;
+            Array<uint32, 50> Slots;
+        };
+
+        class DFLeave final : public ClientPacket
+        {
+        public:
+            DFLeave(WorldPacket&& packet) : ClientPacket(CMSG_DF_LEAVE, std::move(packet)) { }
+
+            void Read() override;
+
+            RideTicket Ticket;
+        };
+
+        class DFProposalResponse final : public ClientPacket
+        {
+        public:
+            DFProposalResponse(WorldPacket&& packet) : ClientPacket(CMSG_DF_PROPOSAL_RESPONSE, std::move(packet)) { }
+
+            void Read() override;
+
+            RideTicket Ticket;
+            uint64 InstanceID = 0;
+            uint32 ProposalID = 0;
+            bool Accepted = false;
+        };
+
+        class DFSetRoles final : public ClientPacket
+        {
+        public:
+            DFSetRoles(WorldPacket&& packet) : ClientPacket(CMSG_DF_SET_ROLES, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 RolesDesired = 0;
+            uint8 PartyIndex = 0;
+        };
+
+        class DFBootPlayerVote final : public ClientPacket
+        {
+        public:
+            DFBootPlayerVote(WorldPacket&& packet) : ClientPacket(CMSG_DF_BOOT_PLAYER_VOTE, std::move(packet)) { }
+
+            void Read() override;
+
+            bool Vote = false;
+        };
+
+        class DFTeleport final : public ClientPacket
+        {
+        public:
+            DFTeleport(WorldPacket&& packet) : ClientPacket(CMSG_DF_TELEPORT, std::move(packet)) { }
+
+            void Read() override;
+
+            bool TeleportOut = false;
+        };
+
+        class DFGetSystemInfo final : public ClientPacket
+        {
+        public:
+            DFGetSystemInfo(WorldPacket&& packet) : ClientPacket(CMSG_DF_GET_SYSTEM_INFO, std::move(packet)) { }
+
+            void Read() override;
+
+            uint8 PartyIndex = 0;
+            bool Player = false;
+        };
+
+        class DFGetJoinStatus final : public ClientPacket
+        {
+        public:
+            DFGetJoinStatus(WorldPacket&& packet) : ClientPacket(CMSG_DF_GET_JOIN_STATUS, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct LFGBlackListSlot
+        {
+            LFGBlackListSlot() { }
+            LFGBlackListSlot(uint32 slot, uint32 reason, int32 subReason1, int32 subReason2)
+                : Slot(slot), Reason(reason), SubReason1(subReason1), SubReason2(subReason2) { }
+
+            uint32 Slot = 0;
+            uint32 Reason = 0;
+            int32 SubReason1 = 0;
+            int32 SubReason2 = 0;
+        };
+
+        struct LFGBlackList
+        {
+            Optional<ObjectGuid> PlayerGuid;
+            std::vector<LFGBlackListSlot> Slot;
+        };
+
+        struct LfgPlayerQuestRewardItem
+        {
+            LfgPlayerQuestRewardItem() { }
+            LfgPlayerQuestRewardItem(int32 itemId, int32 quantity) : ItemID(itemId), Quantity(quantity) { }
+
+            int32 ItemID = 0;
+            int32 Quantity = 0;
+        };
+
+        struct LfgPlayerQuestRewardCurrency
+        {
+            LfgPlayerQuestRewardCurrency() { }
+            LfgPlayerQuestRewardCurrency(int32 currencyID, int32 quantity) : CurrencyID(currencyID), Quantity(quantity) { }
+
+            int32 CurrencyID = 0;
+            int32 Quantity = 0;
+        };
+
+        struct LfgPlayerQuestReward
+        {
+            uint32 Mask = 0;                                            // Roles required for this reward, only used by ShortageReward in SMSG_LFG_PLAYER_INFO
+            int32 RewardMoney = 0;                                      // Only used by SMSG_LFG_PLAYER_INFO
+            int32 RewardXP = 0;
+            std::vector<LfgPlayerQuestRewardItem> Item;
+            std::vector<LfgPlayerQuestRewardCurrency> Currency;         // Only used by SMSG_LFG_PLAYER_INFO
+            std::vector<LfgPlayerQuestRewardCurrency> BonusCurrency;    // Only used by SMSG_LFG_PLAYER_INFO
+            Optional<int32> RewardSpellID;                              // Only used by SMSG_LFG_PLAYER_INFO
+            Optional<int32> Unused1;
+            Optional<uint64> Unused2;
+            Optional<int32> Honor;                                      // Only used by SMSG_REQUEST_PVP_REWARDS_RESPONSE
+        };
+
+        struct LfgPlayerDungeonInfo
+        {
+            uint32 Slot = 0;
+            int32 CompletionQuantity = 0;
+            int32 CompletionLimit = 0;
+            int32 CompletionCurrencyID = 0;
+            int32 SpecificQuantity = 0;
+            int32 SpecificLimit = 0;
+            int32 OverallQuantity = 0;
+            int32 OverallLimit = 0;
+            int32 PurseWeeklyQuantity = 0;
+            int32 PurseWeeklyLimit = 0;
+            int32 PurseQuantity = 0;
+            int32 PurseLimit = 0;
+            int32 Quantity = 0;
+            uint32 CompletedMask = 0;
+            uint32 EncounterMask = 0;
+            bool FirstReward = false;
+            bool ShortageEligible = false;
+            LfgPlayerQuestReward Rewards;
+            std::vector<LfgPlayerQuestReward> ShortageReward;
+        };
+
+        class LfgPlayerInfo final : public ServerPacket
+        {
+        public:
+            LfgPlayerInfo() : ServerPacket(SMSG_LFG_PLAYER_INFO) { }
+
+            WorldPacket const* Write() override;
+
+            LFGBlackList BlackList;
+            std::vector<LfgPlayerDungeonInfo> Dungeon;
+        };
+
+        class LfgPartyInfo final : public ServerPacket
+        {
+        public:
+            LfgPartyInfo() : ServerPacket(SMSG_LFG_PARTY_INFO) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<LFGBlackList> Player;
+        };
+
+        class LFGUpdateStatus final : public ServerPacket
+        {
+        public:
+            LFGUpdateStatus() : ServerPacket(SMSG_LFG_UPDATE_STATUS) { }
+
+            WorldPacket const* Write() override;
+
+            RideTicket Ticket;
+            uint8 SubType = 0;
+            uint8 Reason = 0;
+            std::vector<uint32> Slots;
+            uint32 RequestedRoles = 0;
+            std::vector<ObjectGuid> SuspendedPlayers;
+            bool NotifyUI = false;
+            bool IsParty = false;
+            bool Joined = false;
+            bool LfgJoined = false;
+            bool Queued = false;
+            bool Unused = false;
+        };
+
+        class RoleChosen final : public ServerPacket
+        {
+        public:
+            RoleChosen() : ServerPacket(SMSG_ROLE_CHOSEN, 16 + 4 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Player;
+            uint32 RoleMask = 0;
+            bool Accepted = false;
+        };
+
+        struct LFGRoleCheckUpdateMember
+        {
+            LFGRoleCheckUpdateMember() { }
+            LFGRoleCheckUpdateMember(ObjectGuid guid, uint32 rolesDesired, uint8 level, bool roleCheckComplete)
+                : Guid(guid), RolesDesired(rolesDesired), Level(level), RoleCheckComplete(roleCheckComplete) { }
+
+            ObjectGuid Guid;
+            uint32 RolesDesired = 0;
+            uint8 Level = 0;
+            bool RoleCheckComplete = false;
+        };
+
+        class LFGRoleCheckUpdate final : public ServerPacket
+        {
+        public:
+            LFGRoleCheckUpdate() : ServerPacket(SMSG_LFG_ROLE_CHECK_UPDATE) { }
+
+            WorldPacket const* Write() override;
+
+            uint8 PartyIndex = 0;
+            uint8 RoleCheckStatus = 0;
+            std::vector<uint32> JoinSlots;
+            uint64 BgQueueID = 0;
+            int32 GroupFinderActivityID = 0;
+            std::vector<LFGRoleCheckUpdateMember> Members;
+            bool IsBeginning = false;
+            bool IsRequeue = false;
+        };
+
+        struct LFGJoinBlackListSlot
+        {
+            LFGJoinBlackListSlot() { }
+            LFGJoinBlackListSlot(int32 slot, int32 reason, int32 subReason1, int32 subReason2)
+                : Slot(slot), Reason(reason), SubReason1(subReason1), SubReason2(subReason2) { }
+
+            int32 Slot = 0;
+            int32 Reason = 0;
+            int32 SubReason1 = 0;
+            int32 SubReason2 = 0;
+        };
+
+        struct LFGJoinBlackList
+        {
+            ObjectGuid Guid;
+            std::vector<LFGJoinBlackListSlot> Slots;
+        };
+
+        class LFGJoinResult final : public ServerPacket
+        {
+        public:
+            LFGJoinResult() : ServerPacket(SMSG_LFG_JOIN_RESULT) { }
+
+            WorldPacket const* Write() override;
+
+            RideTicket Ticket;
+            uint8 Result = 0;
+            uint8 ResultDetail = 0;
+            std::vector<LFGJoinBlackList> BlackList;
+        };
+
+        class LFGQueueStatus final : public ServerPacket
+        {
+        public:
+            LFGQueueStatus() : ServerPacket(SMSG_LFG_QUEUE_STATUS, 16 + 4 + 4 + 4 + 4 + 4 + 4 + 4 * 3 + 3 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            RideTicket Ticket;
+            uint32 Slot = 0;
+            uint32 AvgWaitTimeMe = 0;
+            uint32 AvgWaitTime = 0;
+            uint32 AvgWaitTimeByRole[3] = {};
+            uint8 LastNeeded[3] = {};
+            uint32 QueuedTime = 0;
+        };
+
+        struct LFGPlayerRewards
+        {
+            LFGPlayerRewards() { }
+            LFGPlayerRewards(int32 rewardItem, uint32 rewardItemQuantity, int32 bonusCurrency, bool isCurrency)
+                : RewardItem(rewardItem), RewardItemQuantity(rewardItemQuantity), BonusCurrency(bonusCurrency), IsCurrency(isCurrency) { }
+
+            int32 RewardItem = 0;
+            uint32 RewardItemQuantity = 0;
+            int32 BonusCurrency = 0;
+            bool IsCurrency = false;
+        };
+
+        class LFGPlayerReward final : public ServerPacket
+        {
+        public:
+            LFGPlayerReward() : ServerPacket(SMSG_LFG_PLAYER_REWARD) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 QueuedSlot = 0;
+            uint32 ActualSlot = 0;
+            int32 RewardMoney = 0;
+            int32 AddedXP = 0;
+            std::vector<LFGPlayerRewards> Rewards;
+        };
+
+        struct LfgBootInfo
+        {
+            bool VoteInProgress = false;
+            bool VotePassed = false;
+            bool MyVoteCompleted = false;
+            bool MyVote = false;
+            ObjectGuid Target;
+            uint32 TotalVotes = 0;
+            uint32 BootVotes = 0;
+            int32 TimeLeft = 0;
+            uint32 VotesNeeded = 0;
+            std::string Reason;
+        };
+
+        class LfgBootPlayer final : public ServerPacket
+        {
+        public:
+            LfgBootPlayer() : ServerPacket(SMSG_LFG_BOOT_PLAYER) { }
+
+            WorldPacket const* Write() override;
+
+            LfgBootInfo Info;
+        };
+
+        struct LFGProposalUpdatePlayer
+        {
+            uint32 Roles = 0;
+            bool Me = false;
+            bool SameParty = false;
+            bool MyParty = false;
+            bool Responded = false;
+            bool Accepted = false;
+        };
+
+        class LFGProposalUpdate final : public ServerPacket
+        {
+        public:
+            LFGProposalUpdate() : ServerPacket(SMSG_LFG_PROPOSAL_UPDATE) { }
+
+            WorldPacket const* Write() override;
+
+            RideTicket Ticket;
+            uint64 InstanceID = 0;
+            uint32 ProposalID = 0;
+            uint32 Slot = 0;
+            int8 State = 0;
+            uint32 CompletedMask = 0;
+            uint8 Unused;
+            bool ValidCompletedMask = false;
+            bool ProposalSilent = false;
+            bool IsRequeue;
+            std::vector<LFGProposalUpdatePlayer> Players;
+        };
+
+        class LFGDisabled final : public ServerPacket
+        {
+        public:
+            LFGDisabled() : ServerPacket(SMSG_LFG_DISABLED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class LFGOfferContinue final : public ServerPacket
+        {
+        public:
+            LFGOfferContinue(uint32 slot) : ServerPacket(SMSG_LFG_OFFER_CONTINUE, 4), Slot(slot) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 Slot = 0;
+        };
+
+        class LFGTeleportDenied final : public ServerPacket
+        {
+        public:
+            LFGTeleportDenied(lfg::LfgTeleportResult reason) : ServerPacket(SMSG_LFG_TELEPORT_DENIED, 1), Reason(reason) { }
+
+            WorldPacket const* Write() override;
+
+            lfg::LfgTeleportResult Reason;
+        };
     }
 }
 
diff --git a/src/server/game/Server/Packets/LFGPacketsCommon.cpp b/src/server/game/Server/Packets/LFGPacketsCommon.cpp
index 71af239d5aa..74b08383a72 100644
--- a/src/server/game/Server/Packets/LFGPacketsCommon.cpp
+++ b/src/server/game/Server/Packets/LFGPacketsCommon.cpp
@@ -21,7 +21,7 @@ ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::LFG::RideTicket& ticket)
 {
     data >> ticket.RequesterGuid;
     data >> ticket.Id;
-    data >> ticket.Type;
+    ticket.Type = data.read<WorldPackets::LFG::RideType>();
     data >> ticket.Time;
 
     return data;
@@ -30,9 +30,9 @@ ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::LFG::RideTicket& ticket)
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::RideTicket const& ticket)
 {
     data << ticket.RequesterGuid;
-    data << int32(ticket.Id);
-    data << int32(ticket.Type);
-    data << uint32(ticket.Time);
+    data << uint32(ticket.Id);
+    data << uint32(ticket.Type);
+    data << int32(ticket.Time);
 
     return data;
 }
diff --git a/src/server/game/Server/Packets/LFGPacketsCommon.h b/src/server/game/Server/Packets/LFGPacketsCommon.h
index 957ed07f161..b36f0082b6f 100644
--- a/src/server/game/Server/Packets/LFGPacketsCommon.h
+++ b/src/server/game/Server/Packets/LFGPacketsCommon.h
@@ -25,12 +25,19 @@ namespace WorldPackets
 {
     namespace LFG
     {
+        enum class RideType : uint32
+        {
+            None = 0,
+            Battlegrounds = 1,
+            Lfg = 2
+        };
+
         struct RideTicket
         {
             ObjectGuid RequesterGuid;
-            int32 Id = 0;
-            int32 Type = 0;
-            uint32 Time = 0;
+            uint32 Id = 0;
+            RideType Type = RideType::None;
+            int32 Time = 0;
         };
     }
 }
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 2d22d52c736..1001dd1aeec 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -352,15 +352,15 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_DEL_IGNORE,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleDelIgnoreOpcode);
     DEFINE_HANDLER(CMSG_DEPOSIT_REAGENT_BANK,                               STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_DESTROY_ITEM,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleDestroyItemOpcode);
-    DEFINE_HANDLER(CMSG_DF_BOOT_PLAYER_VOTE,                                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLfgSetBootVoteOpcode);
+    DEFINE_HANDLER(CMSG_DF_BOOT_PLAYER_VOTE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLfgSetBootVoteOpcode);
     DEFINE_HANDLER(CMSG_DF_GET_JOIN_STATUS,                                 STATUS_UNHANDLED, PROCESS_THREADSAFE,   &WorldSession::HandleDFGetJoinStatus);
-    DEFINE_HANDLER(CMSG_DF_GET_SYSTEM_INFO,                                 STATUS_UNHANDLED, PROCESS_THREADSAFE,   &WorldSession::HandleDFGetSystemInfo);
-    DEFINE_HANDLER(CMSG_DF_JOIN,                                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLfgJoinOpcode);
-    DEFINE_HANDLER(CMSG_DF_LEAVE,                                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLfgLeaveOpcode);
-    DEFINE_HANDLER(CMSG_DF_PROPOSAL_RESPONSE,                               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLfgProposalResultOpcode);
-    DEFINE_HANDLER(CMSG_DF_READY_CHECK_RESPONSE,                            STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_DF_SET_ROLES,                                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLfgSetRolesOpcode);
-    DEFINE_HANDLER(CMSG_DF_TELEPORT,                                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLfgTeleportOpcode);
+    DEFINE_HANDLER(CMSG_DF_GET_SYSTEM_INFO,                                 STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleDFGetSystemInfo);
+    DEFINE_HANDLER(CMSG_DF_JOIN,                                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLfgJoinOpcode);
+    DEFINE_HANDLER(CMSG_DF_LEAVE,                                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLfgLeaveOpcode);
+    DEFINE_HANDLER(CMSG_DF_PROPOSAL_RESPONSE,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLfgProposalResultOpcode);
+    DEFINE_HANDLER(CMSG_DF_READY_CHECK_RESPONSE,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_DF_SET_ROLES,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLfgSetRolesOpcode);
+    DEFINE_HANDLER(CMSG_DF_TELEPORT,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLfgTeleportOpcode);
     DEFINE_HANDLER(CMSG_DISCARDED_TIME_SYNC_ACKS,                           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_DISMISS_CRITTER,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleDismissCritter);
     DEFINE_HANDLER(CMSG_DO_MASTER_LOOT_ROLL,                                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -1313,28 +1313,27 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEARN_TALENTS_FAILED,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEVEL_UPDATE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEVEL_UP_INFO,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_BOOT_PLAYER,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_DISABLED,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_BOOT_PLAYER,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_DISABLED,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_INSTANCE_SHUTDOWN_COUNTDOWN,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_JOIN_RESULT,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_JOIN_RESULT,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_LIST_JOIN_RESULT,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_LIST_SEARCH_RESULTS,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_LIST_SEARCH_STATUS,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_LIST_UPDATE_BLACKLIST,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_LIST_UPDATE_STATUS,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_OFFER_CONTINUE,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PARTY_INFO,                          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PLAYER_INFO,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PLAYER_REWARD,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PROPOSAL_UPDATE,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_QUEUE_STATUS,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_OFFER_CONTINUE,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PARTY_INFO,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PLAYER_INFO,                         STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PLAYER_REWARD,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_PROPOSAL_UPDATE,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_QUEUE_STATUS,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_READY_CHECK_RESULT,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_READY_CHECK_UPDATE,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_ROLE_CHECK_UPDATE,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    //DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_SEARCH_RESULTS,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_ROLE_CHECK_UPDATE,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_SLOT_INVALID,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_TELEPORT_DENIED,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_UPDATE_STATUS,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_TELEPORT_DENIED,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LFG_UPDATE_STATUS,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_APPLICANT_LIST_CHANGED,         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_APPLICATIONS,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_APPLICATIONS_LIST_CHANGED,      STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1634,7 +1633,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESURRECT_REQUEST,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESYNC_RUNES,                            STATUS_NEVER,        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_CHOSEN,                             STATUS_NEVER,        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_NEVER,        CONNECTION_TYPE_INSTANCE);
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index 122585e0a74..ae51478180e 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -64,6 +64,7 @@ struct LfgQueueStatusData;
 struct LfgPlayerRewardData;
 struct LfgRoleCheck;
 struct LfgUpdateData;
+enum LfgTeleportResult : uint8;
 }
 
 namespace rbac
@@ -399,6 +400,18 @@ namespace WorldPackets
         struct ItemInstance;
     }
 
+    namespace LFG
+    {
+        class DFJoin;
+        class DFLeave;
+        class DFProposalResponse;
+        class DFSetRoles;
+        class DFBootPlayerVote;
+        class DFTeleport;
+        class DFGetSystemInfo;
+        class DFGetJoinStatus;
+    }
+
     namespace Loot
     {
         class LootUnit;
@@ -1527,21 +1540,20 @@ class TC_GAME_API WorldSession
         void HandleInstanceLockResponse(WorldPackets::Instance::InstanceLockResponse& packet);
 
         // Looking for Dungeon/Raid
-        void HandleDFGetSystemInfo(WorldPacket& recvData);
         void SendLfgPlayerLockInfo();
         void SendLfgPartyLockInfo();
-        void HandleLfgJoinOpcode(WorldPacket& recvData);
-        void HandleLfgLeaveOpcode(WorldPacket& recvData);
-        void HandleLfgSetRolesOpcode(WorldPacket& recvData);
-        void HandleLfgProposalResultOpcode(WorldPacket& recvData);
-        void HandleLfgSetBootVoteOpcode(WorldPacket& recvData);
-        void HandleLfgTeleportOpcode(WorldPacket& recvData);
-        void HandleDFGetJoinStatus(WorldPacket& recvData);
+        void HandleLfgJoinOpcode(WorldPackets::LFG::DFJoin& dfJoin);
+        void HandleLfgLeaveOpcode(WorldPackets::LFG::DFLeave& dfLeave);
+        void HandleLfgProposalResultOpcode(WorldPackets::LFG::DFProposalResponse& dfProposalResponse);
+        void HandleLfgSetRolesOpcode(WorldPackets::LFG::DFSetRoles& dfSetRoles);
+        void HandleLfgSetBootVoteOpcode(WorldPackets::LFG::DFBootPlayerVote& dfBootPlayerVote);
+        void HandleLfgTeleportOpcode(WorldPackets::LFG::DFTeleport& dfTeleport);
+        void HandleDFGetSystemInfo(WorldPackets::LFG::DFGetSystemInfo& dfGetSystemInfo);
+        void HandleDFGetJoinStatus(WorldPackets::LFG::DFGetJoinStatus& dfGetJoinStatus);
 
         void SendLfgUpdateStatus(lfg::LfgUpdateData const& updateData, bool party);
         void SendLfgRoleChosen(ObjectGuid guid, uint8 roles);
         void SendLfgRoleCheckUpdate(lfg::LfgRoleCheck const& pRoleCheck);
-        void SendLfgLfrList(bool update);
         void SendLfgJoinResult(lfg::LfgJoinResultData const& joinData);
         void SendLfgQueueStatus(lfg::LfgQueueStatusData const& queueData);
         void SendLfgPlayerReward(lfg::LfgPlayerRewardData const& lfgPlayerRewardData);
@@ -1549,7 +1561,7 @@ class TC_GAME_API WorldSession
         void SendLfgUpdateProposal(lfg::LfgProposal const& proposal);
         void SendLfgDisabled();
         void SendLfgOfferContinue(uint32 dungeonEntry);
-        void SendLfgTeleportError(uint8 err);
+        void SendLfgTeleportError(lfg::LfgTeleportResult err);
 
         void HandleSelfResOpcode(WorldPackets::Spells::SelfRes& packet);
         void HandleRequestPetInfo(WorldPackets::Pet::RequestPetInfo& packet);