Core/PacketIO: Port guild packets to classes as example of new self-validating strings

3 files changed, 1087 insertions, 0 deletions

diff --git a/src/server/game/Server/Packets/AllPackets.h b/src/server/game/Server/Packets/AllPackets.h
index e377bb07215..93badb96545 100644
--- a/src/server/game/Server/Packets/AllPackets.h
+++ b/src/server/game/Server/Packets/AllPackets.h
@@ -20,6 +20,7 @@
 
 #include "ChatPackets.h"
 #include "CombatPackets.h"
+#include "GuildPackets.h"
 #include "NPCPackets.h"
 #include "MiscPackets.h"
 #include "QueryPackets.h"
diff --git a/src/server/game/Server/Packets/GuildPackets.cpp b/src/server/game/Server/Packets/GuildPackets.cpp
new file mode 100644
index 00000000000..bea7a2966e1
--- /dev/null
+++ b/src/server/game/Server/Packets/GuildPackets.cpp
@@ -0,0 +1,459 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "GuildPackets.h"
+
+void WorldPackets::Guild::QueryGuildInfo::Read()
+{
+    _worldPacket >> GuildId;
+}
+
+WorldPackets::Guild::QueryGuildInfoResponse::QueryGuildInfoResponse()
+    : ServerPacket(SMSG_GUILD_QUERY_RESPONSE) { }
+
+WorldPacket const* WorldPackets::Guild::QueryGuildInfoResponse::Write()
+{
+    _worldPacket << GuildId;
+    _worldPacket << Info.GuildName;
+    for (std::string const& rankName : Info.Ranks)
+        _worldPacket << rankName;
+
+    _worldPacket << uint32(Info.EmblemStyle);
+    _worldPacket << uint32(Info.EmblemColor);
+    _worldPacket << uint32(Info.BorderStyle);
+    _worldPacket << uint32(Info.BorderColor);
+    _worldPacket << uint32(Info.BackgroundColor);
+    _worldPacket << uint32(Info.RankCount);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildCreate::Read()
+{
+    _worldPacket >> GuildName;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildInfoResponse::Write()
+{
+    _worldPacket << GuildName;
+    _worldPacket.AppendPackedTime(CreateDate);
+    _worldPacket << int32(NumMembers);
+    _worldPacket << int32(NumAccounts);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildRoster::Write()
+{
+    _worldPacket << uint32(MemberData.size());
+    _worldPacket << WelcomeText;
+    _worldPacket << InfoText;
+    _worldPacket << uint32(RankData.size());
+
+    for (GuildRankData const& rank : RankData)
+        _worldPacket << rank;
+
+    for (GuildRosterMemberData const& member : MemberData)
+        _worldPacket << member;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildUpdateMotdText::Read()
+{
+    _worldPacket >> MotdText;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildCommandResult::Write()
+{
+    _worldPacket << int32(Command);
+    _worldPacket << Name;
+    _worldPacket << int32(Result);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildInviteByName::Read()
+{
+    _worldPacket >> Name;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildInvite::Write()
+{
+    _worldPacket << InviterName;
+    _worldPacket << GuildName;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData)
+{
+    data << rosterMemberData.Guid;
+    data << uint8(rosterMemberData.Status);
+    data << rosterMemberData.Name;
+    data << int32(rosterMemberData.RankID);
+    data << uint8(rosterMemberData.Level);
+    data << uint8(rosterMemberData.ClassID);
+    data << uint8(rosterMemberData.Gender);
+    data << int32(rosterMemberData.AreaID);
+    if (!rosterMemberData.Status)
+        data << float(rosterMemberData.LastSave);
+
+    data << rosterMemberData.Note;
+    data << rosterMemberData.OfficerNote;
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEvent::Write()
+{
+    _worldPacket << uint8(Type);
+    uint8 paramCount = Params[2] ? 3 : (Params[1] ? 2 : (Params[0] ? 1 : 0));
+    _worldPacket << uint8(paramCount);
+    for (uint8 i = 0; i < paramCount; ++i)
+        _worldPacket << Params[i];
+
+    switch (Type)
+    {
+        case GE_JOINED:
+        case GE_LEFT:
+        case GE_SIGNED_ON:
+        case GE_SIGNED_OFF:
+            _worldPacket << Guid;
+            break;
+        default:
+            break;
+    }
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventLogQueryResults::Write()
+{
+    _worldPacket.reserve(4 + Entry.size() * 38);
+
+    _worldPacket << uint32(Entry.size());
+
+    for (GuildEventEntry const& entry : Entry)
+    {
+        _worldPacket << uint8(entry.TransactionType);
+        _worldPacket << entry.PlayerGUID;
+        if (entry.TransactionType != GUILD_EVENT_LOG_JOIN_GUILD && entry.TransactionType != GUILD_EVENT_LOG_LEAVE_GUILD)
+            _worldPacket << entry.OtherGUID;
+        if (entry.TransactionType == GUILD_EVENT_LOG_PROMOTE_PLAYER || entry.TransactionType == GUILD_EVENT_LOG_DEMOTE_PLAYER)
+            _worldPacket << uint8(entry.RankID);
+        _worldPacket << uint32(entry.TransactionDate);
+    }
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildPermissionsQueryResults::Write()
+{
+    _worldPacket << uint32(RankID);
+    _worldPacket << int32(Flags);
+    _worldPacket << int32(WithdrawGoldLimit);
+    _worldPacket << int8(NumTabs);
+
+    for (GuildRankTabPermissions const& tab : Tab)
+    {
+        _worldPacket << int32(tab.Flags);
+        _worldPacket << int32(tab.WithdrawItemLimit);
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildSetRankPermissions::Read()
+{
+    _worldPacket >> RankID;
+    _worldPacket >> Flags;
+    _worldPacket >> RankName;
+    _worldPacket >> WithdrawGoldLimit;
+
+    for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
+    {
+        _worldPacket >> TabFlags[i];
+        _worldPacket >> TabWithdrawItemLimit[i];
+    }
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData)
+{
+    data << uint32(rankData.Flags);
+    data << uint32(rankData.WithdrawGoldLimit);
+
+    for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
+    {
+        data << uint32(rankData.TabFlags[i]);
+        data << uint32(rankData.TabWithdrawItemLimit[i]);
+    }
+
+    return data;
+}
+
+void WorldPackets::Guild::GuildAddRank::Read()
+{
+    _worldPacket >> Name;
+}
+
+void WorldPackets::Guild::GuildUpdateInfoText::Read()
+{
+    _worldPacket >> InfoText;
+}
+
+void WorldPackets::Guild::GuildSetMemberNote::Read()
+{
+    _worldPacket >> NoteeName;
+    _worldPacket >> Note;
+}
+
+void WorldPackets::Guild::GuildDemoteMember::Read()
+{
+    _worldPacket >> Demotee;
+}
+
+void WorldPackets::Guild::GuildPromoteMember::Read()
+{
+    _worldPacket >> Promotee;
+}
+
+void WorldPackets::Guild::GuildOfficerRemoveMember::Read()
+{
+    _worldPacket >> Removee;
+}
+
+void WorldPackets::Guild::GuildBankActivate::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> FullUpdate;
+}
+
+void WorldPackets::Guild::GuildBankBuyTab::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> BankTab;
+}
+
+void WorldPackets::Guild::GuildBankUpdateTab::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> BankTab;
+    _worldPacket >> Name;
+    _worldPacket >> Icon;
+}
+
+void WorldPackets::Guild::GuildBankDepositMoney::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> Money;
+}
+
+void WorldPackets::Guild::GuildBankQueryTab::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> Tab;
+    _worldPacket >> FullUpdate;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildBankRemainingWithdrawMoney::Write()
+{
+    _worldPacket << RemainingWithdrawMoney;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankWithdrawMoney::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> Money;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildBankQueryResults::Write()
+{
+    _worldPacket << uint64(Money);
+    _worldPacket << uint8(Tab);
+    _withdrawalsRemainingPos = _worldPacket.wpos();
+    _worldPacket << int32(WithdrawalsRemaining);
+    _worldPacket << uint8(FullUpdate);
+
+    if (!Tab && FullUpdate)
+    {
+        _worldPacket << uint8(TabInfo.size());
+        for (GuildBankTabInfo const& tab : TabInfo)
+        {
+            _worldPacket << tab.Name;
+            _worldPacket << tab.Icon;
+        }
+    }
+
+    _worldPacket << uint8(ItemInfo.size());
+    for (GuildBankItemInfo const& item : ItemInfo)
+    {
+        _worldPacket << uint8(item.Slot);
+        _worldPacket << uint32(item.ItemID);
+        if (item.ItemID)
+        {
+            _worldPacket << int32(item.Flags);
+            _worldPacket << int32(item.RandomPropertiesID);
+            if (item.RandomPropertiesID)
+                _worldPacket << int32(item.RandomPropertiesSeed);
+
+            _worldPacket << int32(item.Count);
+            _worldPacket << int32(item.EnchantmentID);
+            _worldPacket << uint8(item.Charges);
+            _worldPacket << uint8(item.SocketEnchant.size());
+
+            for (GuildBankSocketEnchant const& socketEnchant : item.SocketEnchant)
+            {
+                _worldPacket << uint8(socketEnchant.SocketIndex);
+                _worldPacket << int32(socketEnchant.SocketEnchantID);
+            }
+        }
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankQueryResults::SetWithdrawalsRemaining(int32 withdrawalsRemaining)
+{
+    WithdrawalsRemaining = withdrawalsRemaining;
+    _worldPacket.put<int32>(_withdrawalsRemainingPos, withdrawalsRemaining);
+}
+
+void WorldPackets::Guild::GuildBankSwapItems::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> BankOnly;
+
+    if (BankOnly)
+    {
+        // dest
+        _worldPacket >> BankTab;
+        _worldPacket >> BankSlot;
+        _worldPacket >> ItemID;
+
+        // src
+        _worldPacket >> BankTab1;
+        _worldPacket >> BankSlot1;
+        _worldPacket >> ItemID1;
+
+        _worldPacket >> AutoStore;
+        _worldPacket >> BankItemCount;
+    }
+    else
+    {
+        _worldPacket >> BankTab;
+        _worldPacket >> BankSlot;
+        _worldPacket >> ItemID;
+
+        _worldPacket >> AutoStore;
+        if (AutoStore)
+        {
+            _worldPacket >> BankItemCount;
+            _worldPacket >> ToSlot;
+            _worldPacket >> StackCount;
+        }
+        else
+        {
+            _worldPacket >> ContainerSlot;
+            _worldPacket >> ContainerItemSlot;
+            _worldPacket >> ToSlot;
+            _worldPacket >> StackCount;
+        }
+    }
+}
+
+void WorldPackets::Guild::GuildBankLogQuery::Read()
+{
+    _worldPacket >> Tab;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildBankLogQueryResults::Write()
+{
+    _worldPacket << uint8(Tab);
+    _worldPacket << uint8(Entry.size());
+
+    for (GuildBankLogEntry const& logEntry : Entry)
+    {
+        _worldPacket << int8(logEntry.EntryType);
+        _worldPacket << logEntry.PlayerGUID;
+
+        switch (logEntry.EntryType)
+        {
+            case GUILD_BANK_LOG_DEPOSIT_ITEM:
+            case GUILD_BANK_LOG_WITHDRAW_ITEM:
+                _worldPacket << uint32(logEntry.ItemID);
+                _worldPacket << uint32(logEntry.Count);
+                break;
+            case GUILD_BANK_LOG_MOVE_ITEM:
+            case GUILD_BANK_LOG_MOVE_ITEM2:
+                _worldPacket << uint32(logEntry.ItemID);
+                _worldPacket << uint32(logEntry.Count);
+                _worldPacket << uint8(logEntry.OtherTab);
+                break;
+            default:
+                _worldPacket << uint32(logEntry.Money);
+                break;
+        }
+
+        _worldPacket << uint32(logEntry.TimeOffset);
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankTextQuery::Read()
+{
+    _worldPacket >> Tab;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildBankTextQueryResult::Write()
+{
+    _worldPacket << uint8(Tab);
+    _worldPacket << Text;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankSetTabText::Read()
+{
+    _worldPacket >> Tab;
+    _worldPacket >> TabText;
+}
+
+void WorldPackets::Guild::GuildSetGuildMaster::Read()
+{
+    _worldPacket >> NewMasterName;
+}
+
+void WorldPackets::Guild::SaveGuildEmblem::Read()
+{
+    _worldPacket >> Vendor;
+    _worldPacket >> EStyle;
+    _worldPacket >> EColor;
+    _worldPacket >> BStyle;
+    _worldPacket >> BColor;
+    _worldPacket >> Bg;
+}
+
+WorldPacket const* WorldPackets::Guild::PlayerSaveGuildEmblem::Write()
+{
+    _worldPacket << int32(Error);
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/GuildPackets.h b/src/server/game/Server/Packets/GuildPackets.h
new file mode 100644
index 00000000000..753e1d42551
--- /dev/null
+++ b/src/server/game/Server/Packets/GuildPackets.h
@@ -0,0 +1,627 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GuildPackets_h__
+#define GuildPackets_h__
+
+#include "Packet.h"
+#include "Guild.h"
+#include "ObjectGuid.h"
+#include "PacketUtilities.h"
+
+namespace WorldPackets
+{
+    namespace Guild
+    {
+        class QueryGuildInfo final : public ClientPacket
+        {
+        public:
+            QueryGuildInfo(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_QUERY, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 GuildId;
+        };
+
+        struct GuildInfo
+        {
+            std::string GuildName;
+
+            std::array<std::string, GUILD_RANKS_MAX_COUNT> Ranks;
+            uint32 RankCount = 0;
+
+            uint32 EmblemStyle = 0;
+            uint32 EmblemColor = 0;
+            uint32 BorderStyle = 0;
+            uint32 BorderColor = 0;
+            uint32 BackgroundColor = 0;
+        };
+
+        class QueryGuildInfoResponse final : public ServerPacket
+        {
+        public:
+            QueryGuildInfoResponse();
+
+            WorldPacket const* Write() override;
+
+            uint32 GuildId;
+            GuildInfo Info;
+        };
+
+        class GuildCreate final : public ClientPacket
+        {
+        public:
+            GuildCreate(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_CREATE, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string GuildName;
+        };
+
+        class GuildGetInfo final : ClientPacket
+        {
+        public:
+            GuildGetInfo(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INFO, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildInfoResponse final : ServerPacket
+        {
+        public:
+            GuildInfoResponse() : ServerPacket(SMSG_GUILD_INFO, 123) { }
+
+            WorldPacket const* Write() override;
+
+            std::string GuildName;
+            time_t CreateDate = time_t(0);
+            int32 NumMembers = 0;
+            int32 NumAccounts = 0;
+        };
+
+        class GuildGetRoster final : public ClientPacket
+        {
+        public:
+            GuildGetRoster(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ROSTER, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct GuildRosterMemberData
+        {
+            ObjectGuid Guid;
+            int64 WeeklyXP = 0;
+            int64 TotalXP = 0;
+            int32 RankID = 0;
+            int32 AreaID = 0;
+            float LastSave = 0.0f;
+            std::string Name;
+            std::string Note;
+            std::string OfficerNote;
+            uint8 Status = 0;
+            uint8 Level = 0;
+            uint8 ClassID = 0;
+            uint8 Gender = 0;
+        };
+
+        struct GuildRankData
+        {
+            uint32 Flags = 0;
+            uint32 WithdrawGoldLimit = 0;
+            uint32 TabFlags[GUILD_BANK_MAX_TABS];
+            uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
+        };
+
+        class GuildRoster final : public ServerPacket
+        {
+        public:
+            GuildRoster() : ServerPacket(SMSG_GUILD_ROSTER, 4 + 4 + 4 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildRosterMemberData> MemberData;
+            std::vector<GuildRankData> RankData;
+            std::string WelcomeText;
+            std::string InfoText;
+        };
+
+        class GuildUpdateMotdText final : public ClientPacket
+        {
+        public:
+            GuildUpdateMotdText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_MOTD, std::move(packet)) { }
+
+            void Read() override;
+
+            String<128, Strings::NoHyperlinks> MotdText;
+        };
+
+        class GuildCommandResult final : public ServerPacket
+        {
+        public:
+            GuildCommandResult() : ServerPacket(SMSG_GUILD_COMMAND_RESULT, 9) { }
+
+            WorldPacket const* Write() override;
+
+            std::string Name;
+            int32 Result = 0;
+            int32 Command = 0;
+        };
+
+        class AcceptGuildInvite final : public ClientPacket
+        {
+        public:
+            AcceptGuildInvite(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ACCEPT, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildDeclineInvitation final : public ClientPacket
+        {
+        public:
+            GuildDeclineInvitation(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DECLINE, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildInviteByName final : public ClientPacket
+        {
+        public:
+            GuildInviteByName(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INVITE, std::move(packet)) { }
+
+            void Read() override;
+
+            String<48> Name;
+        };
+
+        class GuildInvite final : public ServerPacket
+        {
+        public:
+            GuildInvite() : ServerPacket(SMSG_GUILD_INVITE, 144) { }
+
+            WorldPacket const* Write() override;
+
+            std::string InviterName;
+            std::string GuildName;
+        };
+
+        class GuildEvent final : public ServerPacket
+        {
+        public:
+            GuildEvent() : ServerPacket(SMSG_GUILD_EVENT) { }
+
+            WorldPacket const* Write() override;
+
+            uint8 Type = 0;
+            std::array<char const*, 3> Params = { };
+            ObjectGuid Guid;
+        };
+
+        struct GuildEventEntry
+        {
+            ObjectGuid PlayerGUID;
+            ObjectGuid OtherGUID;
+            uint8 TransactionType = 0;
+            uint8 RankID = 0;
+            uint32 TransactionDate = 0;
+        };
+
+        class GuildEventLogQuery final : public ClientPacket
+        {
+        public:
+            GuildEventLogQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_EVENT_LOG_QUERY, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildEventLogQueryResults final : public ServerPacket
+        {
+        public:
+            GuildEventLogQueryResults() : ServerPacket(MSG_GUILD_EVENT_LOG_QUERY, 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildEventEntry> Entry;
+        };
+
+        class GuildPermissionsQuery final : public ClientPacket
+        {
+        public:
+            GuildPermissionsQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_PERMISSIONS, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildPermissionsQueryResults final : public ServerPacket
+        {
+        public:
+            struct GuildRankTabPermissions
+            {
+                int32 Flags = 0;
+                int32 WithdrawItemLimit = 0;
+            };
+
+            GuildPermissionsQueryResults() : ServerPacket(MSG_GUILD_PERMISSIONS, 20) { }
+
+            WorldPacket const* Write() override;
+
+            int8 NumTabs = 0;
+            int32 WithdrawGoldLimit = 0;
+            int32 Flags = 0;
+            uint32 RankID = 0;
+            std::array<GuildRankTabPermissions, GUILD_BANK_MAX_TABS> Tab;
+        };
+
+        class GuildSetRankPermissions final : public ClientPacket
+        {
+        public:
+            GuildSetRankPermissions(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_RANK, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 RankID = 0;
+            uint32 WithdrawGoldLimit = 0;
+            uint32 Flags = 0;
+            uint32 TabFlags[GUILD_BANK_MAX_TABS];
+            uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
+            String<15, Strings::NoHyperlinks> RankName;
+        };
+
+        class GuildAddRank final : public ClientPacket
+        {
+        public:
+            GuildAddRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ADD_RANK, std::move(packet)) { }
+
+            void Read() override;
+
+            String<15, Strings::NoHyperlinks> Name;
+        };
+
+        class GuildDeleteRank final : public ClientPacket
+        {
+        public:
+            GuildDeleteRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DEL_RANK, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildUpdateInfoText final : public ClientPacket
+        {
+        public:
+            GuildUpdateInfoText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INFO_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            String<500, Strings::NoHyperlinks> InfoText;
+        };
+
+        class GuildSetMemberNote final : public ClientPacket
+        {
+        public:
+            GuildSetMemberNote(WorldPacket&& packet) : ClientPacket(std::move(packet)) { }
+
+            void Read() override;
+
+            std::string NoteeName;
+            String<31, Strings::NoHyperlinks> Note;
+        };
+
+        class GuildDelete final : public ClientPacket
+        {
+        public:
+            GuildDelete(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DISBAND, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildDemoteMember final : public ClientPacket
+        {
+        public:
+            GuildDemoteMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DEMOTE, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string Demotee;
+        };
+
+        class GuildPromoteMember final : public ClientPacket
+        {
+        public:
+            GuildPromoteMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_PROMOTE, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string Promotee;
+        };
+
+        class GuildOfficerRemoveMember : public ClientPacket
+        {
+        public:
+            GuildOfficerRemoveMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_REMOVE, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string Removee;
+        };
+
+        class GuildLeave final : public ClientPacket
+        {
+        public:
+            GuildLeave(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_LEAVE, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildBankActivate final : public ClientPacket
+        {
+        public:
+            GuildBankActivate(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANKER_ACTIVATE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            bool FullUpdate = false;
+        };
+
+        class GuildBankBuyTab final : public ClientPacket
+        {
+        public:
+            GuildBankBuyTab(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_BUY_TAB, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            uint8 BankTab = 0;
+        };
+
+        class GuildBankUpdateTab final : public ClientPacket
+        {
+        public:
+            GuildBankUpdateTab(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_UPDATE_TAB, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            uint8 BankTab = 0;
+            String<16, Strings::NoHyperlinks> Name;
+            String<100> Icon;
+        };
+
+        class GuildBankDepositMoney final : public ClientPacket
+        {
+        public:
+            GuildBankDepositMoney(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_DEPOSIT_MONEY, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            uint32 Money = 0;
+        };
+
+        class GuildBankQueryTab final : public ClientPacket
+        {
+        public:
+            GuildBankQueryTab(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_QUERY_TAB, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            uint8 Tab = 0;
+            bool FullUpdate = false;
+        };
+
+        class GuildBankRemainingWithdrawMoneyQuery final : public ClientPacket
+        {
+        public:
+            GuildBankRemainingWithdrawMoneyQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_BANK_MONEY_WITHDRAWN, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildBankRemainingWithdrawMoney final : public ServerPacket
+        {
+        public:
+            GuildBankRemainingWithdrawMoney() : ServerPacket(MSG_GUILD_BANK_MONEY_WITHDRAWN, 8) { }
+
+            WorldPacket const* Write() override;
+
+            int32 RemainingWithdrawMoney = 0;
+        };
+
+        class GuildBankWithdrawMoney final : public ClientPacket
+        {
+        public:
+            GuildBankWithdrawMoney(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_WITHDRAW_MONEY, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            uint32 Money = 0;
+        };
+
+        struct GuildBankSocketEnchant
+        {
+            uint8 SocketIndex = 0;
+            int32 SocketEnchantID = 0;
+        };
+
+        struct GuildBankItemInfo
+        {
+            uint32 ItemID = 0;
+            int32 RandomPropertiesSeed = 0;
+            int32 RandomPropertiesID = 0;
+            uint8 Slot = 0;
+            int32 Count = 0;
+            int32 EnchantmentID = 0;
+            int32 Charges = 0;
+            int32 Flags = 0;
+            std::vector<GuildBankSocketEnchant> SocketEnchant;
+        };
+
+        struct GuildBankTabInfo
+        {
+            std::string Name;
+            std::string Icon;
+        };
+
+        class GuildBankQueryResults final : public ServerPacket
+        {
+        public:
+            GuildBankQueryResults() : ServerPacket(SMSG_GUILD_BANK_LIST, 25) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildBankItemInfo> ItemInfo;
+            std::vector<GuildBankTabInfo> TabInfo;
+            int32 WithdrawalsRemaining = 0;
+            uint8 Tab = 0;
+            uint64 Money = 0;
+            bool FullUpdate = false;
+
+            void SetWithdrawalsRemaining(int32 withdrawalsRemaining);
+
+        private:
+            std::size_t _withdrawalsRemainingPos = 0;
+        };
+
+        class GuildBankSwapItems final : public ClientPacket
+        {
+        public:
+            GuildBankSwapItems(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_SWAP_ITEMS, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            int32 StackCount = 0;
+            int32 BankItemCount = 0;
+            uint32 ItemID = 0;
+            uint32 ItemID1 = 0;
+            uint8 ToSlot = 0;
+            uint8 BankSlot = 0;
+            uint8 BankSlot1 = 0;
+            uint8 BankTab = 0;
+            uint8 BankTab1 = 0;
+            uint8 ContainerSlot = 0;
+            uint8 ContainerItemSlot = 0;
+            bool AutoStore = false;
+            bool BankOnly = false;
+        };
+
+        class GuildBankLogQuery final : public ClientPacket
+        {
+        public:
+            GuildBankLogQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_BANK_LOG_QUERY, std::move(packet)) { }
+
+            void Read() override;
+
+            uint8 Tab = 0;
+        };
+
+        struct GuildBankLogEntry
+        {
+            ObjectGuid PlayerGUID;
+            uint32 TimeOffset = 0;
+            int8 EntryType = 0;
+            uint32 Money = 0;
+            int32 ItemID = 0;
+            int32 Count = 0;
+            int8 OtherTab = 0;
+        };
+
+        class GuildBankLogQueryResults final : public ServerPacket
+        {
+        public:
+            GuildBankLogQueryResults() : ServerPacket(MSG_GUILD_BANK_LOG_QUERY, 25) { }
+
+            WorldPacket const* Write() override;
+
+            uint8 Tab = 0;
+            std::vector<GuildBankLogEntry> Entry;
+        };
+
+        class GuildBankTextQuery final : public ClientPacket
+        {
+        public:
+            GuildBankTextQuery(WorldPacket&& packet) : ClientPacket(MSG_QUERY_GUILD_BANK_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint8 Tab = 0;
+        };
+
+        class GuildBankTextQueryResult : public ServerPacket
+        {
+        public:
+            GuildBankTextQueryResult() : ServerPacket(MSG_QUERY_GUILD_BANK_TEXT, 4 + 2) { }
+
+            WorldPacket const* Write() override;
+
+            uint8 Tab = 0;
+            std::string Text;
+        };
+
+        class GuildBankSetTabText final : public ClientPacket
+        {
+        public:
+            GuildBankSetTabText(WorldPacket&& packet) : ClientPacket(CMSG_SET_GUILD_BANK_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            uint8 Tab = 0;
+            String<500, Strings::NoHyperlinks> TabText;
+        };
+
+        class GuildSetGuildMaster final : public ClientPacket
+        {
+        public:
+            GuildSetGuildMaster(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_LEADER, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string NewMasterName;
+        };
+
+        class SaveGuildEmblem final : public ClientPacket
+        {
+        public:
+            SaveGuildEmblem(WorldPacket&& packet) : ClientPacket(MSG_SAVE_GUILD_EMBLEM, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Vendor;
+            int32 BStyle = 0;
+            int32 EStyle = 0;
+            int32 BColor = 0;
+            int32 EColor = 0;
+            int32 Bg = 0;
+        };
+
+        class PlayerSaveGuildEmblem final : public ServerPacket
+        {
+        public:
+            PlayerSaveGuildEmblem() : ServerPacket(MSG_SAVE_GUILD_EMBLEM, 4) { }
+
+            WorldPacket const* Write() override;
+
+            int32 Error = 0;
+        };
+    }
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData);
+
+#endif // GuildPackets_h__