Core/Guild: Updated and enabled most previously implemented guild and petition related packets

Merged from https://github.com/Mogadischu/TrinityCore/commits/guild

Signed-off-by: Duarte Duarte <dnpd.dd@gmail.com>

12 files changed, 2354 insertions, 217 deletions

diff --git a/src/server/game/Server/Packets/GuildPackets.cpp b/src/server/game/Server/Packets/GuildPackets.cpp
index 5ad6d9729c2..ef0c01c5cb7 100644
--- a/src/server/game/Server/Packets/GuildPackets.cpp
+++ b/src/server/game/Server/Packets/GuildPackets.cpp
@@ -58,3 +58,755 @@ WorldPacket const* WorldPackets::Guild::QueryGuildInfoResponse::Write()
 
     return &_worldPacket;
 }
+
+WorldPacket const* WorldPackets::Guild::GuildRoster::Write()
+{
+    _worldPacket << NumAccounts;
+    _worldPacket.AppendPackedTime(CreateDate);
+    _worldPacket << GuildFlags;
+    _worldPacket << uint32(MemberData.size());
+
+    for (GuildRosterMemberData const& member : MemberData)
+        _worldPacket << member;
+
+    _worldPacket.ResetBitPos();
+    _worldPacket.WriteBits(WelcomeText.length(), 10);
+    _worldPacket.WriteBits(InfoText.length(), 10);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(WelcomeText);
+    _worldPacket.WriteString(InfoText);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildRosterUpdate::Write()
+{
+    _worldPacket << uint32(MemberData.size());
+
+    for (GuildRosterMemberData const& member : MemberData)
+        _worldPacket << member;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildUpdateMotdText::Read()
+{
+    uint32 textLen = _worldPacket.ReadBits(10);
+    MotdText = _worldPacket.ReadString(textLen);
+}
+
+WorldPacket const* WorldPackets::Guild::GuildCommandResult::Write()
+{
+    _worldPacket << Result;
+    _worldPacket << Command;
+
+    _worldPacket.WriteBits(Name.length(), 8);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Name);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::DeclineGuildInvites::Read()
+{
+    Allow = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Guild::GuildInviteByName::Read()
+{
+    uint32 nameLen = _worldPacket.ReadBits(9);
+    Name = _worldPacket.ReadString(nameLen);
+}
+
+WorldPacket const* WorldPackets::Guild::GuildInvite::Write()
+{
+    _worldPacket.WriteBits(InviterName.length(), 6);
+    _worldPacket.WriteBits(GuildName.length(), 7);
+    _worldPacket.WriteBits(OldGuildName.length(), 7);
+    _worldPacket.FlushBits();
+
+    _worldPacket << InviterVirtualRealmAddress;
+    _worldPacket << GuildVirtualRealmAddress;
+    _worldPacket << GuildGUID;
+    _worldPacket << OldGuildVirtualRealmAddress;
+    _worldPacket << OldGuildGUID;
+    _worldPacket << EmblemStyle;
+    _worldPacket << EmblemColor;
+    _worldPacket << BorderStyle;
+    _worldPacket << BorderColor;
+    _worldPacket << Background;
+    _worldPacket << Level;
+
+    _worldPacket.WriteString(InviterName);
+    _worldPacket.WriteString(GuildName);
+    _worldPacket.WriteString(OldGuildName);
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterProfessionData const& rosterProfessionData)
+{
+    data << rosterProfessionData.DbID;
+    data << rosterProfessionData.Rank;
+    data << rosterProfessionData.Step;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData)
+{
+    data << rosterMemberData.Guid;
+    data << rosterMemberData.RankID;
+    data << rosterMemberData.AreaID;
+    data << rosterMemberData.PersonalAchievementPoints;
+    data << rosterMemberData.GuildReputation;
+    data << rosterMemberData.LastSave;
+
+    for (uint8 i = 0; i < 2; i++)
+        data << rosterMemberData.Profession[i];
+
+    data << rosterMemberData.VirtualRealmAddress;
+    data << rosterMemberData.Status;
+    data << rosterMemberData.Level;
+    data << rosterMemberData.ClassID;
+    data << rosterMemberData.Gender;
+
+    data.WriteBits(rosterMemberData.Name.length(), 6);
+    data.WriteBits(rosterMemberData.Note.length(), 8);
+    data.WriteBits(rosterMemberData.OfficerNote.length(), 8);
+    data.WriteBit(rosterMemberData.Authenticated);
+    data.WriteBit(rosterMemberData.SorEligible);
+    data.FlushBits();
+
+    data.WriteString(rosterMemberData.Name);
+    data.WriteString(rosterMemberData.Note);
+    data.WriteString(rosterMemberData.OfficerNote);
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventPresenceChange::Write()
+{
+    _worldPacket << Guid;
+    _worldPacket << VirtualRealmAddress;
+
+    _worldPacket.WriteBits(Name.length(), 6);
+    _worldPacket.WriteBit(LoggedOn);
+    _worldPacket.WriteBit(Mobile);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Name);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventMotd::Write()
+{
+    _worldPacket.WriteBits(MotdText.length(), 10);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(MotdText);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventPlayerJoined::Write()
+{
+    _worldPacket << Guid;
+    _worldPacket << VirtualRealmAddress;
+
+    _worldPacket.WriteBits(Name.length(), 6);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Name);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventRankChanged::Write()
+{
+    _worldPacket << RankID;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventBankMoneyChanged::Write()
+{
+    _worldPacket << Money;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventLogQueryResults::Write()
+{
+    _worldPacket.reserve(4 + Entry.size() * 38);
+
+    _worldPacket << uint32(Entry.size());
+
+    for (GuildEventEntry const& entry : Entry)
+    {
+        _worldPacket << entry.PlayerGUID;
+        _worldPacket << entry.OtherGUID;
+        _worldPacket << entry.TransactionType;
+        _worldPacket << entry.RankID;
+        _worldPacket << entry.TransactionDate;
+    }
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventPlayerLeft::Write()
+{
+    _worldPacket.WriteBit(Removed);
+    _worldPacket.WriteBits(LeaverName.length(), 6);
+    _worldPacket.FlushBits();
+
+    if (Removed)
+    {
+        _worldPacket.WriteBits(RemoverName.length(), 6);
+        _worldPacket.FlushBits();
+
+        _worldPacket << RemoverGUID;
+        _worldPacket << RemoverVirtualRealmAddress;
+        _worldPacket.WriteString(RemoverName);
+    }
+
+    _worldPacket << LeaverGUID;
+    _worldPacket << LeaverVirtualRealmAddress;
+    _worldPacket.WriteString(LeaverName);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildPermissionsQueryResults::Write()
+{
+    _worldPacket << RankID;
+    _worldPacket << WithdrawGoldLimit;
+    _worldPacket << Flags;
+    _worldPacket << NumTabs;
+    _worldPacket << uint32(Tab.size());
+
+    for (GuildRankTabPermissions const& tab : Tab)
+    {
+        _worldPacket << tab.Flags;
+        _worldPacket << tab.WithdrawItemLimit;
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildSetRankPermissions::Read()
+{
+    _worldPacket >> RankID;
+    _worldPacket >> RankOrder;
+    _worldPacket >> Flags;
+    _worldPacket >> OldFlags;
+    _worldPacket >> WithdrawGoldLimit;
+
+    for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
+    {
+        _worldPacket >> TabFlags[i];
+        _worldPacket >> TabWithdrawItemLimit[i];
+    }
+
+    _worldPacket.ResetBitPos();
+    uint32 rankNameLen = _worldPacket.ReadBits(7);
+
+    RankName = _worldPacket.ReadString(rankNameLen);
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventNewLeader::Write()
+{
+    _worldPacket.WriteBit(SelfPromoted);
+    _worldPacket.WriteBits(NewLeaderName.length(), 6);
+    _worldPacket.WriteBits(OldLeaderName.length(), 6);
+    _worldPacket.FlushBits();
+
+    _worldPacket << OldLeaderGUID;
+    _worldPacket << OldLeaderVirtualRealmAddress;
+    _worldPacket << NewLeaderGUID;
+    _worldPacket << NewLeaderVirtualRealmAddress;
+
+    _worldPacket.WriteString(NewLeaderName);
+    _worldPacket.WriteString(OldLeaderName);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventTabModified::Write()
+{
+    _worldPacket << Tab;
+
+    _worldPacket.WriteBits(Name.length(), 7);
+    _worldPacket.WriteBits(Icon.length(), 9);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Name);
+    _worldPacket.WriteString(Icon);
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildEventTabTextChanged::Write()
+{
+    _worldPacket << Tab;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData)
+{
+    data << rankData.RankID;
+    data << rankData.RankOrder;
+    data << rankData.Flags;
+    data << rankData.WithdrawGoldLimit;
+
+    for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
+    {
+        data << rankData.TabFlags[i];
+        data << rankData.TabWithdrawItemLimit[i];
+    }
+
+    data.WriteBits(rankData.RankName.length(), 7);
+    data.FlushBits();
+
+    data.WriteString(rankData.RankName);
+
+    return data;
+}
+
+void WorldPackets::Guild::GuildAddRank::Read()
+{
+    _worldPacket.WriteBits(Name.length(), 7);
+    _worldPacket.FlushBits();
+
+    _worldPacket >> RankOrder;
+    _worldPacket.WriteString(Name);
+}
+
+void WorldPackets::Guild::GuildAssignMemberRank::Read()
+{
+    _worldPacket >> Member;
+    _worldPacket >> RankOrder;
+}
+
+void WorldPackets::Guild::GuildDeleteRank::Read()
+{
+    _worldPacket >> RankOrder;
+}
+
+void WorldPackets::Guild::GuildGetRanks::Read()
+{
+    _worldPacket >> GuildGUID;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildRanks::Write()
+{
+    _worldPacket << uint32(Ranks.size());
+
+    for (GuildRankData const& rank : Ranks)
+        _worldPacket << rank;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildSendRankChange::Write()
+{
+    _worldPacket << Officer;
+    _worldPacket << Other;
+    _worldPacket << RankID;
+
+    _worldPacket.WriteBit(Promote);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildShiftRank::Read()
+{
+    _worldPacket >> RankOrder;
+    ShiftUp = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Guild::GuildUpdateInfoText::Read()
+{
+    uint32 textLen = _worldPacket.ReadBits(11);
+    InfoText = _worldPacket.ReadString(textLen);
+}
+
+void WorldPackets::Guild::GuildSetMemberNote::Read()
+{
+    _worldPacket >> NoteeGUID;
+
+    uint32 noteLen = _worldPacket.ReadBits(8);
+    IsPublic = _worldPacket.ReadBit();
+
+    Note = _worldPacket.ReadString(noteLen);
+}
+
+WorldPacket const* WorldPackets::Guild::GuildMemberUpdateNote::Write()
+{
+    _worldPacket.reserve(16 + 2 + Note.size());
+
+    _worldPacket << Member;
+
+    _worldPacket.WriteBits(Note.length(), 8);
+    _worldPacket.WriteBit(IsPublic);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Note);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildDemoteMember::Read()
+{
+    _worldPacket >> Demotee;
+}
+
+void WorldPackets::Guild::GuildPromoteMember::Read()
+{
+    _worldPacket >> Promotee;
+}
+
+void WorldPackets::Guild::GuildOfficerRemoveMember::Read()
+{
+    _worldPacket >> Removee;
+}
+
+void WorldPackets::Guild::GuildChangeNameRequest::Read()
+{
+    uint32 nameLen = _worldPacket.ReadBits(7);
+    NewName = _worldPacket.ReadString(nameLen);
+}
+
+WorldPacket const* WorldPackets::Guild::GuildFlaggedForRename::Write()
+{
+    _worldPacket.WriteBit(FlagSet);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::RequestGuildPartyState::Read()
+{
+    _worldPacket >> GuildGUID;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildPartyState::Write()
+{
+    _worldPacket.WriteBit(InGuildParty);
+    _worldPacket.FlushBits();
+
+    _worldPacket << NumMembers;
+    _worldPacket << NumRequired;
+    _worldPacket << GuildXPEarnedMult;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRewardItem const& rewardItem)
+{
+    data << rewardItem.ItemID;
+    data << uint32(rewardItem.AchievementsRequired.size());
+    data << rewardItem.RaceMask;
+    data << rewardItem.MinGuildLevel;
+    data << rewardItem.MinGuildRep;
+    data << rewardItem.Cost;
+
+    for (uint8 i = 0; i < rewardItem.AchievementsRequired.size(); i++)
+        data << rewardItem.AchievementsRequired[i];
+
+    return data;
+}
+
+void WorldPackets::Guild::RequestGuildRewardsList::Read()
+{
+    _worldPacket >> CurrentVersion;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildRewardList::Write()
+{
+    _worldPacket << Version;
+    _worldPacket << uint32(RewardItems.size());
+
+    for (GuildRewardItem const& item : RewardItems)
+        _worldPacket << item;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankActivate::Read()
+{
+    _worldPacket >> Banker;
+    FullUpdate = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Guild::GuildBankBuyTab::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> BankTab;
+}
+
+void WorldPackets::Guild::GuildBankUpdateTab::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> BankTab;
+
+    _worldPacket.ResetBitPos();
+    uint32 nameLen = _worldPacket.ReadBits(7);
+    uint32 iconLen = _worldPacket.ReadBits(9);
+
+    Name = _worldPacket.ReadString(nameLen);
+    Icon = _worldPacket.ReadString(iconLen);
+}
+
+void WorldPackets::Guild::GuildBankDepositMoney::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> Money;
+}
+
+void WorldPackets::Guild::GuildBankQueryTab::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> Tab;
+
+    FullUpdate = _worldPacket.ReadBit();
+}
+
+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 << Money;
+    _worldPacket << Tab;
+    _worldPacket << WithdrawalsRemaining;
+    _worldPacket << uint32(TabInfo.size());
+    _worldPacket << uint32(ItemInfo.size());
+
+    for (GuildBankTabInfo const& tab : TabInfo)
+    {
+        _worldPacket << tab.TabIndex;
+        _worldPacket.WriteBits(tab.Name.length(), 7);
+        _worldPacket.WriteBits(tab.Icon.length(), 9);
+        _worldPacket.FlushBits();
+
+        _worldPacket.WriteString(tab.Name);
+        _worldPacket.WriteString(tab.Icon);
+    }
+
+    for (GuildBankItemInfo const& item : ItemInfo)
+    {
+        _worldPacket << item.Slot;
+        _worldPacket << item.Item;
+        _worldPacket << item.Count;
+        _worldPacket << item.EnchantmentID;
+        _worldPacket << item.Charges;
+        _worldPacket << item.OnUseEnchantmentID;
+        _worldPacket << uint32(item.SocketEnchant.size());
+        _worldPacket << item.Flags;
+
+        for (GuildBankItemInfo::GuildBankSocketEnchant const& socketEnchant : item.SocketEnchant)
+        {
+            _worldPacket << socketEnchant.SocketIndex;
+            _worldPacket << socketEnchant.SocketEnchantID;
+        }
+
+        _worldPacket.WriteBit(item.Locked);
+        _worldPacket.FlushBits();
+    }
+
+    _worldPacket.WriteBit(FullUpdate);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankSwapItems::Read()
+{
+    _worldPacket >> Banker;
+    _worldPacket >> BankTab;
+    _worldPacket >> BankSlot;
+    _worldPacket >> ItemID;
+    _worldPacket >> BankTab1;
+    _worldPacket >> BankSlot1;
+    _worldPacket >> ItemID1;
+    _worldPacket >> BankItemCount;
+    _worldPacket >> ContainerSlot;
+    _worldPacket >> ContainerItemSlot;
+    _worldPacket >> ToSlot;
+    _worldPacket >> StackCount;
+
+    _worldPacket.ResetBitPos();
+    BankOnly = _worldPacket.ReadBit();
+    AutoStore = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Guild::GuildBankLogQuery::Read()
+{
+    _worldPacket >> Tab;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildBankLogQueryResults::Write()
+{
+    _worldPacket << Tab;
+    _worldPacket << uint32(Entry.size());
+
+    for (GuildBankLogEntry const& logEntry : Entry)
+    {
+        _worldPacket << logEntry.PlayerGUID;
+        _worldPacket << logEntry.TimeOffset;
+        _worldPacket << logEntry.EntryType;
+
+        _worldPacket.WriteBit(logEntry.Money.HasValue);
+        _worldPacket.WriteBit(logEntry.ItemID.HasValue);
+        _worldPacket.WriteBit(logEntry.Count.HasValue);
+        _worldPacket.WriteBit(logEntry.OtherTab.HasValue);
+        _worldPacket.FlushBits();
+
+        if (logEntry.Money.HasValue)
+            _worldPacket << logEntry.Money.Value;
+
+        if (logEntry.ItemID.HasValue)
+            _worldPacket << logEntry.ItemID.Value;
+
+        if (logEntry.Count.HasValue)
+            _worldPacket << logEntry.Count.Value;
+
+        if (logEntry.OtherTab.HasValue)
+            _worldPacket << logEntry.OtherTab.Value;
+    }
+
+    _worldPacket.WriteBit(WeeklyBonusMoney.HasValue);
+    _worldPacket.FlushBits();
+
+    if (WeeklyBonusMoney.HasValue)
+        _worldPacket << WeeklyBonusMoney.Value;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankTextQuery::Read()
+{
+    _worldPacket >> Tab;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildBankTextQueryResult::Write()
+{
+    _worldPacket << Tab;
+
+    _worldPacket.WriteBits(Text.length(), 14);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(Text);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildBankSetTabText::Read()
+{
+    _worldPacket >> Tab;
+
+    _worldPacket.ResetBitPos();
+    uint32 tabTextLen = _worldPacket.ReadBits(14);
+
+    TabText = _worldPacket.ReadString(tabTextLen);
+}
+
+void WorldPackets::Guild::GuildQueryNews::Read()
+{
+    _worldPacket >> GuildGUID;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildNewsEvent const& newsEvent)
+{
+    data << newsEvent.Id;
+    data.AppendPackedTime(newsEvent.CompletedDate);
+    data << newsEvent.Type;
+    data << newsEvent.Flags;
+
+    for (uint8 i = 0; i < 2; i++)
+        data << newsEvent.Data[i];
+
+    data << newsEvent.MemberGuid;
+    data << uint32(newsEvent.MemberList.size());
+
+    for (ObjectGuid memberGuid : newsEvent.MemberList)
+        data << memberGuid;
+
+    data.WriteBit(newsEvent.Item.HasValue);
+    data.FlushBits();
+
+    if (newsEvent.Item.HasValue)
+        data << newsEvent.Item.Value;  // WorldPackets::Item::ItemInstance
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::Guild::GuildNews::Write()
+{
+    _worldPacket << NewsEvents;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::GuildNewsUpdateSticky::Read()
+{
+    _worldPacket >> GuildGUID;
+    _worldPacket >> NewsID;
+
+    NewsID = _worldPacket.ReadBit();
+}
+
+void WorldPackets::Guild::GuildSetGuildMaster::Read()
+{
+    uint32 nameLen = _worldPacket.ReadBits(9);
+    NewMasterName = _worldPacket.ReadString(nameLen);
+}
+
+WorldPacket const* WorldPackets::Guild::GuildChallengeUpdate::Write()
+{
+    for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
+        _worldPacket << int32(CurrentCount[i]);
+
+    for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
+        _worldPacket << int32(MaxCount[i]);
+
+    for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
+        _worldPacket << int32(MaxLevelGold[i]);
+
+    for (int i = 0; i < GUILD_CHALLENGES_TYPES; ++i)
+        _worldPacket << int32(Gold[i]);
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Guild::SaveGuildEmblem::Read()
+{
+    _worldPacket >> Vendor;
+    _worldPacket >> BStyle;
+    _worldPacket >> EStyle;
+    _worldPacket >> BColor;
+    _worldPacket >> EColor;
+    _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
index d4b1e9f12bd..d117fc71f2b 100644
--- a/src/server/game/Server/Packets/GuildPackets.h
+++ b/src/server/game/Server/Packets/GuildPackets.h
@@ -20,6 +20,8 @@
 
 #include "Packet.h"
 #include "ObjectGuid.h"
+#include "Guild.h"
+#include "ItemPackets.h"
 
 namespace WorldPackets
 {
@@ -78,7 +80,938 @@ namespace WorldPackets
             ObjectGuid GuildGuid;
             Optional<GuildInfo> Info;
         };
+
+        class GuildGetRoster final : public ClientPacket
+        {
+        public:
+            GuildGetRoster(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_GET_ROSTER, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        struct GuildRosterProfessionData
+        {
+            int32 DbID = 0;
+            int32 Rank = 0;
+            int32 Step = 0;
+        };
+
+        struct GuildRosterMemberData
+        {
+            ObjectGuid Guid;
+            int64 WeeklyXP = 0;
+            int64 TotalXP = 0;
+            int32 RankID = 0;
+            int32 AreaID = 0;
+            int32 PersonalAchievementPoints = 0;
+            int32 GuildReputation = 0;
+            int32 GuildRepToCap = 0;
+            float LastSave = 0.0f;
+            std::string Name;
+            uint32 VirtualRealmAddress = 0;
+            std::string Note;
+            std::string OfficerNote;
+            uint8 Status = 0;
+            uint8 Level = 0;
+            uint8 ClassID = 0;
+            uint8 Gender = 0;
+            bool Authenticated = false;
+            bool SorEligible = false;
+            GuildRosterProfessionData Profession[2];
+        };
+
+        class GuildRoster final : public ServerPacket
+        {
+        public:
+            GuildRoster() : ServerPacket(SMSG_GUILD_ROSTER, 4 + 4 + 4 + 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildRosterMemberData> MemberData;
+            std::string WelcomeText;
+            std::string InfoText;
+            uint32 CreateDate = 0;
+            int32 NumAccounts = 0;
+            int32 GuildFlags = 0;
+        };
+
+        class GuildRosterUpdate final : public ServerPacket
+        {
+        public:
+            GuildRosterUpdate() : ServerPacket(SMSG_GUILD_ROSTER_UPDATE, 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildRosterMemberData> MemberData;
+        };
+
+        class GuildUpdateMotdText final : public ClientPacket
+        {
+        public:
+            GuildUpdateMotdText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_UPDATE_MOTD_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string 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_ACCEPT_GUILD_INVITE, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildDeclineInvitation final : public ClientPacket
+        {
+        public:
+            GuildDeclineInvitation(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DECLINE_INVITATION, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class DeclineGuildInvites final : public ClientPacket
+        {
+        public:
+            DeclineGuildInvites(WorldPacket&& packet) : ClientPacket(CMSG_DECLINE_GUILD_INVITES, std::move(packet)) { }
+
+            void Read() override;
+
+            bool Allow = false;
+        };
+
+        class GuildInviteByName final : public ClientPacket
+        {
+        public:
+            GuildInviteByName(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INVITE_BY_NAME, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string Name;
+        };
+
+        class GuildInvite final : public ServerPacket
+        {
+        public:
+            GuildInvite() : ServerPacket(SMSG_GUILD_INVITE, 68) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid GuildGUID;
+            ObjectGuid OldGuildGUID;
+            int32 Level = 0;
+            uint32 EmblemColor = 0;
+            uint32 EmblemStyle = 0;
+            uint32 BorderStyle = 0;
+            uint32 BorderColor = 0;
+            uint32 Background = 0;
+            uint32 GuildVirtualRealmAddress = 0;
+            uint32 OldGuildVirtualRealmAddress = 0;
+            uint32 InviterVirtualRealmAddress = 0;
+            std::string InviterName;
+            std::string GuildName;
+            std::string OldGuildName;
+        };
+
+        class GuildEventPresenceChange final : public ServerPacket
+        {
+        public:
+            GuildEventPresenceChange() : ServerPacket(SMSG_GUILD_EVENT_PRESENCE_CHANGE, 16 + 4 + 1 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Guid;
+            uint32 VirtualRealmAddress = 0;
+            std::string Name;
+            bool Mobile = false;
+            bool LoggedOn = false;
+        };
+
+        class GuildEventMotd final : public ServerPacket
+        {
+        public:
+            GuildEventMotd() : ServerPacket(SMSG_GUILD_EVENT_MOTD, 1) { }
+
+            WorldPacket const* Write() override;
+
+            std::string MotdText;
+        };
+
+        class GuildEventPlayerJoined final : public ServerPacket
+        {
+        public:
+            GuildEventPlayerJoined() : ServerPacket(SMSG_GUILD_EVENT_PLAYER_JOINED, 21) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Guid;
+            std::string Name;
+            uint32 VirtualRealmAddress = 0;
+        };
+
+        class GuildEventRankChanged final : public ServerPacket
+        {
+        public:
+            GuildEventRankChanged() : ServerPacket(SMSG_GUILD_EVENT_RANK_CHANGED, 4) { }
+
+            WorldPacket const* Write() override;
+
+            int32 RankID = 0;
+        };
+
+        class GuildEventRanksUpdated final : public ServerPacket
+        {
+        public:
+            GuildEventRanksUpdated() : ServerPacket(SMSG_GUILD_EVENT_RANKS_UPDATED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class GuildEventBankMoneyChanged final : public ServerPacket
+        {
+        public:
+            GuildEventBankMoneyChanged() : ServerPacket(SMSG_GUILD_EVENT_BANK_MONEY_CHANGED, 8) { }
+
+            WorldPacket const* Write() override;
+
+            uint64 Money = 0;
+        };
+
+        class GuildEventDisbanded final : public ServerPacket
+        {
+        public:
+            GuildEventDisbanded() : ServerPacket(SMSG_GUILD_EVENT_DISBANDED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        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(CMSG_GUILD_EVENT_LOG_QUERY, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildEventLogQueryResults final : public ServerPacket
+        {
+        public:
+            GuildEventLogQueryResults() : ServerPacket(SMSG_GUILD_EVENT_LOG_QUERY_RESULT, 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildEventEntry> Entry;
+        };
+
+        class GuildEventPlayerLeft final : public ServerPacket
+        {
+        public:
+            GuildEventPlayerLeft() : ServerPacket(SMSG_GUILD_EVENT_PLAYER_LEFT, 43) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid LeaverGUID;
+            std::string LeaverName;
+            uint32 LeaverVirtualRealmAddress = 0;
+            ObjectGuid RemoverGUID;
+            std::string RemoverName;
+            uint32 RemoverVirtualRealmAddress = 0;
+            bool Removed = false;
+        };
+
+        class GuildEventNewLeader final : public ServerPacket
+        {
+        public:
+            GuildEventNewLeader() : ServerPacket(SMSG_GUILD_EVENT_NEW_LEADER, 43) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid NewLeaderGUID;
+            std::string NewLeaderName;
+            uint32 NewLeaderVirtualRealmAddress = 0;
+            ObjectGuid OldLeaderGUID;
+            std::string OldLeaderName;
+            uint32 OldLeaderVirtualRealmAddress = 0;
+            bool SelfPromoted = false;
+        };
+
+        class GuildEventTabAdded final : public ServerPacket
+        {
+        public:
+            GuildEventTabAdded() : ServerPacket(SMSG_GUILD_EVENT_TAB_ADDED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class GuildEventTabModified final : public ServerPacket
+        {
+        public:
+            GuildEventTabModified() : ServerPacket(SMSG_GUILD_EVENT_TAB_MODIFIED, 6) { }
+
+            WorldPacket const* Write() override;
+
+            std::string Icon;
+            std::string Name;
+            int32 Tab = 0;
+        };
+
+        class GuildEventTabTextChanged final : public ServerPacket
+        {
+        public:
+            GuildEventTabTextChanged() : ServerPacket(SMSG_GUILD_EVENT_TAB_TEXT_CHANGED, 4) { }
+
+            WorldPacket const* Write() override;
+
+            int32 Tab = 0;
+        };
+
+        class GuildEventBankContentsChanged final : public ServerPacket
+        {
+        public:
+            GuildEventBankContentsChanged() : ServerPacket(SMSG_GUILD_EVENT_BANK_CONTENTS_CHANGED, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class GuildPermissionsQuery final : public ClientPacket
+        {
+        public:
+            GuildPermissionsQuery(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_PERMISSIONS_QUERY, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildPermissionsQueryResults final : public ServerPacket
+        {
+        public:
+            struct GuildRankTabPermissions
+            {
+                int32 Flags = 0;
+                int32 WithdrawItemLimit = 0;
+            };
+
+            GuildPermissionsQueryResults() : ServerPacket(SMSG_GUILD_PERMISSIONS_QUERY_RESULTS, 20) { }
+
+            WorldPacket const* Write() override;
+
+            int32 NumTabs = 0;
+            int32 WithdrawGoldLimit = 0;
+            int32 Flags = 0;
+            uint32 RankID = 0;
+            std::vector<GuildRankTabPermissions> Tab;
+        };
+
+        class GuildSetRankPermissions final : public ClientPacket
+        {
+        public:
+            GuildSetRankPermissions(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_SET_RANK_PERMISSIONS, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 RankID = 0;
+            int32 RankOrder = 0;
+            int32 WithdrawGoldLimit = 0;
+            uint32 Flags = 0;
+            uint32 OldFlags = 0;
+            int32 TabFlags[GUILD_BANK_MAX_TABS];
+            int32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
+            std::string RankName;
+        };
+
+        class GuildAddRank final : public ClientPacket
+        {
+        public:
+            GuildAddRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ADD_RANK, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string Name;
+            int32 RankOrder = 0;
+        };
+
+        class GuildAssignMemberRank final : public ClientPacket
+        {
+        public:
+            GuildAssignMemberRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ASSIGN_MEMBER_RANK, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Member;
+            int32 RankOrder = 0;
+        };
+
+        class GuildDeleteRank final : public ClientPacket
+        {
+        public:
+            GuildDeleteRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DELETE_RANK, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 RankOrder = 0;
+        };
+
+        class GuildGetRanks final : public ClientPacket
+        {
+        public:
+            GuildGetRanks(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_GET_RANKS, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid GuildGUID;
+        };
+
+        struct GuildRankData
+        {
+            uint32 RankID = 0;
+            uint32 RankOrder = 0;
+            uint32 Flags = 0;
+            uint32 WithdrawGoldLimit = 0;
+            std::string RankName;
+            uint32 TabFlags[GUILD_BANK_MAX_TABS];
+            uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
+        };
+
+        class GuildRanks final : public ServerPacket
+        {
+        public:
+            GuildRanks() : ServerPacket(SMSG_GUILD_RANKS, 4) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildRankData> Ranks;
+        };
+
+        class GuildSendRankChange final : public ServerPacket
+        {
+        public:
+            GuildSendRankChange() : ServerPacket(SMSG_GUILD_SEND_RANK_CHANGE, 43) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Other;
+            ObjectGuid Officer;
+            bool Promote = false;
+            uint32 RankID = 0;
+        };
+
+        class GuildShiftRank final : public ClientPacket
+        {
+        public:
+            GuildShiftRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_SHIFT_RANK, std::move(packet)) { }
+
+            void Read() override;
+
+            bool ShiftUp = false;
+            int32 RankOrder = 0;
+        };
+
+        class GuildUpdateInfoText final : public ClientPacket
+        {
+        public:
+            GuildUpdateInfoText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_UPDATE_INFO_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string InfoText;
+        };
+
+        class GuildSetMemberNote final : public ClientPacket
+        {
+        public:
+            GuildSetMemberNote(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_SET_MEMBER_NOTE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid NoteeGUID;
+            bool IsPublic = false;          ///< 0 == Officer, 1 == Public
+            std::string Note;
+        };
+
+        class GuildMemberUpdateNote final : public ServerPacket
+        {
+        public:
+            GuildMemberUpdateNote() : ServerPacket(SMSG_GUILD_MEMBER_UPDATE_NOTE, 21) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Member;
+            bool IsPublic = false;          ///< 0 == Officer, 1 == Public
+            std::string Note;
+        };
+
+        class GuildMemberDailyReset final : public ServerPacket
+        {
+        public:
+            GuildMemberDailyReset() : ServerPacket(SMSG_GUILD_MEMBER_DAILY_RESET, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class GuildDelete final : public ClientPacket
+        {
+        public:
+            GuildDelete(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DELETE, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildDemoteMember final : public ClientPacket
+        {
+        public:
+            GuildDemoteMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DEMOTE_MEMBER, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Demotee;
+        };
+
+        class GuildPromoteMember final : public ClientPacket
+        {
+        public:
+            GuildPromoteMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_PROMOTE_MEMBER, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Promotee;
+        };
+
+        class GuildOfficerRemoveMember : public ClientPacket
+        {
+        public:
+            GuildOfficerRemoveMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_OFFICER_REMOVE_MEMBER, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Removee;
+        };
+
+        class GuildLeave final : public ClientPacket
+        {
+        public:
+            GuildLeave(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_LEAVE, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildChangeNameRequest final : public ClientPacket
+        {
+        public:
+            GuildChangeNameRequest(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_CHANGE_NAME_REQUEST, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string NewName;
+        };
+
+        class GuildFlaggedForRename final : public ServerPacket
+        {
+        public:
+            GuildFlaggedForRename() : ServerPacket(SMSG_GUILD_FLAGGED_FOR_RENAME, 1) { }
+
+            WorldPacket const* Write() override;
+
+            bool FlagSet = false;
+        };
+
+        class RequestGuildPartyState final : public ClientPacket
+        {
+        public:
+            RequestGuildPartyState(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_REQUEST_PARTY_STATE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid GuildGUID;
+        };
+
+        class GuildPartyState final : public ServerPacket
+        {
+        public:
+            GuildPartyState() : ServerPacket(SMSG_GUILD_PARTY_STATE_RESPONSE, 15) { }
+
+            WorldPacket const* Write() override;
+
+            float GuildXPEarnedMult = 0.0f;
+            int32 NumMembers = 0;
+            int32 NumRequired = 0;
+            bool InGuildParty = false;
+        };
+
+        class RequestGuildRewardsList final : public ClientPacket
+        {
+        public:
+            RequestGuildRewardsList(WorldPacket&& packet) : ClientPacket(CMSG_REQUEST_GUILD_REWARDS_LIST, std::move(packet)) { }
+
+            void Read() override;
+
+            uint32 CurrentVersion = 0;
+        };
+
+        struct GuildRewardItem
+        {
+            uint32 ItemID = 0;
+            std::vector<uint32> AchievementsRequired;
+            uint32 RaceMask = 0;
+            int32 MinGuildLevel = 0;
+            int32 MinGuildRep = 0;
+            uint64 Cost = 0;
+        };
+
+        class GuildRewardList final : public ServerPacket
+        {
+        public:
+            GuildRewardList() : ServerPacket(SMSG_GUILD_REWARDS_LIST, 8) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildRewardItem> RewardItems;
+            uint32 Version = 0;
+        };
+
+        class GuildBankActivate final : public ClientPacket
+        {
+        public:
+            GuildBankActivate(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_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;
+            std::string Name;
+            std::string Icon;
+        };
+
+        class GuildBankDepositMoney final : public ClientPacket
+        {
+        public:
+            GuildBankDepositMoney(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_DEPOSIT_MONEY, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Banker;
+            uint64 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(CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildBankRemainingWithdrawMoney final : public ServerPacket
+        {
+        public:
+            GuildBankRemainingWithdrawMoney() : ServerPacket(SMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY, 8) { }
+
+            WorldPacket const* Write() override;
+
+            int64 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;
+            uint64 Money = 0;
+        };
+
+        struct GuildBankItemInfo
+        {
+            struct GuildBankSocketEnchant
+            {
+                int32 SocketIndex = 0;
+                int32 SocketEnchantID = 0;
+            };
+
+            WorldPackets::Item::ItemInstance Item;
+            int32 Slot = 0;
+            int32 Count = 0;
+            int32 EnchantmentID = 0;
+            int32 Charges = 0;
+            int32 OnUseEnchantmentID = 0;
+            int32 Flags = 0;
+            bool Locked = false;
+            std::vector<GuildBankSocketEnchant> SocketEnchant;
+        };
+
+        struct GuildBankTabInfo
+        {
+            int32 TabIndex = 0;
+            std::string Name;
+            std::string Icon;
+        };
+
+        class GuildBankQueryResults final : public ServerPacket
+        {
+        public:
+            GuildBankQueryResults() : ServerPacket(SMSG_GUILD_BANK_QUERY_RESULTS, 25) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildBankItemInfo> ItemInfo;
+            std::vector<GuildBankTabInfo> TabInfo;
+            int32 WithdrawalsRemaining = 0;
+            int32 Tab = 0;
+            uint64 Money = 0;
+            bool FullUpdate = false;
+        };
+
+        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(CMSG_GUILD_BANK_LOG_QUERY, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 Tab = 0;
+        };
+
+        struct GuildBankLogEntry
+        {
+            ObjectGuid PlayerGUID;
+            uint32 TimeOffset = 0;
+            int8 EntryType = 0;
+            Optional<uint64> Money;
+            Optional<int32> ItemID;
+            Optional<int32> Count;
+            Optional<int8> OtherTab;
+        };
+
+        class GuildBankLogQueryResults final : public ServerPacket
+        {
+        public:
+            GuildBankLogQueryResults() : ServerPacket(SMSG_GUILD_BANK_LOG_QUERY_RESULT, 25) { }
+
+            WorldPacket const* Write() override;
+
+            int32 Tab = 0;
+            std::vector<GuildBankLogEntry> Entry;
+            Optional<uint64> WeeklyBonusMoney;
+        };
+
+        class GuildBankTextQuery final : public ClientPacket
+        {
+        public:
+            GuildBankTextQuery(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_TEXT_QUERY, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 Tab = 0;
+        };
+
+        class GuildBankTextQueryResult : public ServerPacket
+        {
+        public:
+            GuildBankTextQueryResult() : ServerPacket(SMSG_GUILD_BANK_TEXT_QUERY_RESULT, 5) { }
+
+            WorldPacket const* Write() override;
+
+            int32 Tab = 0;
+            std::string Text;
+        };
+
+        class GuildBankSetTabText final : public ClientPacket
+        {
+        public:
+            GuildBankSetTabText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_SET_TAB_TEXT, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 Tab = 0;
+            std::string TabText;
+        };
+
+        class GuildQueryNews final : public ClientPacket
+        {
+        public:
+            GuildQueryNews(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_QUERY_NEWS, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid GuildGUID;
+        };
+
+        struct GuildNewsEvent
+        {
+            int32 Id = 0;
+            uint32 CompletedDate = 0;
+            int32 Type = 0;
+            int32 Flags = 0;
+            int32 Data[2];
+            ObjectGuid MemberGuid;
+            GuidList MemberList;
+            Optional<Item::ItemInstance> Item;
+        };
+
+        class GuildNews final : public ServerPacket
+        {
+        public:
+            GuildNews() : ServerPacket(SMSG_GUILD_NEWS, 25) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<GuildNewsEvent> NewsEvents;
+        };
+
+        class GuildNewsUpdateSticky final : public ClientPacket
+        {
+        public:
+            GuildNewsUpdateSticky(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_NEWS_UPDATE_STICKY, std::move(packet)) { }
+
+            void Read() override;
+
+            int32 NewsID = 0;
+            ObjectGuid GuildGUID;
+            bool Sticky = false;
+        };
+
+        class GuildSetGuildMaster final : public ClientPacket
+        {
+        public:
+            GuildSetGuildMaster(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_SET_GUILD_MASTER, std::move(packet)) { }
+
+            void Read() override;
+
+            std::string NewMasterName;
+        };
+
+        class GuildChallengeUpdateRequest final : public ClientPacket
+        {
+        public:
+            GuildChallengeUpdateRequest(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_CHALLENGE_UPDATE_REQUEST, std::move(packet)) { }
+
+            void Read() override { }
+        };
+
+        class GuildChallengeUpdate final : public ServerPacket
+        {
+        public:
+            GuildChallengeUpdate() : ServerPacket(SMSG_GUILD_CHALLENGE_UPDATE, 120) { }
+
+            WorldPacket const* Write() override;
+
+            int32 CurrentCount[GUILD_CHALLENGES_TYPES];
+            int32 MaxCount[GUILD_CHALLENGES_TYPES];
+            int32 Gold[GUILD_CHALLENGES_TYPES];
+            int32 MaxLevelGold[GUILD_CHALLENGES_TYPES];
+        };
+
+        class SaveGuildEmblem final : public ClientPacket
+        {
+        public:
+            SaveGuildEmblem(WorldPacket&& packet) : ClientPacket(CMSG_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(SMSG_SAVE_GUILD_EMBLEM, 4) { }
+
+            WorldPacket const* Write() override;
+
+            int32 Error = 0;
+        };
     }
 }
 
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterProfessionData const& rosterProfessionData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRewardItem const& rewardItem);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildNewsEvent const& newsEvent);
+
 #endif // GuildPackets_h__
diff --git a/src/server/game/Server/Packets/MailPackets.h b/src/server/game/Server/Packets/MailPackets.h
index 8019c274191..281a48b7248 100644
--- a/src/server/game/Server/Packets/MailPackets.h
+++ b/src/server/game/Server/Packets/MailPackets.h
@@ -38,7 +38,7 @@ namespace WorldPackets
 
         struct MailAttachedItem
         {
-            MailAttachedItem(::Item const* item, uint8 pos); 
+            MailAttachedItem(::Item const* item, uint8 pos);
 
             uint8 Position = 0;
             int32 AttachID = 0;
@@ -126,7 +126,7 @@ namespace WorldPackets
                 std::string Body;
                 std::vector<MailAttachment> Attachments;
             };
-            
+
             SendMail(WorldPacket&& packet) : ClientPacket(CMSG_SEND_MAIL, std::move(packet)) { }
 
             void Read() override;
diff --git a/src/server/game/Server/Packets/MiscPackets.h b/src/server/game/Server/Packets/MiscPackets.h
index 53fd7ce8796..9dd39e4c3d9 100644
--- a/src/server/game/Server/Packets/MiscPackets.h
+++ b/src/server/game/Server/Packets/MiscPackets.h
@@ -53,7 +53,7 @@ namespace WorldPackets
             ObjectGuid BinderID;
             uint32 AreaID = 0;
         };
-        
+
         class BinderConfirm final : public ServerPacket
         {
         public:
diff --git a/src/server/game/Server/Packets/NPCPackets.cpp b/src/server/game/Server/Packets/NPCPackets.cpp
index 1b1ef3ce613..4dc3d66a852 100644
--- a/src/server/game/Server/Packets/NPCPackets.cpp
+++ b/src/server/game/Server/Packets/NPCPackets.cpp
@@ -135,3 +135,9 @@ void WorldPackets::NPC::GossipSelectOption::Read()
     uint32 length = _worldPacket.ReadBits(8);
     PromotionCode = _worldPacket.ReadString(length);
 }
+WorldPacket const* WorldPackets::NPC::PlayerTabardVendorActivate::Write()
+{
+    _worldPacket << Vendor;
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/NPCPackets.h b/src/server/game/Server/Packets/NPCPackets.h
index 50c174539b5..bce5dbbd074 100644
--- a/src/server/game/Server/Packets/NPCPackets.h
+++ b/src/server/game/Server/Packets/NPCPackets.h
@@ -158,6 +158,16 @@ namespace WorldPackets
 
             ObjectGuid Guid;
         };
+
+        class PlayerTabardVendorActivate final : public ServerPacket
+        {
+        public:
+            PlayerTabardVendorActivate() : ServerPacket(SMSG_TABARD_VENDOR_ACTIVATE, 16) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Vendor;
+        };
     }
 }
 
diff --git a/src/server/game/Server/Packets/PetitionPackets.cpp b/src/server/game/Server/Packets/PetitionPackets.cpp
new file mode 100644
index 00000000000..936dea3d3a4
--- /dev/null
+++ b/src/server/game/Server/Packets/PetitionPackets.cpp
@@ -0,0 +1,192 @@
+/*
+* 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 "PetitionPackets.h"
+
+void WorldPackets::Petition::QueryPetition::Read()
+{
+    _worldPacket >> PetitionID;
+    _worldPacket >> ItemGUID;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Petition::PetitionInfo const& petitionInfo)
+{
+    data << petitionInfo.PetitionID;
+    data << petitionInfo.Petitioner;
+
+    data << petitionInfo.MinSignatures;
+    data << petitionInfo.MaxSignatures;
+    data << petitionInfo.DeadLine;
+    data << petitionInfo.IssueDate;
+    data << petitionInfo.AllowedGuildID;
+    data << petitionInfo.AllowedClasses;
+    data << petitionInfo.AllowedRaces;
+    data << petitionInfo.AllowedGender;
+    data << petitionInfo.AllowedMinLevel;
+    data << petitionInfo.AllowedMaxLevel;
+    data << petitionInfo.NumChoices;
+    data << petitionInfo.StaticType;
+    data << petitionInfo.Muid;
+
+    data.WriteBits(petitionInfo.Title.length(), 7);
+    data.WriteBits(petitionInfo.BodyText.length(), 12);
+
+    for (uint8 i = 0; i < 10; i++)
+        data.WriteBits(petitionInfo.Choicetext[i].length(), 6);
+
+    data.FlushBits();
+
+    for (uint8 i = 0; i < 10; i++)
+        data.WriteString(petitionInfo.Choicetext[i]);
+
+    data.WriteString(petitionInfo.Title);
+    data.WriteString(petitionInfo.BodyText);
+
+    return data;
+}
+
+WorldPacket const* WorldPackets::Petition::QueryPetitionResponse::Write()
+{
+    _worldPacket << PetitionID;
+    _worldPacket.WriteBit(Allow);
+    _worldPacket.FlushBits();
+
+    if (Allow)
+        _worldPacket << Info;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Petition::PetitionShowList::Read()
+{
+    _worldPacket >> PetitionUnit;
+}
+
+WorldPacket const* WorldPackets::Petition::ServerPetitionShowList::Write()
+{
+    _worldPacket << Unit;
+    _worldPacket << Price;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Petition::PetitionBuy::Read()
+{
+    uint32 titleLen = _worldPacket.ReadBits(7);
+
+    _worldPacket >> Unit;
+    Title = _worldPacket.ReadString(titleLen);
+}
+
+void WorldPackets::Petition::PetitionShowSignatures::Read()
+{
+    _worldPacket >> Item;
+}
+
+WorldPacket const* WorldPackets::Petition::ServerPetitionShowSignatures::Write()
+{
+    _worldPacket << Item;
+    _worldPacket << Owner;
+    _worldPacket << OwnerAccountID;
+    _worldPacket << PetitionID;
+
+    _worldPacket << uint32(Signatures.size());
+    for (PetitionSignature signature : Signatures)
+    {
+        _worldPacket << signature.Signer;
+        _worldPacket << signature.Choice;
+    }
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Petition::SignPetition::Read()
+{
+    _worldPacket >> PetitionGUID;
+    _worldPacket >> Choice;
+}
+
+WorldPacket const* WorldPackets::Petition::PetitionSignResults::Write()
+{
+    _worldPacket << Item;
+    _worldPacket << Player;
+
+    _worldPacket.WriteBits(Error, 4);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Petition::PetitionAlreadySigned::Write()
+{
+    _worldPacket << SignerGUID;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Petition::DeclinePetition::Read()
+{
+    _worldPacket >> PetitionGUID;
+}
+
+void WorldPackets::Petition::TurnInPetition::Read()
+{
+    _worldPacket >> Item;
+}
+
+WorldPacket const* WorldPackets::Petition::TurnInPetitionResult::Write()
+{
+    _worldPacket.WriteBits(Result, 4);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Petition::OfferPetition::Read()
+{
+    _worldPacket >> ItemGUID;
+    _worldPacket >> TargetPlayer;
+}
+
+WorldPacket const* WorldPackets::Petition::OfferPetitionError::Write()
+{
+    _worldPacket << PlayerGUID;
+
+    return &_worldPacket;
+}
+
+void WorldPackets::Petition::PetitionRenameGuild::Read()
+{
+    _worldPacket >> PetitionGuid;
+
+    _worldPacket.ResetBitPos();
+    uint32 nameLen = _worldPacket.ReadBits(7);
+
+    NewGuildName = _worldPacket.ReadString(nameLen);
+}
+
+WorldPacket const* WorldPackets::Petition::PetitionRenameGuildResponse::Write()
+{
+    _worldPacket << PetitionGuid;
+
+    _worldPacket.WriteBits(NewGuildName.length(), 7);
+    _worldPacket.FlushBits();
+
+    _worldPacket.WriteString(NewGuildName);
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/PetitionPackets.h b/src/server/game/Server/Packets/PetitionPackets.h
new file mode 100644
index 00000000000..fe136508547
--- /dev/null
+++ b/src/server/game/Server/Packets/PetitionPackets.h
@@ -0,0 +1,246 @@
+/*
+* 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 PetitionPackets_h__
+#define PetitionPackets_h__
+
+#include "Packet.h"
+#include "ObjectGuid.h"
+#include "WorldSession.h"
+
+namespace WorldPackets
+{
+    namespace Petition
+    {
+        class QueryPetition final : public ClientPacket
+        {
+        public:
+            QueryPetition(WorldPacket&& packet) : ClientPacket(CMSG_QUERY_PETITION, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid ItemGUID;
+            uint32 PetitionID = 0;
+        };
+
+        struct PetitionInfo
+        {
+            int32 PetitionID = 0;
+            ObjectGuid Petitioner;
+            std::string Title;
+            std::string BodyText;
+            int32 MinSignatures = 0;
+            int32 MaxSignatures = 0;
+            int32 DeadLine = 0;
+            int32 IssueDate = 0;
+            int32 AllowedGuildID = 0;
+            int32 AllowedClasses = 0;
+            int32 AllowedRaces = 0;
+            int16 AllowedGender = 0;
+            int32 AllowedMinLevel = 0;
+            int32 AllowedMaxLevel = 0;
+            int32 NumChoices = 0;
+            int32 StaticType = 0;
+            uint32 Muid = 0;
+            std::string Choicetext[10];
+        };
+
+        class QueryPetitionResponse final : public ServerPacket
+        {
+        public:
+            QueryPetitionResponse() : ServerPacket(SMSG_QUERY_PETITION_RESPONSE, 75) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 PetitionID = 0;
+            bool Allow = false;
+            PetitionInfo Info;
+        };
+
+        class PetitionShowList final : public ClientPacket
+        {
+        public:
+            PetitionShowList(WorldPacket&& packet) : ClientPacket(CMSG_PETITION_SHOW_LIST, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid PetitionUnit;
+        };
+
+        class ServerPetitionShowList final : public ServerPacket
+        {
+        public:
+            ServerPetitionShowList() : ServerPacket(SMSG_PETITION_SHOW_LIST, 20) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Unit;
+            uint32 Price = 0;
+        };
+
+        class PetitionBuy final : public ClientPacket
+        {
+        public:
+            PetitionBuy(WorldPacket&& packet) : ClientPacket(CMSG_PETITION_BUY, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Unit;
+            std::string Title;
+        };
+
+        class PetitionShowSignatures final : public ClientPacket
+        {
+        public:
+            PetitionShowSignatures(WorldPacket&& packet) : ClientPacket(CMSG_PETITION_SHOW_SIGNATURES, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Item;
+        };
+
+        class ServerPetitionShowSignatures final : public ServerPacket
+        {
+        public:
+            struct PetitionSignature
+            {
+                ObjectGuid Signer;
+                int32 Choice = 0;
+            };
+
+            ServerPetitionShowSignatures() : ServerPacket(SMSG_PETITION_SHOW_SIGNATURES, 40) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Item;
+            ObjectGuid Owner;
+            ObjectGuid OwnerAccountID;
+            int32 PetitionID = 0;
+            std::vector<PetitionSignature> Signatures;
+        };
+
+        class SignPetition final : public ClientPacket
+        {
+        public:
+            SignPetition(WorldPacket&& packet) : ClientPacket(CMSG_SIGN_PETITION, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid PetitionGUID;
+            uint8 Choice = 0;
+        };
+
+        class PetitionSignResults final : public ServerPacket
+        {
+        public:
+            PetitionSignResults() : ServerPacket(SMSG_PETITION_SIGN_RESULTS, 33) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Item;
+            ObjectGuid Player;
+            int32 Error = 0; // PetitionError
+        };
+
+        class PetitionAlreadySigned final : public ServerPacket
+        {
+        public:
+            PetitionAlreadySigned() : ServerPacket(SMSG_PETITION_ALREADY_SIGNED, 16) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid SignerGUID;
+        };
+
+        class DeclinePetition final : public ClientPacket
+        {
+        public:
+            DeclinePetition(WorldPacket&& packet) : ClientPacket(CMSG_DECLINE_PETITION, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid PetitionGUID;
+        };
+
+        class TurnInPetition final : public ClientPacket
+        {
+        public:
+            TurnInPetition(WorldPacket&& packet) : ClientPacket(CMSG_TURN_IN_PETITION, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Item;
+        };
+
+        class TurnInPetitionResult final : public ServerPacket
+        {
+        public:
+            TurnInPetitionResult() : ServerPacket(SMSG_TURN_IN_PETITION_RESULTS, 4) { }
+
+            WorldPacket const* Write() override;
+
+            int32 Result = 0; // PetitionError
+        };
+
+        class OfferPetition final : public ClientPacket
+        {
+        public:
+            OfferPetition(WorldPacket&& packet) : ClientPacket(CMSG_OFFER_PETITION, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid TargetPlayer;
+            ObjectGuid ItemGUID;
+        };
+
+        class OfferPetitionError final : public ServerPacket
+        {
+        public:
+            OfferPetitionError() : ServerPacket(SMSG_OFFER_PETITION_ERROR, 16) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid PlayerGUID;
+        };
+
+        class PetitionRenameGuild final : public ClientPacket
+        {
+        public:
+            PetitionRenameGuild(WorldPacket&& packet) : ClientPacket(CMSG_PETITION_RENAME_GUILD, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid PetitionGuid;
+            std::string NewGuildName;
+        };
+
+        class PetitionRenameGuildResponse final : public ServerPacket
+        {
+        public:
+            PetitionRenameGuildResponse() : ServerPacket(SMSG_PETITION_RENAME_GUILD_RESPONSE, 20) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid PetitionGuid;
+            std::string NewGuildName;
+        };
+    }
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Petition::PetitionInfo const& petitionInfo);
+
+#endif // PetitionPackets_h__
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index e29624e90e6..b2c31859d39 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -37,6 +37,7 @@
 #include "Packets/MiscPackets.h"
 #include "Packets/MovementPackets.h"
 #include "Packets/NPCPackets.h"
+#include "Packets/PetitionPackets.h"
 #include "Packets/QueryPackets.h"
 #include "Packets/QuestPackets.h"
 #include "Packets/SocialPackets.h"
@@ -141,7 +142,7 @@ void OpcodeTable::Initialize()
 #define DEFINE_HANDLER(opcode, status, processing, packetclass, handler) \
     ValidateAndSetClientOpcode<packetclass, handler>(opcode, #opcode, status, processing);
 
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_ACCEPT_GUILD_INVITE,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
+    DEFINE_HANDLER(CMSG_ACCEPT_GUILD_INVITE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::AcceptGuildInvite, &WorldSession::HandleGuildAcceptInvite);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_ACCEPT_LEVEL_GRANT,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleAcceptGrantLevel          );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_ACCEPT_TRADE,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleAcceptTradeOpcode         );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_ACCEPT_WARGAME_INVITE,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -185,7 +186,6 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_AUTOSTORE_BANK_ITEM,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleAutoStoreBankItemOpcode   );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_AUTOSTORE_GROUND_ITEM,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_HANDLER(CMSG_AUTOSTORE_LOOT_ITEM,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Loot::AutoStoreLootItem, &WorldSession::HandleAutostoreLootItemOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_AUTO_DECLINE_GUILD_INVITES,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleAutoDeclineGuildInvites   );
     DEFINE_HANDLER(CMSG_BANKER_ACTIVATE,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleBankerActivateOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_BATTLEFIELD_JOIN,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_BATTLEFIELD_LEAVE,                       STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleBattlefieldLeaveOpcode    );
@@ -325,8 +325,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CREATURE_QUERY,                                     STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Query::QueryCreature, &WorldSession::HandleCreatureQuery);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_DANCE_QUERY,                             STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_HANDLER(CMSG_DB_QUERY_BULK,                                      STATUS_AUTHED,    PROCESS_INPLACE,      WorldPackets::Query::DBQueryBulk, &WorldSession::HandleDBQueryBulk);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_DECLINE_GUILD_INVITES,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_DECLINE_PETITION,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionDeclineOpcode     );
+    DEFINE_HANDLER(CMSG_DECLINE_GUILD_INVITES,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::DeclineGuildInvites, &WorldSession::HandleDeclineGuildInvites);
+    DEFINE_HANDLER(CMSG_DECLINE_PETITION,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::DeclinePetition, &WorldSession::HandleDeclinePetition);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_DELETE_EQUIPMENT_SET,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleEquipmentSetDelete        );
     DEFINE_HANDLER(CMSG_DEL_FRIEND,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Social::DelFriend, &WorldSession::HandleDelFriendOpcode);
     DEFINE_HANDLER(CMSG_DEL_IGNORE,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Social::DelIgnore, &WorldSession::HandleDelIgnoreOpcode);
@@ -408,60 +408,52 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GROUP_SET_LEADER,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupSetLeaderOpcode      );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GROUP_SET_ROLES,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGroupSetRolesOpcode       );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GROUP_SWAP_SUB_GROUP,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupSwapSubGroupOpcode   );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_ACCEPT,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildAcceptOpcode         );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_ADD_BATTLENET_FRIEND,              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_ADD_RANK,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildAddRankOpcode        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_ASSIGN_MEMBER_RANK,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildAssignRankOpcode     );
+    DEFINE_HANDLER(CMSG_GUILD_ADD_RANK,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildAddRank, &WorldSession::HandleGuildAddRank);
+    DEFINE_HANDLER(CMSG_GUILD_ASSIGN_MEMBER_RANK,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildAssignMemberRank, &WorldSession::HandleGuildAssignRank);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_AUTO_DECLINE_INVITATION,           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANKER_ACTIVATE,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankerActivate       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_BUY_TAB,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankBuyTab           );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_DEPOSIT_MONEY,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankDepositMoney     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_LOG_QUERY,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankLogQuery         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_MONEY_WITHDRAWN_QUERY,        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankMoneyWithdrawn   );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_NOTE,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_QUERY_TAB,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankQueryTab         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_QUERY_TEXT,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleQueryGuildBankTabText     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY, STATUS_UNHANDLED, PROCESS_INPLACE,    &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_SET_TAB_TEXT,                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_SWAP_ITEMS,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankSwapItems        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_UPDATE_TAB,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankUpdateTab        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_BANK_WITHDRAW_MONEY,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankWithdrawMoney    );
+    DEFINE_HANDLER(CMSG_GUILD_BANK_ACTIVATE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankActivate, &WorldSession::HandleGuildBankActivate);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_BUY_TAB,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankBuyTab, &WorldSession::HandleGuildBankBuyTab);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_DEPOSIT_MONEY,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankDepositMoney, &WorldSession::HandleGuildBankDepositMoney);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_LOG_QUERY,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankLogQuery, &WorldSession::HandleGuildBankLogQuery);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_QUERY_TAB,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankQueryTab, &WorldSession::HandleGuildBankQueryTab);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY,          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankRemainingWithdrawMoneyQuery, &WorldSession::HandleGuildBankMoneyWithdrawn);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_SET_TAB_TEXT,                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankSetTabText, &WorldSession::HandleGuildBankSetTabText);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_SWAP_ITEMS,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankSwapItems, &WorldSession::HandleGuildBankSwapItems);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_TEXT_QUERY,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankTextQuery, &WorldSession::HandleGuildBankTextQuery);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_UPDATE_TAB,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankUpdateTab, &WorldSession::HandleGuildBankUpdateTab);
+    DEFINE_HANDLER(CMSG_GUILD_BANK_WITHDRAW_MONEY,                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildBankWithdrawMoney, &WorldSession::HandleGuildBankWithdrawMoney);
+    DEFINE_HANDLER(CMSG_GUILD_CHALLENGE_UPDATE_REQUEST,                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildChallengeUpdateRequest, &WorldSession::HandleGuildChallengeUpdateRequest);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_CHANGE_NAME_REQUEST,               STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_DECLINE,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildDeclineOpcode        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_DELETE,                            STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_DELETE_RANK,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildDeleteRankOpcode     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_DEMOTE,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildDemoteOpcode         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_DISBAND,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildDisbandOpcode        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_EVENT_LOG_QUERY,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildEventLogQueryOpcode  );
+    DEFINE_HANDLER(CMSG_GUILD_DECLINE_INVITATION,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildDeclineInvitation, &WorldSession::HandleGuildDeclineInvitation);
+    DEFINE_HANDLER(CMSG_GUILD_DELETE_RANK,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildDeleteRank, &WorldSession::HandleGuildDeleteRank);
+    DEFINE_HANDLER(CMSG_GUILD_DEMOTE_MEMBER,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildDemoteMember, &WorldSession::HandleGuildDemoteMember);
+    DEFINE_HANDLER(CMSG_GUILD_DELETE,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildDelete, &WorldSession::HandleGuildDelete);
+    DEFINE_HANDLER(CMSG_GUILD_EVENT_LOG_QUERY,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildEventLogQuery, &WorldSession::HandleGuildEventLogQuery);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_GET_ACHIEVEMENT_MEMBERS,           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_GET_RANKS,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildGetRanksOpcode       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_GET_ROSTER,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildRosterOpcode         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_INVITE_BY_NAME,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildInviteOpcode         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_LEAVE,                             STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildLeaveOpcode          );
+    DEFINE_HANDLER(CMSG_GUILD_GET_RANKS,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildGetRanks, &WorldSession::HandleGuildGetRanks);
+    DEFINE_HANDLER(CMSG_GUILD_GET_ROSTER,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildGetRoster, &WorldSession::HandleGuildGetRoster);
+    DEFINE_HANDLER(CMSG_GUILD_INVITE_BY_NAME,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildInviteByName, &WorldSession::HandleGuildInviteByName);
+    DEFINE_HANDLER(CMSG_GUILD_LEAVE,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildLeave, &WorldSession::HandleGuildLeave);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_MEMBER_SEND_SOR_REQUEST,           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_NEWS_UPDATE_STICKY,                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGuildNewsUpdateStickyOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_OFFICER_REMOVE_MEMBER,             STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildOfficerRemoveMemberOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_PERMISSIONS_QUERY,                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildPermissions          );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_PROMOTE_MEMBER,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildPromoteOpcode        );
+    DEFINE_HANDLER(CMSG_GUILD_NEWS_UPDATE_STICKY,                           STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Guild::GuildNewsUpdateSticky, &WorldSession::HandleGuildNewsUpdateSticky);
+    DEFINE_HANDLER(CMSG_GUILD_OFFICER_REMOVE_MEMBER,                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildOfficerRemoveMember, &WorldSession::HandleGuildOfficerRemoveMember);
+    DEFINE_HANDLER(CMSG_GUILD_PERMISSIONS_QUERY,                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildPermissionsQuery, &WorldSession::HandleGuildPermissionsQuery);
+    DEFINE_HANDLER(CMSG_GUILD_PROMOTE_MEMBER,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildPromoteMember, &WorldSession::HandleGuildPromoteMember);
     DEFINE_HANDLER(CMSG_GUILD_QUERY,                                        STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::Guild::QueryGuildInfo, &WorldSession::HandleGuildQueryOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_QUERY_MEMBERS_FOR_RECIPE,          STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_QUERY_MEMBER_RECIPES,              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_QUERY_NEWS,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleGuildQueryNewsOpcode      );
+    DEFINE_HANDLER(CMSG_GUILD_QUERY_NEWS,                                   STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Guild::GuildQueryNews, &WorldSession::HandleGuildQueryNews);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_QUERY_RECIPES,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_REPLACE_GUILD_MASTER,              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_REQUEST_CHALLENGE_INFO,            STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_REQUEST_CHALLENGE_UPDATE,          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildRequestChallengeUpdate);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_REQUEST_MAX_DAILY_XP,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildRequestMaxDailyXP    );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_REQUEST_PARTY_STATE,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildRequestPartyState    );
+    DEFINE_HANDLER(CMSG_GUILD_REQUEST_PARTY_STATE,                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::RequestGuildPartyState, &WorldSession::HandleGuildRequestPartyState);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_SET_ACHIEVEMENT_TRACKING,          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildSetAchievementTracking);
-    DEFINE_HANDLER(CMSG_GUILD_SET_FOCUSED_ACHIEVEMENT,                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Achievement::GuildSetFocusedAchievement, &WorldSession::HandleGuildSetFocusedAchievement);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_SET_GUILD_MASTER,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildSetGuildMaster       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_SET_MEMBER_NOTE,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_SET_NOTE,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildSetNoteOpcode        );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_SET_RANK_PERMISSIONS,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildSetRankPermissionsOpcode);
+    DEFINE_HANDLER(CMSG_GUILD_SET_GUILD_MASTER,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildSetGuildMaster, &WorldSession::HandleGuildSetGuildMaster);
+    DEFINE_HANDLER(CMSG_GUILD_SET_MEMBER_NOTE,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildSetMemberNote, &WorldSession::HandleGuildSetMemberNote);
+    DEFINE_HANDLER(CMSG_GUILD_SET_RANK_PERMISSIONS,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildSetRankPermissions, &WorldSession::HandleGuildSetRankPermissions);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_SHIFT_RANK,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_UPDATE_INFO_TEXT,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildChangeInfoTextOpcode );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_GUILD_UPDATE_MOTD_TEXT,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildMOTDOpcode           );
+    DEFINE_HANDLER(CMSG_GUILD_UPDATE_INFO_TEXT,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildUpdateInfoText, &WorldSession::HandleGuildUpdateInfoText);
+    DEFINE_HANDLER(CMSG_GUILD_UPDATE_MOTD_TEXT,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::GuildUpdateMotdText, &WorldSession::HandleGuildUpdateMotdText);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_HEARTH_AND_RESURRECT,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleHearthAndResurrect        );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_IGNORE_TRADE,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleIgnoreTradeOpcode         );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_INCREASE_CAST_TIME_FOR_SPELL,            STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -507,9 +499,8 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_BROWSE,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderBrowse         );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_DECLINE_RECRUIT,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderDeclineRecruit );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_GET_APPLICATIONS,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderGetApplications);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_GET_GUILD_POST,                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
+    DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_GET_GUILD_POST,                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderPostRequest    );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_GET_RECRUITS,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderGetRecruits    );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_POST_REQUEST,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderPostRequest    );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_REMOVE_RECRUIT,                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderRemoveRecruit  );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_LF_GUILD_SET_GUILD_POST,                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildFinderSetGuildPost   );
     DEFINE_HANDLER(CMSG_LIST_INVENTORY,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleListInventoryOpcode);
@@ -635,7 +626,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_NPC_TEXT_QUERY,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Query::QueryNPCText, &WorldSession::HandleNpcTextQueryOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_OBJECT_UPDATE_FAILED,                    STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleObjectUpdateFailedOpcode  );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_OBJECT_UPDATE_RESCUED,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_OFFER_PETITION,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleOfferPetitionOpcode       );
+    DEFINE_HANDLER(CMSG_OFFER_PETITION,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::OfferPetition, &WorldSession::HandleOfferPetition);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_OPENING_CINEMATIC,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleOpeningCinematic          );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_OPEN_GARRISON_MISSION_NPC,               STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_OPEN_ITEM,                               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleOpenItemOpcode            );
@@ -648,12 +639,10 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_SILENCE,                           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_UNINVITE,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGroupUninviteOpcode       );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_PARTY_UNSILENCE,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PETITION_BUY,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionBuyOpcode         );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PETITION_QUERY,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionQueryOpcode       );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PETITION_RENAME_GUILD,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionRenameGuildOpcode );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PETITION_SHOW_LIST,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionShowListOpcode    );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PETITION_SHOW_SIGNATURES,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionShowSignOpcode    );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_PETITION_SIGN,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetitionSignOpcode        );
+    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);
+    DEFINE_HANDLER(CMSG_PETITION_SHOW_SIGNATURES,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::PetitionShowSignatures, &WorldSession::HandlePetitionShowSignatures);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_PET_ABANDON,                             STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetAbandon                );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_PET_ACTION,                              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandlePetAction                 );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_PET_BATTLE_FINAL_NOTIF,                  STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -686,10 +675,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_QUERY_CORPSE_LOCATION_FROM_CLIENT,                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Query::QueryCorpseLocationFromClient, &WorldSession::HandleQueryCorpseLocation);
     DEFINE_HANDLER(CMSG_QUERY_CORPSE_TRANSPORT,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Query::QueryCorpseTransport, &WorldSession::HandleQueryCorpseTransport);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_QUERY_COUNTDOWN_TIMER,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_QUERY_GUILD_XP,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildQueryXPOpcode        );
-    DEFINE_HANDLER(CMSG_QUERY_INSPECT_ACHIEVEMENTS,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Inspect::QueryInspectAchievements, &WorldSession::HandleQueryInspectAchievements);
-    DEFINE_HANDLER(CMSG_QUERY_NEXT_MAIL_TIME,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Mail::MailQueryNextMailTime, &WorldSession::HandleQueryNextMailTime);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_QUERY_PETITION,                          STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
+    DEFINE_HANDLER(CMSG_QUERY_PETITION,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::QueryPetition, &WorldSession::HandleQueryPetition);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_QUERY_SCENARIO_POI,                      STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_HANDLER(CMSG_QUERY_TIME,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Query::QueryTime, &WorldSession::HandleQueryTimeOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_QUESTGIVER_ACCEPT_QUEST,                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleQuestgiverAcceptQuestOpcode);
@@ -732,7 +718,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_REQUEST_CEMETERY_LIST,                              STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Misc::RequestCemeteryList, &WorldSession::HandleRequestCemeteryList);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_CONQUEST_FORMULA_CONSTANTS,      STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_FORCED_REACTIONS,                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_GUILD_REWARDS_LIST,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleGuildRewardsQueryOpcode   );
+    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_OPCODE_HANDLER_OLD(CMSG_REQUEST_LFG_LIST_BLACKLIST,              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_REQUEST_PARTY_JOIN_UPDATES,              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -758,7 +744,7 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_ROLE_POLL_BEGIN,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRolePollBeginOpcode       );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_ROUTER_CLIENT_LOG_STREAMING_ERROR,       STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SAVE_CUF_PROFILES,                       STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::HandleSaveCUFProfiles           );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SAVE_GUILD_EMBLEM,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSaveGuildEmblemOpcode     );
+    DEFINE_HANDLER(CMSG_SAVE_GUILD_EMBLEM,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Guild::SaveGuildEmblem, &WorldSession::HandleSaveGuildEmblem);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SAVE_PLAYER,                             STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SCENE_PLAYBACK_CANCELED,                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SCENE_PLAYBACK_COMPLETE,                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -789,7 +775,6 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_FACTION_CHEAT,                       STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_FACTION_INACTIVE,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetFactionInactiveOpcode  );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_FACTION_NOT_AT_WAR,                  STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_GUILD_BANK_TEXT,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetGuildBankTabText       );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT,          STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_LFG_BONUS_FACTION_ID,                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_LFG_COMMENT,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -819,7 +804,7 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SHOWING_CLOAK,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleShowingCloakOpcode        );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SHOWING_HELM,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleShowingHelmOpcode         );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SHOW_TRADE_SKILL,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_SIGN_PETITION,                           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
+    DEFINE_HANDLER(CMSG_SIGN_PETITION,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::SignPetition, &WorldSession::HandleSignPetition);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SILENCE_PARTY_TALKER,                    STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SOCKET_GEMS,                             STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSocketOpcode              );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SORT_BAGS,                               STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -847,7 +832,7 @@ void OpcodeTable::Initialize()
     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::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_SYNC_DANCE,                              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_TABARD_VENDOR_ACTIVATE,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleTabardVendorActivateOpcode);
+    DEFINE_HANDLER(CMSG_TABARD_VENDOR_ACTIVATE,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::NPC::Hello, &WorldSession::HandleTabardVendorActivateOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_TAXICLEARALLNODES,                       STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_TAXIENABLEALLNODES,                      STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_TAXISHOWNODES,                           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -868,7 +853,7 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_TRANSMOGRIFY_ITEMS,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleTransmogrifyItems         );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_TRIGGER_CINEMATIC_CHEAT,                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_TROPHY_MONUMENT_LOAD_SELECTED_TROPHY_ID, STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_TURN_IN_PETITION,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleTurnInPetitionOpcode      );
+    DEFINE_HANDLER(CMSG_TURN_IN_PETITION,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Petition::TurnInPetition, &WorldSession::HandleTurnInPetition);
     DEFINE_HANDLER(CMSG_TUTORIAL_FLAG,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::TutorialSetFlag, &WorldSession::HandleTutorialFlag);
     DEFINE_HANDLER(CMSG_UI_TIME_REQUEST,                                    STATUS_LOGGEDIN,  PROCESS_INPLACE,      WorldPackets::Misc::UITimeRequest, &WorldSession::HandleUITimeRequest);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_UNACCEPT_TRADE,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleUnacceptTradeOpcode       );
@@ -1300,69 +1285,58 @@ void OpcodeTable::Initialize()
     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);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_LIST,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_LOG_QUERY_RESULT,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_MONEY_WITHDRAWN,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_QUERY_TEXT_RESULT,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_LOG_QUERY_RESULT,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_QUERY_RESULTS,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY,     STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_BANK_TEXT_QUERY_RESULT,            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CANCEL,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHALLENGE_COMPLETED,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHALLENGE_UPDATED,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHALLENGE_UPDATE,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CHANGE_NAME_RESULT,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_COMMAND_RESULT,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_COMMAND_RESULT_2,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_COMMAND_RESULT,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CRITERIA_DELETED,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_CRITERIA_UPDATE,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_DECLINE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_BANK_CONTENTS_CHANGED,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_BANK_MONEY_CHANGED,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_DISBANDED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_LOG_QUERY_RESULTS,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_MOTD,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_NEW_LEADER,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_PLAYER_JOINED,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_PLAYER_LEFT,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_PRESENCE_CHANGE,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_RANKS_UPDATED,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_RANK_CHANGED,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_ADDED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_BANK_MONEY_CHANGED,          STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_DISBANDED,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_LOG_QUERY_RESULT,            STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_MOTD,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_NEW_LEADER,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_PLAYER_JOINED,               STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_PLAYER_LEFT,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_PRESENCE_CHANGE,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_RANK_CHANGED,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_RANKS_UPDATED,               STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_ADDED,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_DELETED,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_MODIFIED,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_TEXT_CHANGED,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_FLAGGED_FOR_RENAME,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_INVITE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_MODIFIED,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_EVENT_TAB_TEXT_CHANGED,            STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_FLAGGED_FOR_RENAME,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_INVITE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_INVITE_CANCEL,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_INVITE_DECLINED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_INVITE_EXPIRED,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_KNOWN_RECIPES,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MAX_DAILY_XP,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MEMBERS_WITH_RECIPE,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MEMBER_DAILY_RESET,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MEMBER_DAILY_RESET,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MEMBER_RECIPES,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MEMBER_UPDATE_NOTE,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MEMBER_UPDATE_NOTE,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MOVED,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MOVE_COMPLETE,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_MOVE_STARTING,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_NAME_CHANGED,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_NEWS,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_NEWS,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_NEWS_DELETED,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_NEWS_UPDATE,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_PARTY_STATE_RESPONSE,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_PERMISSIONS_QUERY_RESULTS,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_PARTY_STATE_RESPONSE,              STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_PERMISSIONS_QUERY_RESULTS,         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_QUERY_RESPONSE,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_RANKS,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_RANKS,                             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_SEND_RANK_CHANGE,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_REPUTATION_REACTION_CHANGED,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_REPUTATION_WEEKLY_CAP,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_RESET,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_REWARDS_LIST,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ROSTER,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ROSTER_UPDATE,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_REWARDS_LIST,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ROSTER,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_ROSTER_UPDATE,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_SEND_RANK_CHANGE,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_SET_NOTE,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_TRADESKILL_UPDATE,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_XP,                                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_XP_GAIN,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GUILD_XP_UPDATE,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_HEALTH_UPDATE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_HIGHEST_THREAT_UPDATE,                   STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_HOTFIX_NOTIFY,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1616,10 +1590,9 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PERIODICAURALOG,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETGODMODE,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_ALREADY_SIGNED,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_DECLINED,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_RENAME_GUILD_RESPONSE,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_SHOW_LIST,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_SHOW_SIGNATURES,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_RENAME_GUILD_RESPONSE,          STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_SHOW_LIST,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_SHOW_SIGNATURES,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PETITION_SIGN_RESULTS,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_ACTION_FEEDBACK,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_ACTION_SOUND,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1683,8 +1656,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_LOG_DATA,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_OPTIONS_ENABLED,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_SEASON,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_BATTLE_PET_NAME_RESPONSE,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_PETITION_RESPONSE,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_PETITION_RESPONSE,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_TIME_RESPONSE,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUESTGIVER_INVALID_QUEST,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUESTGIVER_OFFER_REWARD,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1761,7 +1733,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_BEGIN,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_INFORM,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RUNE_REGEN_DEBUG,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SAVE_GUILD_EMBLEM,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SAVE_GUILD_EMBLEM,                       STATUS_NEVER,        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);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SCENARIO_OUT_OF_BOUNDS,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1874,7 +1846,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SUPPRESS_NPC_GREETINGS,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SUSPEND_COMMS,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SUSPEND_TOKEN,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_TABARD_VENDOR_ACTIVATE,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_TABARD_VENDOR_ACTIVATE,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TALENTS_ERROR,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TALENTS_INFO,                            STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TALENTS_INVOLUNTARILY_RESET,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1900,7 +1872,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TRANSFER_PENDING,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TRIGGER_CINEMATIC,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TRIGGER_MOVIE,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_TURN_IN_PETITION_RESULTS,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_TURN_IN_PETITION_RESULTS,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_TUTORIAL_FLAGS,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UI_TIME,                                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_UNDELETE_CHARACTER_RESPONSE,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
diff --git a/src/server/game/Server/Protocol/Opcodes.h b/src/server/game/Server/Protocol/Opcodes.h
index 6666b38bfc2..eff8ab83551 100644
--- a/src/server/game/Server/Protocol/Opcodes.h
+++ b/src/server/game/Server/Protocol/Opcodes.h
@@ -90,7 +90,6 @@ enum OpcodeClient : uint32
     CMSG_AUTOSTORE_BANK_ITEM                          = 0x0732,
     CMSG_AUTOSTORE_GROUND_ITEM                        = 0xBADD,
     CMSG_AUTOSTORE_LOOT_ITEM                          = 0x0609,
-    CMSG_AUTO_DECLINE_GUILD_INVITES                   = 0xBADD,
     CMSG_BANKER_ACTIVATE                              = 0x1B24,
     CMSG_BATTLEFIELD_JOIN                             = 0xBADD,
     CMSG_BATTLEFIELD_LEAVE                            = 0x06F1,
@@ -311,34 +310,33 @@ enum OpcodeClient : uint32
     CMSG_GROUP_SET_LEADER                             = 0xBADD,
     CMSG_GROUP_SET_ROLES                              = 0xBADD,
     CMSG_GROUP_SWAP_SUB_GROUP                         = 0xBADD,
-    CMSG_GUILD_ACCEPT                                 = 0xBADD,
     CMSG_GUILD_ADD_BATTLENET_FRIEND                   = 0x1437,
     CMSG_GUILD_ADD_RANK                               = 0x1630,
     CMSG_GUILD_ASSIGN_MEMBER_RANK                     = 0x0436,
     CMSG_GUILD_AUTO_DECLINE_INVITATION                = 0x062F,
-    CMSG_GUILD_BANKER_ACTIVATE                        = 0x19E3,
+    CMSG_GUILD_BANK_ACTIVATE                          = 0x19E3,
     CMSG_GUILD_BANK_BUY_TAB                           = 0x1BC3,
     CMSG_GUILD_BANK_DEPOSIT_MONEY                     = 0x1B11,
     CMSG_GUILD_BANK_LOG_QUERY                         = 0x0428,
-    CMSG_GUILD_BANK_MONEY_WITHDRAWN_QUERY             = 0x020D,
+    CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY    = 0x063D,
     CMSG_GUILD_BANK_NOTE                              = 0xBADD,
     CMSG_GUILD_BANK_QUERY_TAB                         = 0x1139,
-    CMSG_GUILD_BANK_QUERY_TEXT                        = 0x062D,
-    CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY    = 0x063D,
+    CMSG_GUILD_BANK_TEXT_QUERY                        = 0x062D,
     CMSG_GUILD_BANK_SET_TAB_TEXT                      = 0x0E30,
     CMSG_GUILD_BANK_SWAP_ITEMS                        = 0x1131,
     CMSG_GUILD_BANK_UPDATE_TAB                        = 0x13C1,
-    CMSG_GUILD_BANK_WITHDRAW_MONEY                    = 0xBADD,
+    CMSG_GUILD_BANK_WITHDRAW_MONEY                    = 0x020D,
+    CMSG_GUILD_CHALLENGE_UPDATE_REQUEST               = 0x166E,
     CMSG_GUILD_CHANGE_NAME_REQUEST                    = 0x043E,
-    CMSG_GUILD_DECLINE                                = 0x0667,
+    CMSG_GUILD_DECLINE_INVITATION                     = 0x0667,
     CMSG_GUILD_DELETE                                 = 0x1427,
     CMSG_GUILD_DELETE_RANK                            = 0x0C28,
-    CMSG_GUILD_DEMOTE                                 = 0x142F,
-    CMSG_GUILD_DISBAND                                = 0xBADD,
+    CMSG_GUILD_DEMOTE_MEMBER                          = 0x142F,
     CMSG_GUILD_EVENT_LOG_QUERY                        = 0x0E37,
     CMSG_GUILD_GET_ACHIEVEMENT_MEMBERS                = 0x0C40,
     CMSG_GUILD_GET_RANKS                              = 0x0C37,
     CMSG_GUILD_GET_ROSTER                             = 0x0638,
+    CMSG_GUILD_INFO                                   = 0xBADD,
     CMSG_GUILD_INVITE_BY_NAME                         = 0x19A4,
     CMSG_GUILD_LEAVE                                  = 0x0476,
     CMSG_GUILD_MEMBER_SEND_SOR_REQUEST                = 0x0666,
@@ -352,15 +350,11 @@ enum OpcodeClient : uint32
     CMSG_GUILD_QUERY_NEWS                             = 0x0676,
     CMSG_GUILD_QUERY_RECIPES                          = 0x1438,
     CMSG_GUILD_REPLACE_GUILD_MASTER                   = 0x163E,
-    CMSG_GUILD_REQUEST_CHALLENGE_INFO                 = 0x166E,
-    CMSG_GUILD_REQUEST_CHALLENGE_UPDATE               = 0xBADD,
-    CMSG_GUILD_REQUEST_MAX_DAILY_XP                   = 0xBADD,
     CMSG_GUILD_REQUEST_PARTY_STATE                    = 0x0A8E,
     CMSG_GUILD_SET_ACHIEVEMENT_TRACKING               = 0x1640,
     CMSG_GUILD_SET_FOCUSED_ACHIEVEMENT                = 0x0C7E,
     CMSG_GUILD_SET_GUILD_MASTER                       = 0x1184,
     CMSG_GUILD_SET_MEMBER_NOTE                        = 0x1C27,
-    CMSG_GUILD_SET_NOTE                               = 0xBADD,
     CMSG_GUILD_SET_RANK_PERMISSIONS                   = 0x0E38,
     CMSG_GUILD_SHIFT_RANK                             = 0x0627,
     CMSG_GUILD_UPDATE_INFO_TEXT                       = 0x0C75,
@@ -412,7 +406,6 @@ enum OpcodeClient : uint32
     CMSG_LF_GUILD_GET_APPLICATIONS                    = 0x043F,
     CMSG_LF_GUILD_GET_GUILD_POST                      = 0x0E68,
     CMSG_LF_GUILD_GET_RECRUITS                        = 0x0430,
-    CMSG_LF_GUILD_POST_REQUEST                        = 0xBADD,
     CMSG_LF_GUILD_REMOVE_RECRUIT                      = 0x0680,
     CMSG_LF_GUILD_SET_GUILD_POST                      = 0x0B3D,
     CMSG_LIST_INVENTORY                               = 0x0B39,
@@ -552,11 +545,9 @@ enum OpcodeClient : uint32
     CMSG_PARTY_UNINVITE                               = 0x1982,
     CMSG_PARTY_UNSILENCE                              = 0xBADD,
     CMSG_PETITION_BUY                                 = 0x0010,
-    CMSG_PETITION_QUERY                               = 0xBADD,
     CMSG_PETITION_RENAME_GUILD                        = 0x0920,
     CMSG_PETITION_SHOW_LIST                           = 0x000F,
     CMSG_PETITION_SHOW_SIGNATURES                     = 0x0BC4,
-    CMSG_PETITION_SIGN                                = 0xBADD,
     CMSG_PET_ABANDON                                  = 0x0005,
     CMSG_PET_ACTION                                   = 0x133A,
     CMSG_PET_BATTLE_FINAL_NOTIF                       = 0x0565,
@@ -589,7 +580,6 @@ enum OpcodeClient : uint32
     CMSG_QUERY_CORPSE_LOCATION_FROM_CLIENT            = 0x128A,
     CMSG_QUERY_CORPSE_TRANSPORT                       = 0x0908,
     CMSG_QUERY_COUNTDOWN_TIMER                        = 0x09DE,
-    CMSG_QUERY_GUILD_XP                               = 0xBADD,
     CMSG_QUERY_INSPECT_ACHIEVEMENTS                   = 0x0A07,
     CMSG_QUERY_NEXT_MAIL_TIME                         = 0x0B31,
     CMSG_QUERY_PETITION                               = 0x048B,
@@ -692,7 +682,6 @@ enum OpcodeClient : uint32
     CMSG_SET_FACTION_CHEAT                            = 0xBADD,
     CMSG_SET_FACTION_INACTIVE                         = 0x09E2,
     CMSG_SET_FACTION_NOT_AT_WAR                       = 0x0A06,
-    CMSG_SET_GUILD_BANK_TEXT                          = 0xBADD,
     CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT               = 0x02C4,
     CMSG_SET_LFG_BONUS_FACTION_ID                     = 0x009D,
     CMSG_SET_LFG_COMMENT                              = 0xBADD,
@@ -1201,31 +1190,29 @@ enum OpcodeServer : uint32
     SMSG_GUILD_ACHIEVEMENT_DELETED                    = 0x1058,
     SMSG_GUILD_ACHIEVEMENT_EARNED                     = 0x1048,
     SMSG_GUILD_ACHIEVEMENT_MEMBERS                    = 0x1826,
-    SMSG_GUILD_BANK_LIST                              = 0x1245,
     SMSG_GUILD_BANK_LOG_QUERY_RESULT                  = 0x1237,
-    SMSG_GUILD_BANK_MONEY_WITHDRAWN                   = 0x1047,
-    SMSG_GUILD_BANK_QUERY_TEXT_RESULT                 = 0x1875,
+    SMSG_GUILD_BANK_QUERY_RESULTS                     = 0x1245,
+    SMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY          = 0x1047,
+    SMSG_GUILD_BANK_TEXT_QUERY_RESULT                 = 0x1875,
     SMSG_GUILD_CANCEL                                 = 0xBADD,
     SMSG_GUILD_CHALLENGE_COMPLETED                    = 0x1836,
-    SMSG_GUILD_CHALLENGE_UPDATED                      = 0x1A06,
+    SMSG_GUILD_CHALLENGE_UPDATE                       = 0x1A06,
     SMSG_GUILD_CHANGE_NAME_RESULT                     = 0x1006,
     SMSG_GUILD_COMMAND_RESULT                         = 0x1205,
-    SMSG_GUILD_COMMAND_RESULT_2                       = 0xBADD,
     SMSG_GUILD_CRITERIA_DELETED                       = 0x1805,
     SMSG_GUILD_CRITERIA_UPDATE                        = 0x1208,
     SMSG_GUILD_DECLINE                                = 0xBADD,
-    SMSG_GUILD_EVENT                                  = 0xBADD,
     SMSG_GUILD_EVENT_BANK_CONTENTS_CHANGED            = 0x1045,
     SMSG_GUILD_EVENT_BANK_MONEY_CHANGED               = 0x1077,
     SMSG_GUILD_EVENT_DISBANDED                        = 0x1A08,
-    SMSG_GUILD_EVENT_LOG_QUERY_RESULTS                = 0x1075,
+    SMSG_GUILD_EVENT_LOG_QUERY_RESULT                 = 0x1075,
     SMSG_GUILD_EVENT_MOTD                             = 0x1825,
     SMSG_GUILD_EVENT_NEW_LEADER                       = 0x1005,
     SMSG_GUILD_EVENT_PLAYER_JOINED                    = 0x1257,
     SMSG_GUILD_EVENT_PLAYER_LEFT                      = 0x1206,
     SMSG_GUILD_EVENT_PRESENCE_CHANGE                  = 0x1228,
-    SMSG_GUILD_EVENT_RANKS_UPDATED                    = 0x1018,
     SMSG_GUILD_EVENT_RANK_CHANGED                     = 0x1276,
+    SMSG_GUILD_EVENT_RANKS_UPDATED                    = 0x1018,
     SMSG_GUILD_EVENT_TAB_ADDED                        = 0x1868,
     SMSG_GUILD_EVENT_TAB_DELETED                      = 0x1808,
     SMSG_GUILD_EVENT_TAB_MODIFIED                     = 0x1035,
@@ -1236,34 +1223,25 @@ enum OpcodeServer : uint32
     SMSG_GUILD_INVITE_DECLINED                        = 0x1226,
     SMSG_GUILD_INVITE_EXPIRED                         = 0x1246,
     SMSG_GUILD_KNOWN_RECIPES                          = 0x1078,
-    SMSG_GUILD_MAX_DAILY_XP                           = 0xBADD,
     SMSG_GUILD_MEMBERS_WITH_RECIPE                    = 0x1277,
     SMSG_GUILD_MEMBER_DAILY_RESET                     = 0x1015,
     SMSG_GUILD_MEMBER_RECIPES                         = 0x1036,
     SMSG_GUILD_MEMBER_UPDATE_NOTE                     = 0x1846,
     SMSG_GUILD_MOVED                                  = 0x1838,
-    SMSG_GUILD_MOVE_COMPLETE                          = 0xBADD,
     SMSG_GUILD_MOVE_STARTING                          = 0x1877,
-    SMSG_GUILD_NAME_CHANGED                           = 0x1A07,
     SMSG_GUILD_NEWS                                   = 0x1027,
     SMSG_GUILD_NEWS_DELETED                           = 0x1007,
-    SMSG_GUILD_NEWS_UPDATE                            = 0xBADD,
     SMSG_GUILD_PARTY_STATE_RESPONSE                   = 0x1225,
     SMSG_GUILD_PERMISSIONS_QUERY_RESULTS              = 0x1827,
     SMSG_GUILD_QUERY_RESPONSE                         = 0x1046,
     SMSG_GUILD_RANKS                                  = 0x1218,
+    SMSG_GUILD_RECIPES                                = 0xBADD,
     SMSG_GUILD_REPUTATION_REACTION_CHANGED            = 0x1068,
-    SMSG_GUILD_REPUTATION_WEEKLY_CAP                  = 0xBADD,
     SMSG_GUILD_RESET                                  = 0x1258,
     SMSG_GUILD_REWARDS_LIST                           = 0x1818,
     SMSG_GUILD_ROSTER                                 = 0x1026,
     SMSG_GUILD_ROSTER_UPDATE                          = 0x1265,
     SMSG_GUILD_SEND_RANK_CHANGE                       = 0x1207,
-    SMSG_GUILD_SET_NOTE                               = 0xBADD,
-    SMSG_GUILD_TRADESKILL_UPDATE                      = 0xBADD,
-    SMSG_GUILD_XP                                     = 0xBADD,
-    SMSG_GUILD_XP_GAIN                                = 0xBADD,
-    SMSG_GUILD_XP_UPDATE                              = 0xBADD,
     SMSG_HEALTH_UPDATE                                = 0x0BE1,
     SMSG_HIGHEST_THREAT_UPDATE                        = 0x059A,
     SMSG_HOTFIX_NOTIFY                                = 0x1304,
@@ -1517,7 +1495,6 @@ enum OpcodeServer : uint32
     SMSG_PERIODICAURALOG                              = 0x0B1B,
     SMSG_PETGODMODE                                   = 0xBADD,
     SMSG_PETITION_ALREADY_SIGNED                      = 0x0D8E,
-    SMSG_PETITION_DECLINED                            = 0x1B32,
     SMSG_PETITION_RENAME_GUILD_RESPONSE               = 0x1055,
     SMSG_PETITION_SHOW_LIST                           = 0x0915,
     SMSG_PETITION_SHOW_SIGNATURES                     = 0x0830,
diff --git a/src/server/game/Server/WorldSession.cpp b/src/server/game/Server/WorldSession.cpp
index 114b303e7f4..20a72640d49 100644
--- a/src/server/game/Server/WorldSession.cpp
+++ b/src/server/game/Server/WorldSession.cpp
@@ -1385,23 +1385,23 @@ uint32 WorldSession::DosProtection::GetMaxPacketCounterAllowed(uint16 opcode) co
         //case CMSG_ARENA_TEAM_REMOVE:                    // not profiled
         //case CMSG_ARENA_TEAM_LEADER:                    // not profiled
         case CMSG_LOOT_METHOD:                          // not profiled
-        case CMSG_GUILD_INVITE_BY_NAME:                   // not profiled
-        //case CMSG_GUILD_ACCEPT:                         // not profiled
-        case CMSG_GUILD_DECLINE:                        // not profiled
+        case CMSG_GUILD_INVITE_BY_NAME:                 // not profiled
+        case CMSG_ACCEPT_GUILD_INVITE:                  // not profiled
+        case CMSG_GUILD_DECLINE_INVITATION:             // not profiled
         case CMSG_GUILD_LEAVE:                          // not profiled
-        case CMSG_GUILD_DISBAND:                        // not profiled
+        case CMSG_GUILD_DELETE:                         // not profiled
         case CMSG_GUILD_SET_GUILD_MASTER:               // not profiled
-        //case CMSG_GUILD_MOTD:                           // not profiled
+        case CMSG_GUILD_UPDATE_MOTD_TEXT:               // not profiled
         case CMSG_GUILD_SET_RANK_PERMISSIONS:           // not profiled
         case CMSG_GUILD_ADD_RANK:                       // not profiled
         case CMSG_GUILD_DELETE_RANK:                    // not profiled
-        case CMSG_GUILD_UPDATE_INFO_TEXT:                 // not profiled
+        case CMSG_GUILD_UPDATE_INFO_TEXT:               // not profiled
         case CMSG_GUILD_BANK_DEPOSIT_MONEY:             // not profiled
-        //case CMSG_GUILD_BANK_WITHDRAW_MONEY:            // not profiled
+        case CMSG_GUILD_BANK_WITHDRAW_MONEY:            // not profiled
         case CMSG_GUILD_BANK_BUY_TAB:                   // not profiled
-        //case CMSG_GUILD_BANK_UPDATE_TAB:                // not profiled
+        case CMSG_GUILD_BANK_UPDATE_TAB:                // not profiled
         //case CMSG_SET_GUILD_BANK_TEXT:                  // not profiled
-        //case CMSG_SAVE_GUILD_EMBLEM:                     // not profiled
+        case CMSG_SAVE_GUILD_EMBLEM:                    // not profiled
         //case MSG_PETITION_RENAME:                       // not profiled
         //case MSG_TALENT_WIPE_CONFIRM:                   // not profiled
         case CMSG_SET_DUNGEON_DIFFICULTY:               // not profiled
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index fe221d38a9e..4ad9e35c01e 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -166,6 +166,44 @@ namespace WorldPackets
     namespace Guild
     {
         class QueryGuildInfo;
+        class GuildInviteByName;
+        class AcceptGuildInvite;
+        class DeclineGuildInvites;
+        class GuildDeclineInvitation;
+        class GuildGetRoster;
+        class GuildPromoteMember;
+        class GuildDemoteMember;
+        class GuildOfficerRemoveMember;
+        class GuildAssignMemberRank;
+        class GuildLeave;
+        class GuildDelete;
+        class GuildUpdateMotdText;
+        class GuildGetRanks;
+        class GuildAddRank;
+        class GuildDeleteRank;
+        class GuildUpdateInfoText;
+        class GuildSetMemberNote;
+        class GuildEventLogQuery;
+        class GuildBankRemainingWithdrawMoneyQuery;
+        class GuildPermissionsQuery;
+        class GuildSetRankPermissions;
+        class GuildBankActivate;
+        class GuildBankQueryTab;
+        class GuildBankDepositMoney;
+        class GuildBankWithdrawMoney;
+        class GuildBankSwapItems;
+        class GuildBankBuyTab;
+        class GuildBankUpdateTab;
+        class GuildBankLogQuery;
+        class GuildBankTextQuery;
+        class GuildBankSetTabText;
+        class RequestGuildPartyState;
+        class RequestGuildRewardsList;
+        class GuildQueryNews;
+        class GuildNewsUpdateSticky;
+        class GuildSetGuildMaster;
+        class GuildChallengeUpdateRequest;
+        class SaveGuildEmblem;
     }
 
     namespace Inspect
@@ -243,6 +281,19 @@ namespace WorldPackets
         class GossipSelectOption;
     }
 
+    namespace Petition
+    {
+        class DeclinePetition;
+        class OfferPetition;
+        class PetitionBuy;
+        class PetitionRenameGuild;
+        class PetitionShowList;
+        class PetitionShowSignatures;
+        class QueryPetition;
+        class SignPetition;
+        class TurnInPetition;
+    }
+
     namespace Query
     {
         class QueryCreature;
@@ -862,44 +913,43 @@ class WorldSession
         void HandlePartyAssignmentOpcode(WorldPacket& recvData);
         void HandleRolePollBeginOpcode(WorldPacket& recvData);
 
-        void HandlePetitionBuyOpcode(WorldPacket& recvData);
-        void HandlePetitionShowSignOpcode(WorldPacket& recvData);
-        void HandlePetitionQueryOpcode(WorldPacket& recvData);
-        void HandlePetitionRenameGuildOpcode(WorldPacket& recvData);
-        void HandlePetitionSignOpcode(WorldPacket& recvData);
-        void HandlePetitionDeclineOpcode(WorldPacket& recvData);
-        void HandleOfferPetitionOpcode(WorldPacket& recvData);
-        void HandleTurnInPetitionOpcode(WorldPacket& recvData);
+        void HandleDeclinePetition(WorldPackets::Petition::DeclinePetition& packet);
+        void HandleOfferPetition(WorldPackets::Petition::OfferPetition& packet);
+        void HandlePetitionBuy(WorldPackets::Petition::PetitionBuy& packet);
+        void HandlePetitionShowSignatures(WorldPackets::Petition::PetitionShowSignatures& packet);
+        void HandleQueryPetition(WorldPackets::Petition::QueryPetition& packet);
+        void HandlePetitionRenameGuild(WorldPackets::Petition::PetitionRenameGuild& packet);
+        void HandleSignPetition(WorldPackets::Petition::SignPetition& packet);
+        void HandleTurnInPetition(WorldPackets::Petition::TurnInPetition& packet);
 
         void HandleGuildQueryOpcode(WorldPackets::Guild::QueryGuildInfo& query);
-        void HandleGuildInviteOpcode(WorldPacket& recvPacket);
-        void HandleGuildOfficerRemoveMemberOpcode(WorldPacket& recvPacket);
-        void HandleGuildAcceptOpcode(WorldPacket& recvPacket);
-        void HandleGuildDeclineOpcode(WorldPacket& recvPacket);
-        void HandleGuildEventLogQueryOpcode(WorldPacket& recvPacket);
-        void HandleGuildRosterOpcode(WorldPacket& recvPacket);
-        void HandleGuildRewardsQueryOpcode(WorldPacket& recvPacket);
-        void HandleGuildPromoteOpcode(WorldPacket& recvPacket);
-        void HandleGuildDemoteOpcode(WorldPacket& recvPacket);
-        void HandleGuildAssignRankOpcode(WorldPacket& recvPacket);
-        void HandleGuildLeaveOpcode(WorldPacket& recvPacket);
-        void HandleGuildDisbandOpcode(WorldPacket& recvPacket);
+        void HandleGuildInviteByName(WorldPackets::Guild::GuildInviteByName& packet);
+        void HandleGuildOfficerRemoveMember(WorldPackets::Guild::GuildOfficerRemoveMember& packet);
+        void HandleGuildAcceptInvite(WorldPackets::Guild::AcceptGuildInvite& invite);
+        void HandleGuildDeclineInvitation(WorldPackets::Guild::GuildDeclineInvitation& decline);
+        void HandleGuildEventLogQuery(WorldPackets::Guild::GuildEventLogQuery& packet);
+        void HandleGuildGetRoster(WorldPackets::Guild::GuildGetRoster& packet);
+        void HandleRequestGuildRewardsList(WorldPackets::Guild::RequestGuildRewardsList& packet);
+        void HandleGuildPromoteMember(WorldPackets::Guild::GuildPromoteMember& promote);
+        void HandleGuildDemoteMember(WorldPackets::Guild::GuildDemoteMember& demote);
+        void HandleGuildAssignRank(WorldPackets::Guild::GuildAssignMemberRank& packet);
+        void HandleGuildLeave(WorldPackets::Guild::GuildLeave& leave);
+        void HandleGuildDelete(WorldPackets::Guild::GuildDelete& packet);
         void HandleGuildSetAchievementTracking(WorldPacket& recvPacket);
-        void HandleGuildSetGuildMaster(WorldPacket& recvPacket);
-        void HandleGuildMOTDOpcode(WorldPacket& recvPacket);
-        void HandleGuildNewsUpdateStickyOpcode(WorldPacket& recvPacket);
-        void HandleGuildSetNoteOpcode(WorldPacket& recvPacket);
-        void HandleGuildGetRanksOpcode(WorldPacket& recvPacket);
-        void HandleGuildQueryNewsOpcode(WorldPacket& recvPacket);
-        void HandleGuildSetRankPermissionsOpcode(WorldPacket& recvPacket);
-        void HandleGuildAddRankOpcode(WorldPacket& recvPacket);
-        void HandleGuildDeleteRankOpcode(WorldPacket& recvPacket);
-        void HandleGuildChangeInfoTextOpcode(WorldPacket& recvPacket);
-        void HandleSaveGuildEmblemOpcode(WorldPacket& recvPacket);
-        void HandleGuildRequestPartyState(WorldPacket& recvPacket);
-        void HandleGuildRequestChallengeUpdate(WorldPacket& recvPacket);
-        void HandleGuildRequestMaxDailyXP(WorldPacket& recvPacket);
-        void HandleAutoDeclineGuildInvites(WorldPacket& recvPacket);
+        void HandleGuildSetGuildMaster(WorldPackets::Guild::GuildSetGuildMaster& packet);
+        void HandleGuildUpdateMotdText(WorldPackets::Guild::GuildUpdateMotdText& packet);
+        void HandleGuildNewsUpdateSticky(WorldPackets::Guild::GuildNewsUpdateSticky& packet);
+        void HandleGuildSetMemberNote(WorldPackets::Guild::GuildSetMemberNote& packet);
+        void HandleGuildGetRanks(WorldPackets::Guild::GuildGetRanks& packet);
+        void HandleGuildQueryNews(WorldPackets::Guild::GuildQueryNews& newsQuery);
+        void HandleGuildSetRankPermissions(WorldPackets::Guild::GuildSetRankPermissions& packet);
+        void HandleGuildAddRank(WorldPackets::Guild::GuildAddRank& packet);
+        void HandleGuildDeleteRank(WorldPackets::Guild::GuildDeleteRank& packet);
+        void HandleGuildUpdateInfoText(WorldPackets::Guild::GuildUpdateInfoText& packet);
+        void HandleSaveGuildEmblem(WorldPackets::Guild::SaveGuildEmblem& packet);
+        void HandleGuildRequestPartyState(WorldPackets::Guild::RequestGuildPartyState& packet);
+        void HandleGuildChallengeUpdateRequest(WorldPackets::Guild::GuildChallengeUpdateRequest& packet);
+        void HandleDeclineGuildInvites(WorldPackets::Guild::DeclineGuildInvites& packet);
 
         void HandleGuildFinderAddRecruit(WorldPacket& recvPacket);
         void HandleGuildFinderBrowse(WorldPacket& recvPacket);
@@ -917,12 +967,12 @@ class WorldSession
         void HandleMoveSplineDoneOpcode(WorldPacket& recvPacket);
         void SendActivateTaxiReply(ActivateTaxiReply reply);
 
-        void HandleTabardVendorActivateOpcode(WorldPacket& recvPacket);
+        void HandleTabardVendorActivateOpcode(WorldPackets::NPC::Hello& packet);
         void HandleBankerActivateOpcode(WorldPackets::NPC::Hello& packet);
         void HandleBuyBankSlotOpcode(WorldPacket& recvPacket);
         void HandleTrainerListOpcode(WorldPackets::NPC::Hello& packet);
         void HandleTrainerBuySpellOpcode(WorldPacket& recvPacket);
-        void HandlePetitionShowListOpcode(WorldPacket& recvPacket);
+        void HandlePetitionShowList(WorldPackets::Petition::PetitionShowList& packet);
         void HandleGossipHelloOpcode(WorldPackets::NPC::Hello& packet);
         void HandleGossipSelectOptionOpcode(WorldPackets::NPC::GossipSelectOption& packet);
         void HandleSpiritHealerActivateOpcode(WorldPacket& recvPacket);
@@ -1193,20 +1243,19 @@ class WorldSession
         void HandleSetTaxiBenchmarkOpcode(WorldPacket& recvData);
 
         // Guild Bank
-        void HandleGuildPermissions(WorldPacket& recvData);
-        void HandleGuildBankMoneyWithdrawn(WorldPacket& recvData);
-        void HandleGuildBankerActivate(WorldPacket& recvData);
-        void HandleGuildBankQueryTab(WorldPacket& recvData);
-        void HandleGuildBankLogQuery(WorldPacket& recvData);
-        void HandleGuildBankDepositMoney(WorldPacket& recvData);
-        void HandleGuildBankWithdrawMoney(WorldPacket& recvData);
-        void HandleGuildBankSwapItems(WorldPacket& recvData);
-
-        void HandleGuildBankUpdateTab(WorldPacket& recvData);
-        void HandleGuildBankBuyTab(WorldPacket& recvData);
-        void HandleQueryGuildBankTabText(WorldPacket& recvData);
-        void HandleSetGuildBankTabText(WorldPacket& recvData);
-        void HandleGuildQueryXPOpcode(WorldPacket& recvData);
+        void HandleGuildPermissionsQuery(WorldPackets::Guild::GuildPermissionsQuery& packet);
+        void HandleGuildBankMoneyWithdrawn(WorldPackets::Guild::GuildBankRemainingWithdrawMoneyQuery& packet);
+        void HandleGuildBankActivate(WorldPackets::Guild::GuildBankActivate& packet);
+        void HandleGuildBankQueryTab(WorldPackets::Guild::GuildBankQueryTab& packet);
+        void HandleGuildBankLogQuery(WorldPackets::Guild::GuildBankLogQuery& packet);
+        void HandleGuildBankDepositMoney(WorldPackets::Guild::GuildBankDepositMoney& packet);
+        void HandleGuildBankWithdrawMoney(WorldPackets::Guild::GuildBankWithdrawMoney& packet);
+        void HandleGuildBankSwapItems(WorldPackets::Guild::GuildBankSwapItems& packet);
+
+        void HandleGuildBankUpdateTab(WorldPackets::Guild::GuildBankUpdateTab& packet);
+        void HandleGuildBankBuyTab(WorldPackets::Guild::GuildBankBuyTab& packet);
+        void HandleGuildBankTextQuery(WorldPackets::Guild::GuildBankTextQuery& packet);
+        void HandleGuildBankSetTabText(WorldPackets::Guild::GuildBankSetTabText& packet);
 
         // Refer-a-Friend
         void HandleGrantLevel(WorldPacket& recvData);