Core/PacketIO: Updated and enabled guild finder opcodes

2 files changed, 411 insertions, 0 deletions

diff --git a/src/server/game/Server/Packets/GuildFinderPackets.cpp b/src/server/game/Server/Packets/GuildFinderPackets.cpp
new file mode 100644
index 00000000000..db7ac6556ed
--- /dev/null
+++ b/src/server/game/Server/Packets/GuildFinderPackets.cpp
@@ -0,0 +1,174 @@
+/*
+ * 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 "GuildFinderPackets.h"
+#include "PacketUtilities.h"
+
+void WorldPackets::GuildFinder::LFGuildAddRecruit::Read()
+{
+    _worldPacket >> GuildGUID;
+    _worldPacket >> PlayStyle;
+    _worldPacket >> Availability;
+    _worldPacket >> ClassRoles;
+    Comment = _worldPacket.ReadString(_worldPacket.ReadBits(10));
+}
+
+void WorldPackets::GuildFinder::LFGuildBrowse::Read()
+{
+    _worldPacket >> PlayStyle;
+    _worldPacket >> Availability;
+    _worldPacket >> ClassRoles;
+    _worldPacket >> CharacterLevel;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::LFGuildBrowseData const& guildData)
+{
+    data.WriteBits(guildData.GuildName.length(), 7);
+    data.WriteBits(guildData.Comment.length(), 10);
+    data << guildData.GuildGUID;
+    data << uint32(guildData.GuildVirtualRealm);
+    data << int32(guildData.GuildMembers);
+    data << int32(guildData.GuildAchievementPoints);
+    data << int32(guildData.PlayStyle);
+    data << int32(guildData.Availability);
+    data << int32(guildData.ClassRoles);
+    data << int32(guildData.LevelRange);
+    data << int32(guildData.EmblemStyle);
+    data << int32(guildData.EmblemColor);
+    data << int32(guildData.BorderStyle);
+    data << int32(guildData.BorderColor);
+    data << int32(guildData.Background);
+    data << int8(guildData.Cached);
+    data << int8(guildData.MembershipRequested);
+    data.WriteString(guildData.GuildName);
+    data.WriteString(guildData.Comment);
+    return data;
+}
+
+WorldPacket const* WorldPackets::GuildFinder::LFGuildBrowseResult::Write()
+{
+    _worldPacket << uint32(Post.size());
+    for (LFGuildBrowseData const& guildData : Post)
+        _worldPacket << guildData;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::GuildFinder::LFGuildDeclineRecruit::Read()
+{
+    _worldPacket >> RecruitGUID;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::LFGuildApplicationData const& application)
+{
+    data << application.GuildGUID;
+    data << uint32(application.GuildVirtualRealm);
+    data << int32(application.ClassRoles);
+    data << int32(application.PlayStyle);
+    data << int32(application.Availability);
+    data << uint32(application.SecondsSinceCreated);
+    data << uint32(application.SecondsUntilExpiration);
+    data.WriteBits(application.GuildName.length(), 7);
+    data.WriteBits(application.Comment.length(), 10);
+    data.FlushBits();
+    data.WriteString(application.GuildName);
+    data.WriteString(application.Comment);
+    return data;
+}
+
+WorldPacket const* WorldPackets::GuildFinder::LFGuildApplications::Write()
+{
+    _worldPacket << uint32(Application.size());
+    _worldPacket << int32(NumRemaining);
+    for (LFGuildApplicationData const& application : Application)
+        _worldPacket << application;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::GuildPostData const& post)
+{
+    data.WriteBit(post.Active);
+    data.WriteBits(post.Comment.length(), 10);
+    data << int32(post.PlayStyle);
+    data << int32(post.Availability);
+    data << int32(post.ClassRoles);
+    data << int32(post.LevelRange);
+    data << uint32(post.SecondsRemaining);
+    data.WriteString(post.Comment);
+    return data;
+}
+
+WorldPacket const* WorldPackets::GuildFinder::LFGuildPost::Write()
+{
+    _worldPacket.WriteBit(Post.is_initialized());
+    _worldPacket.FlushBits();
+    if (Post)
+        _worldPacket << *Post;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::GuildFinder::LFGuildGetRecruits::Read()
+{
+    _worldPacket >> LastUpdate;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::LFGuildRecruitData const& recruit)
+{
+    data << recruit.RecruitGUID;
+    data << uint32(recruit.RecruitVirtualRealm);
+    data << int32(recruit.CharacterClass);
+    data << int32(recruit.CharacterGender);
+    data << int32(recruit.CharacterLevel);
+    data << int32(recruit.ClassRoles);
+    data << int32(recruit.PlayStyle);
+    data << int32(recruit.Availability);
+    data << uint32(recruit.SecondsSinceCreated);
+    data << uint32(recruit.SecondsUntilExpiration);
+    data.WriteBits(recruit.Name.length(), 6);
+    data.WriteBits(recruit.Comment.length(), 10);
+    data.FlushBits();
+    data.WriteString(recruit.Name);
+    data.WriteString(recruit.Comment);
+    return data;
+}
+
+WorldPacket const* WorldPackets::GuildFinder::LFGuildRecruits::Write()
+{
+    _worldPacket << uint32(Recruits.size());
+    _worldPacket << uint32(UpdateTime);
+    for (LFGuildRecruitData const& recruit : Recruits)
+        _worldPacket << recruit;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::GuildFinder::LFGuildRemoveRecruit::Read()
+{
+    _worldPacket >> GuildGUID;
+}
+
+void WorldPackets::GuildFinder::LFGuildSetGuildPost::Read()
+{
+    _worldPacket >> PlayStyle;
+    _worldPacket >> Availability;
+    _worldPacket >> ClassRoles;
+    _worldPacket >> LevelRange;
+    Active = _worldPacket.ReadBit();
+    Comment = _worldPacket.ReadString(_worldPacket.ReadBits(10));
+}
diff --git a/src/server/game/Server/Packets/GuildFinderPackets.h b/src/server/game/Server/Packets/GuildFinderPackets.h
new file mode 100644
index 00000000000..02b4e5de29c
--- /dev/null
+++ b/src/server/game/Server/Packets/GuildFinderPackets.h
@@ -0,0 +1,237 @@
+/*
+ * 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 GuildFinderPackets_h__
+#define GuildFinderPackets_h__
+
+#include "Packet.h"
+#include "ObjectGuid.h"
+
+namespace WorldPackets
+{
+    namespace GuildFinder
+    {
+        class LFGuildAddRecruit final : public ClientPacket
+        {
+        public:
+            LFGuildAddRecruit(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_ADD_RECRUIT, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid GuildGUID;
+            int32 Availability = 0;
+            int32 ClassRoles = 0;
+            int32 PlayStyle = 0;
+            std::string Comment;
+        };
+
+        class LFGuildApplicationsListChanged final : public ServerPacket
+        {
+        public:
+            LFGuildApplicationsListChanged() : ServerPacket(SMSG_LF_GUILD_APPLICATIONS_LIST_CHANGED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class LFGuildApplicantListChanged final : public ServerPacket
+        {
+        public:
+            LFGuildApplicantListChanged() : ServerPacket(SMSG_LF_GUILD_APPLICANT_LIST_CHANGED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class LFGuildBrowse final : public ClientPacket
+        {
+        public:
+            LFGuildBrowse(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_BROWSE, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 CharacterLevel = 0;
+            int32 Availability = 0;
+            int32 ClassRoles = 0;
+            int32 PlayStyle = 0;
+        };
+
+        struct LFGuildBrowseData
+        {
+            std::string GuildName;
+            ObjectGuid GuildGUID;
+            uint32 GuildVirtualRealm = 0;
+            int32 GuildMembers = 0;
+            int32 GuildAchievementPoints = 0;
+            int32 PlayStyle = 0;
+            int32 Availability = 0;
+            int32 ClassRoles = 0;
+            int32 LevelRange = 0;
+            int32 EmblemStyle = 0;
+            int32 EmblemColor = 0;
+            int32 BorderStyle = 0;
+            int32 BorderColor = 0;
+            int32 Background = 0;
+            std::string Comment;
+            int8 Cached = 0;
+            int8 MembershipRequested = 0;
+        };
+
+        class LFGuildBrowseResult final : public ServerPacket
+        {
+        public:
+            LFGuildBrowseResult() : ServerPacket(SMSG_LF_GUILD_BROWSE) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<LFGuildBrowseData> Post;
+        };
+
+        class LFGuildDeclineRecruit final : public ClientPacket
+        {
+        public:
+            LFGuildDeclineRecruit(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_DECLINE_RECRUIT, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid RecruitGUID;
+        };
+
+        class LFGuildGetApplications final : public ClientPacket
+        {
+        public:
+            LFGuildGetApplications(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_GET_APPLICATIONS, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct LFGuildApplicationData
+        {
+            ObjectGuid GuildGUID;
+            uint32 GuildVirtualRealm = 0;
+            std::string GuildName;
+            int32 ClassRoles = 0;
+            int32 PlayStyle = 0;
+            int32 Availability = 0;
+            uint32 SecondsSinceCreated = 0;
+            uint32 SecondsUntilExpiration = 0;
+            std::string Comment;
+        };
+
+        class LFGuildApplications final : public ServerPacket
+        {
+        public:
+            LFGuildApplications() : ServerPacket(SMSG_LF_GUILD_APPLICATIONS) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<LFGuildApplicationData> Application;
+            int32 NumRemaining = 0;
+        };
+
+        class LFGuildGetGuildPost final : public ClientPacket
+        {
+        public:
+            LFGuildGetGuildPost(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_GET_GUILD_POST, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct GuildPostData
+        {
+            bool Active = false;
+            int32 PlayStyle = 0;
+            int32 Availability = 0;
+            int32 ClassRoles = 0;
+            int32 LevelRange = 0;
+            time_t SecondsRemaining = time_t(0);
+            std::string Comment;
+        };
+
+        class LFGuildPost final : public ServerPacket
+        {
+        public:
+            LFGuildPost() : ServerPacket(SMSG_LF_GUILD_POST, 1 + 1 + 4 + 4 + 4 + 4 + 4 + 255) { }
+
+            WorldPacket const* Write() override;
+
+            Optional<GuildPostData> Post;
+        };
+
+        class LFGuildGetRecruits final : public ClientPacket
+        {
+        public:
+            LFGuildGetRecruits(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_GET_RECRUITS, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 LastUpdate = 0;
+        };
+
+        struct LFGuildRecruitData
+        {
+            ObjectGuid RecruitGUID;
+            std::string Name;
+            uint32 RecruitVirtualRealm = 0;
+            std::string Comment;
+            int32 CharacterClass = 0;
+            int32 CharacterGender = 0;
+            int32 CharacterLevel = 0;
+            int32 ClassRoles = 0;
+            int32 PlayStyle = 0;
+            int32 Availability = 0;
+            uint32 SecondsSinceCreated = 0;
+            uint32 SecondsUntilExpiration = 0;
+        };
+
+        class LFGuildRecruits final : public ServerPacket
+        {
+        public:
+            LFGuildRecruits() : ServerPacket(SMSG_LF_GUILD_RECRUITS) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<LFGuildRecruitData> Recruits;
+            time_t UpdateTime = time_t(0);
+        };
+
+        class LFGuildRemoveRecruit final : public ClientPacket
+        {
+        public:
+            LFGuildRemoveRecruit(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_REMOVE_RECRUIT, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid GuildGUID;
+        };
+
+        class LFGuildSetGuildPost final : public ClientPacket
+        {
+        public:
+            LFGuildSetGuildPost(WorldPacket&& packet) : ClientPacket(CMSG_LF_GUILD_SET_GUILD_POST, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 Availability = 0;
+            int32 PlayStyle = 0;
+            int32 ClassRoles = 0;
+            int32 LevelRange = 0;
+            bool Active = false;
+            std::string Comment;
+        };
+    }
+}
+
+#endif // GuildFinderPackets_h__