refactor(Core/Packet): Guild (#9411)

* Core/Packet: Guild

* Winfi
This commit is contained in:
IntelligentQuantum
2021-12-11 12:30:06 +03:30
committed by GitHub
parent fad214efe0
commit 3591f69662
14 changed files with 1800 additions and 920 deletions

View File

@@ -18,4 +18,6 @@
#ifndef AllPackets_h__
#define AllPackets_h__
#include "GuildPackets.h"
#endif // AllPackets_h__

View File

@@ -0,0 +1,458 @@
/*
* This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by the
* Free Software Foundation; either version 3 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 Affero General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "GuildPackets.h"
void WorldPackets::Guild::QueryGuildInfo::Read()
{
_worldPacket >> GuildId;
}
WorldPackets::Guild::QueryGuildInfoResponse::QueryGuildInfoResponse()
: ServerPacket(SMSG_GUILD_QUERY_RESPONSE) { }
WorldPacket const* WorldPackets::Guild::QueryGuildInfoResponse::Write()
{
_worldPacket << GuildId;
_worldPacket << Info.GuildName;
for (std::string const& rankName : Info.Ranks)
_worldPacket << rankName;
_worldPacket << uint32(Info.EmblemStyle);
_worldPacket << uint32(Info.EmblemColor);
_worldPacket << uint32(Info.BorderStyle);
_worldPacket << uint32(Info.BorderColor);
_worldPacket << uint32(Info.BackgroundColor);
_worldPacket << uint32(Info.RankCount);
return &_worldPacket;
}
void WorldPackets::Guild::GuildCreate::Read()
{
_worldPacket >> GuildName;
}
WorldPacket const* WorldPackets::Guild::GuildInfoResponse::Write()
{
_worldPacket << GuildName;
_worldPacket.AppendPackedTime(CreateDate);
_worldPacket << int32(NumMembers);
_worldPacket << int32(NumAccounts);
return &_worldPacket;
}
WorldPacket const* WorldPackets::Guild::GuildRoster::Write()
{
_worldPacket << uint32(MemberData.size());
_worldPacket << WelcomeText;
_worldPacket << InfoText;
_worldPacket << uint32(RankData.size());
for (GuildRankData const& rank : RankData)
_worldPacket << rank;
for (GuildRosterMemberData const& member : MemberData)
_worldPacket << member;
return &_worldPacket;
}
void WorldPackets::Guild::GuildUpdateMotdText::Read()
{
_worldPacket >> MotdText;
}
WorldPacket const* WorldPackets::Guild::GuildCommandResult::Write()
{
_worldPacket << int32(Command);
_worldPacket << Name;
_worldPacket << int32(Result);
return &_worldPacket;
}
void WorldPackets::Guild::GuildInviteByName::Read()
{
_worldPacket >> Name;
}
WorldPacket const* WorldPackets::Guild::GuildInvite::Write()
{
_worldPacket << InviterName;
_worldPacket << GuildName;
return &_worldPacket;
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData)
{
data << rosterMemberData.Guid;
data << uint8(rosterMemberData.Status);
data << rosterMemberData.Name;
data << int32(rosterMemberData.RankID);
data << uint8(rosterMemberData.Level);
data << uint8(rosterMemberData.ClassID);
data << uint8(rosterMemberData.Gender);
data << int32(rosterMemberData.AreaID);
if (!rosterMemberData.Status)
data << float(rosterMemberData.LastSave);
data << rosterMemberData.Note;
data << rosterMemberData.OfficerNote;
return data;
}
WorldPacket const* WorldPackets::Guild::GuildEvent::Write()
{
_worldPacket << uint8(Type);
_worldPacket << uint8(Params.size());
for (std::string_view param : Params)
_worldPacket << param;
switch (Type)
{
case GE_JOINED:
case GE_LEFT:
case GE_SIGNED_ON:
case GE_SIGNED_OFF:
_worldPacket << Guid;
break;
default:
break;
}
return &_worldPacket;
}
WorldPacket const* WorldPackets::Guild::GuildEventLogQueryResults::Write()
{
_worldPacket.reserve(1 + Entry.size() * sizeof(GuildEventEntry));
_worldPacket << uint8(Entry.size());
for (GuildEventEntry const& entry : Entry)
{
_worldPacket << uint8(entry.TransactionType);
_worldPacket << entry.PlayerGUID;
if (entry.TransactionType != GUILD_EVENT_LOG_JOIN_GUILD && entry.TransactionType != GUILD_EVENT_LOG_LEAVE_GUILD)
_worldPacket << entry.OtherGUID;
if (entry.TransactionType == GUILD_EVENT_LOG_PROMOTE_PLAYER || entry.TransactionType == GUILD_EVENT_LOG_DEMOTE_PLAYER)
_worldPacket << uint8(entry.RankID);
_worldPacket << uint32(entry.TransactionDate);
}
return &_worldPacket;
}
WorldPacket const* WorldPackets::Guild::GuildPermissionsQueryResults::Write()
{
_worldPacket << uint32(RankID);
_worldPacket << int32(Flags);
_worldPacket << int32(WithdrawGoldLimit);
_worldPacket << int8(NumTabs);
for (GuildRankTabPermissions const& tab : Tab)
{
_worldPacket << int32(tab.Flags);
_worldPacket << int32(tab.WithdrawItemLimit);
}
return &_worldPacket;
}
void WorldPackets::Guild::GuildSetRankPermissions::Read()
{
_worldPacket >> RankID;
_worldPacket >> Flags;
_worldPacket >> RankName;
_worldPacket >> WithdrawGoldLimit;
for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
{
_worldPacket >> TabFlags[i];
_worldPacket >> TabWithdrawItemLimit[i];
}
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData)
{
data << uint32(rankData.Flags);
data << uint32(rankData.WithdrawGoldLimit);
for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
{
data << uint32(rankData.TabFlags[i]);
data << uint32(rankData.TabWithdrawItemLimit[i]);
}
return data;
}
void WorldPackets::Guild::GuildAddRank::Read()
{
_worldPacket >> Name;
}
void WorldPackets::Guild::GuildUpdateInfoText::Read()
{
_worldPacket >> InfoText;
}
void WorldPackets::Guild::GuildSetMemberNote::Read()
{
_worldPacket >> NoteeName;
_worldPacket >> Note;
}
void WorldPackets::Guild::GuildDemoteMember::Read()
{
_worldPacket >> Demotee;
}
void WorldPackets::Guild::GuildPromoteMember::Read()
{
_worldPacket >> Promotee;
}
void WorldPackets::Guild::GuildOfficerRemoveMember::Read()
{
_worldPacket >> Removee;
}
void WorldPackets::Guild::GuildBankActivate::Read()
{
_worldPacket >> Banker;
_worldPacket >> FullUpdate;
}
void WorldPackets::Guild::GuildBankBuyTab::Read()
{
_worldPacket >> Banker;
_worldPacket >> BankTab;
}
void WorldPackets::Guild::GuildBankUpdateTab::Read()
{
_worldPacket >> Banker;
_worldPacket >> BankTab;
_worldPacket >> Name;
_worldPacket >> Icon;
}
void WorldPackets::Guild::GuildBankDepositMoney::Read()
{
_worldPacket >> Banker;
_worldPacket >> Money;
}
void WorldPackets::Guild::GuildBankQueryTab::Read()
{
_worldPacket >> Banker;
_worldPacket >> Tab;
_worldPacket >> FullUpdate;
}
WorldPacket const* WorldPackets::Guild::GuildBankRemainingWithdrawMoney::Write()
{
_worldPacket << RemainingWithdrawMoney;
return &_worldPacket;
}
void WorldPackets::Guild::GuildBankWithdrawMoney::Read()
{
_worldPacket >> Banker;
_worldPacket >> Money;
}
WorldPacket const* WorldPackets::Guild::GuildBankQueryResults::Write()
{
_worldPacket << uint64(Money);
_worldPacket << uint8(Tab);
_withdrawalsRemainingPos = _worldPacket.wpos();
_worldPacket << int32(WithdrawalsRemaining);
_worldPacket << uint8(FullUpdate);
if (!Tab && FullUpdate)
{
_worldPacket << uint8(TabInfo.size());
for (GuildBankTabInfo const& tab : TabInfo)
{
_worldPacket << tab.Name;
_worldPacket << tab.Icon;
}
}
_worldPacket << uint8(ItemInfo.size());
for (GuildBankItemInfo const& item : ItemInfo)
{
_worldPacket << uint8(item.Slot);
_worldPacket << uint32(item.ItemID);
if (item.ItemID)
{
_worldPacket << int32(item.Flags);
_worldPacket << int32(item.RandomPropertiesID);
if (item.RandomPropertiesID)
_worldPacket << int32(item.RandomPropertiesSeed);
_worldPacket << int32(item.Count);
_worldPacket << int32(item.EnchantmentID);
_worldPacket << uint8(item.Charges);
_worldPacket << uint8(item.SocketEnchant.size());
for (GuildBankSocketEnchant const& socketEnchant : item.SocketEnchant)
{
_worldPacket << uint8(socketEnchant.SocketIndex);
_worldPacket << int32(socketEnchant.SocketEnchantID);
}
}
}
return &_worldPacket;
}
void WorldPackets::Guild::GuildBankQueryResults::SetWithdrawalsRemaining(int32 withdrawalsRemaining)
{
WithdrawalsRemaining = withdrawalsRemaining;
_worldPacket.put<int32>(_withdrawalsRemainingPos, withdrawalsRemaining);
}
void WorldPackets::Guild::GuildBankSwapItems::Read()
{
_worldPacket >> Banker;
_worldPacket >> BankOnly;
if (BankOnly)
{
// dest
_worldPacket >> BankTab;
_worldPacket >> BankSlot;
_worldPacket >> ItemID;
// src
_worldPacket >> BankTab1;
_worldPacket >> BankSlot1;
_worldPacket >> ItemID1;
_worldPacket >> AutoStore;
_worldPacket >> BankItemCount;
}
else
{
_worldPacket >> BankTab;
_worldPacket >> BankSlot;
_worldPacket >> ItemID;
_worldPacket >> AutoStore;
if (AutoStore)
{
_worldPacket >> BankItemCount;
_worldPacket >> ToSlot;
_worldPacket >> StackCount;
}
else
{
_worldPacket >> ContainerSlot;
_worldPacket >> ContainerItemSlot;
_worldPacket >> ToSlot;
_worldPacket >> StackCount;
}
}
}
void WorldPackets::Guild::GuildBankLogQuery::Read()
{
_worldPacket >> Tab;
}
WorldPacket const* WorldPackets::Guild::GuildBankLogQueryResults::Write()
{
_worldPacket << uint8(Tab);
_worldPacket << uint8(Entry.size());
for (GuildBankLogEntry const& logEntry : Entry)
{
_worldPacket << int8(logEntry.EntryType);
_worldPacket << logEntry.PlayerGUID;
switch (logEntry.EntryType)
{
case GUILD_BANK_LOG_DEPOSIT_ITEM:
case GUILD_BANK_LOG_WITHDRAW_ITEM:
_worldPacket << uint32(logEntry.ItemID);
_worldPacket << uint32(logEntry.Count);
break;
case GUILD_BANK_LOG_MOVE_ITEM:
case GUILD_BANK_LOG_MOVE_ITEM2:
_worldPacket << uint32(logEntry.ItemID);
_worldPacket << uint32(logEntry.Count);
_worldPacket << uint8(logEntry.OtherTab);
break;
default:
_worldPacket << uint32(logEntry.Money);
break;
}
_worldPacket << uint32(logEntry.TimeOffset);
}
return &_worldPacket;
}
void WorldPackets::Guild::GuildBankTextQuery::Read()
{
_worldPacket >> Tab;
}
WorldPacket const* WorldPackets::Guild::GuildBankTextQueryResult::Write()
{
_worldPacket << uint8(Tab);
_worldPacket << Text;
return &_worldPacket;
}
void WorldPackets::Guild::GuildBankSetTabText::Read()
{
_worldPacket >> Tab;
_worldPacket >> TabText;
}
void WorldPackets::Guild::GuildSetGuildMaster::Read()
{
_worldPacket >> NewMasterName;
}
void WorldPackets::Guild::SaveGuildEmblem::Read()
{
_worldPacket >> Vendor;
_worldPacket >> EStyle;
_worldPacket >> EColor;
_worldPacket >> BStyle;
_worldPacket >> BColor;
_worldPacket >> Bg;
}
WorldPacket const* WorldPackets::Guild::PlayerSaveGuildEmblem::Write()
{
_worldPacket << int32(Error);
return &_worldPacket;
}

View File

@@ -0,0 +1,628 @@
/*
* This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by the
* Free Software Foundation; either version 3 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 Affero General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GuildPackets_h__
#define GuildPackets_h__
#include "Packet.h"
#include "Guild.h"
#include "ObjectGuid.h"
#include "PacketUtilities.h"
#include <boost/container/static_vector.hpp>
#include <array>
namespace WorldPackets
{
namespace Guild
{
class QueryGuildInfo final : public ClientPacket
{
public:
QueryGuildInfo(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_QUERY, std::move(packet)) { }
void Read() override;
uint32 GuildId = 0;
};
struct GuildInfo
{
std::string GuildName;
std::array<std::string, GUILD_RANKS_MAX_COUNT> Ranks;
uint32 RankCount = 0;
uint32 EmblemStyle = 0;
uint32 EmblemColor = 0;
uint32 BorderStyle = 0;
uint32 BorderColor = 0;
uint32 BackgroundColor = 0;
};
class QueryGuildInfoResponse final : public ServerPacket
{
public:
QueryGuildInfoResponse();
WorldPacket const* Write() override;
uint32 GuildId = 0;
GuildInfo Info;
};
class GuildCreate final : public ClientPacket
{
public:
GuildCreate(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_CREATE, std::move(packet)) { }
void Read() override;
std::string GuildName;
};
class GuildGetInfo final : ClientPacket
{
public:
GuildGetInfo(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INFO, std::move(packet)) { }
void Read() override { }
};
class GuildInfoResponse final : ServerPacket
{
public:
GuildInfoResponse() : ServerPacket(SMSG_GUILD_INFO, 123) { }
WorldPacket const* Write() override;
std::string GuildName;
time_t CreateDate = time_t(0);
int32 NumMembers = 0;
int32 NumAccounts = 0;
};
class GuildGetRoster final : public ClientPacket
{
public:
GuildGetRoster(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ROSTER, std::move(packet)) { }
void Read() override { }
};
struct GuildRosterMemberData
{
ObjectGuid Guid;
int64 WeeklyXP = 0;
int64 TotalXP = 0;
int32 RankID = 0;
int32 AreaID = 0;
float LastSave = 0.0f;
std::string Name;
std::string Note;
std::string OfficerNote;
uint8 Status = 0;
uint8 Level = 0;
uint8 ClassID = 0;
uint8 Gender = 0;
};
struct GuildRankData
{
uint32 Flags = 0;
uint32 WithdrawGoldLimit = 0;
uint32 TabFlags[GUILD_BANK_MAX_TABS];
uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
};
class GuildRoster final : public ServerPacket
{
public:
GuildRoster() : ServerPacket(SMSG_GUILD_ROSTER, 4 + 4 + 4 + 4) { }
WorldPacket const* Write() override;
std::vector<GuildRosterMemberData> MemberData;
std::vector<GuildRankData> RankData;
std::string WelcomeText;
std::string InfoText;
};
class GuildUpdateMotdText final : public ClientPacket
{
public:
GuildUpdateMotdText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_MOTD, std::move(packet)) { }
void Read() override;
String<128, Strings::NoHyperlinks> MotdText;
};
class GuildCommandResult final : public ServerPacket
{
public:
GuildCommandResult() : ServerPacket(SMSG_GUILD_COMMAND_RESULT, 9) { }
WorldPacket const* Write() override;
std::string Name;
int32 Result = 0;
int32 Command = 0;
};
class AcceptGuildInvite final : public ClientPacket
{
public:
AcceptGuildInvite(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ACCEPT, std::move(packet)) { }
void Read() override { }
};
class GuildDeclineInvitation final : public ClientPacket
{
public:
GuildDeclineInvitation(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DECLINE, std::move(packet)) { }
void Read() override { }
};
class GuildInviteByName final : public ClientPacket
{
public:
GuildInviteByName(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INVITE, std::move(packet)) { }
void Read() override;
String<48> Name;
};
class GuildInvite final : public ServerPacket
{
public:
GuildInvite() : ServerPacket(SMSG_GUILD_INVITE, 144) { }
WorldPacket const* Write() override;
std::string InviterName;
std::string GuildName;
};
class GuildEvent final : public ServerPacket
{
public:
GuildEvent() : ServerPacket(SMSG_GUILD_EVENT) { }
WorldPacket const* Write() override;
uint8 Type = 0;
boost::container::static_vector<std::string_view, 3> Params;
ObjectGuid Guid;
};
struct GuildEventEntry
{
ObjectGuid PlayerGUID;
ObjectGuid OtherGUID;
uint8 TransactionType = 0;
uint8 RankID = 0;
uint32 TransactionDate = 0;
};
class GuildEventLogQuery final : public ClientPacket
{
public:
GuildEventLogQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_EVENT_LOG_QUERY, std::move(packet)) { }
void Read() override { }
};
class GuildEventLogQueryResults final : public ServerPacket
{
public:
GuildEventLogQueryResults() : ServerPacket(MSG_GUILD_EVENT_LOG_QUERY, 4) { }
WorldPacket const* Write() override;
std::vector<GuildEventEntry> Entry;
};
class GuildPermissionsQuery final : public ClientPacket
{
public:
GuildPermissionsQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_PERMISSIONS, std::move(packet)) { }
void Read() override { }
};
class GuildPermissionsQueryResults final : public ServerPacket
{
public:
struct GuildRankTabPermissions
{
int32 Flags = 0;
int32 WithdrawItemLimit = 0;
};
GuildPermissionsQueryResults() : ServerPacket(MSG_GUILD_PERMISSIONS, 20) { }
WorldPacket const* Write() override;
int8 NumTabs = 0;
int32 WithdrawGoldLimit = 0;
int32 Flags = 0;
uint32 RankID = 0;
std::array<GuildRankTabPermissions, GUILD_BANK_MAX_TABS> Tab;
};
class GuildSetRankPermissions final : public ClientPacket
{
public:
GuildSetRankPermissions(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_RANK, std::move(packet)) { }
void Read() override;
uint32 RankID = 0;
uint32 WithdrawGoldLimit = 0;
uint32 Flags = 0;
uint32 TabFlags[GUILD_BANK_MAX_TABS];
uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
String<15, Strings::NoHyperlinks> RankName;
};
class GuildAddRank final : public ClientPacket
{
public:
GuildAddRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_ADD_RANK, std::move(packet)) { }
void Read() override;
String<15, Strings::NoHyperlinks> Name;
};
class GuildDeleteRank final : public ClientPacket
{
public:
GuildDeleteRank(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DEL_RANK, std::move(packet)) { }
void Read() override { }
};
class GuildUpdateInfoText final : public ClientPacket
{
public:
GuildUpdateInfoText(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_INFO_TEXT, std::move(packet)) { }
void Read() override;
String<500, Strings::NoHyperlinks> InfoText;
};
class GuildSetMemberNote final : public ClientPacket
{
public:
GuildSetMemberNote(WorldPacket&& packet) : ClientPacket(std::move(packet)) { }
void Read() override;
std::string NoteeName;
String<31, Strings::NoHyperlinks> Note;
};
class GuildDelete final : public ClientPacket
{
public:
GuildDelete(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DISBAND, std::move(packet)) { }
void Read() override { }
};
class GuildDemoteMember final : public ClientPacket
{
public:
GuildDemoteMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_DEMOTE, std::move(packet)) { }
void Read() override;
std::string Demotee;
};
class GuildPromoteMember final : public ClientPacket
{
public:
GuildPromoteMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_PROMOTE, std::move(packet)) { }
void Read() override;
std::string Promotee;
};
class GuildOfficerRemoveMember : public ClientPacket
{
public:
GuildOfficerRemoveMember(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_REMOVE, std::move(packet)) { }
void Read() override;
std::string Removee;
};
class GuildLeave final : public ClientPacket
{
public:
GuildLeave(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_LEAVE, std::move(packet)) { }
void Read() override { }
};
class GuildBankActivate final : public ClientPacket
{
public:
GuildBankActivate(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANKER_ACTIVATE, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
bool FullUpdate = false;
};
class GuildBankBuyTab final : public ClientPacket
{
public:
GuildBankBuyTab(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_BUY_TAB, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
uint8 BankTab = 0;
};
class GuildBankUpdateTab final : public ClientPacket
{
public:
GuildBankUpdateTab(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_UPDATE_TAB, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
uint8 BankTab = 0;
String<16, Strings::NoHyperlinks> Name;
String<100> Icon;
};
class GuildBankDepositMoney final : public ClientPacket
{
public:
GuildBankDepositMoney(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_DEPOSIT_MONEY, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
uint32 Money = 0;
};
class GuildBankQueryTab final : public ClientPacket
{
public:
GuildBankQueryTab(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_QUERY_TAB, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
uint8 Tab = 0;
bool FullUpdate = false;
};
class GuildBankRemainingWithdrawMoneyQuery final : public ClientPacket
{
public:
GuildBankRemainingWithdrawMoneyQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_BANK_MONEY_WITHDRAWN, std::move(packet)) { }
void Read() override { }
};
class GuildBankRemainingWithdrawMoney final : public ServerPacket
{
public:
GuildBankRemainingWithdrawMoney() : ServerPacket(MSG_GUILD_BANK_MONEY_WITHDRAWN, 8) { }
WorldPacket const* Write() override;
int32 RemainingWithdrawMoney = 0;
};
class GuildBankWithdrawMoney final : public ClientPacket
{
public:
GuildBankWithdrawMoney(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_WITHDRAW_MONEY, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
uint32 Money = 0;
};
struct GuildBankSocketEnchant
{
uint8 SocketIndex = 0;
int32 SocketEnchantID = 0;
};
struct GuildBankItemInfo
{
uint32 ItemID = 0;
int32 RandomPropertiesSeed = 0;
int32 RandomPropertiesID = 0;
uint8 Slot = 0;
int32 Count = 0;
int32 EnchantmentID = 0;
int32 Charges = 0;
int32 Flags = 0;
std::vector<GuildBankSocketEnchant> SocketEnchant;
};
struct GuildBankTabInfo
{
std::string Name;
std::string Icon;
};
class GuildBankQueryResults final : public ServerPacket
{
public:
GuildBankQueryResults() : ServerPacket(SMSG_GUILD_BANK_LIST, 25) { }
WorldPacket const* Write() override;
std::vector<GuildBankItemInfo> ItemInfo;
std::vector<GuildBankTabInfo> TabInfo;
int32 WithdrawalsRemaining = 0;
uint8 Tab = 0;
uint64 Money = 0;
bool FullUpdate = false;
void SetWithdrawalsRemaining(int32 withdrawalsRemaining);
private:
std::size_t _withdrawalsRemainingPos = 0;
};
class GuildBankSwapItems final : public ClientPacket
{
public:
GuildBankSwapItems(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_SWAP_ITEMS, std::move(packet)) { }
void Read() override;
ObjectGuid Banker;
int32 StackCount = 0;
int32 BankItemCount = 0;
uint32 ItemID = 0;
uint32 ItemID1 = 0;
uint8 ToSlot = 0;
uint8 BankSlot = 0;
uint8 BankSlot1 = 0;
uint8 BankTab = 0;
uint8 BankTab1 = 0;
uint8 ContainerSlot = 0;
uint8 ContainerItemSlot = 0;
bool AutoStore = false;
bool BankOnly = false;
};
class GuildBankLogQuery final : public ClientPacket
{
public:
GuildBankLogQuery(WorldPacket&& packet) : ClientPacket(MSG_GUILD_BANK_LOG_QUERY, std::move(packet)) { }
void Read() override;
uint8 Tab = 0;
};
struct GuildBankLogEntry
{
ObjectGuid PlayerGUID;
uint32 TimeOffset = 0;
int8 EntryType = 0;
uint32 Money = 0;
int32 ItemID = 0;
int32 Count = 0;
int8 OtherTab = 0;
};
class GuildBankLogQueryResults final : public ServerPacket
{
public:
GuildBankLogQueryResults() : ServerPacket(MSG_GUILD_BANK_LOG_QUERY, 25) { }
WorldPacket const* Write() override;
uint8 Tab = 0;
std::vector<GuildBankLogEntry> Entry;
};
class GuildBankTextQuery final : public ClientPacket
{
public:
GuildBankTextQuery(WorldPacket&& packet) : ClientPacket(MSG_QUERY_GUILD_BANK_TEXT, std::move(packet)) { }
void Read() override;
uint8 Tab = 0;
};
class GuildBankTextQueryResult : public ServerPacket
{
public:
GuildBankTextQueryResult() : ServerPacket(MSG_QUERY_GUILD_BANK_TEXT, 4 + 2) { }
WorldPacket const* Write() override;
uint8 Tab = 0;
std::string Text;
};
class GuildBankSetTabText final : public ClientPacket
{
public:
GuildBankSetTabText(WorldPacket&& packet) : ClientPacket(CMSG_SET_GUILD_BANK_TEXT, std::move(packet)) { }
void Read() override;
uint8 Tab = 0;
String<500, Strings::NoHyperlinks> TabText;
};
class GuildSetGuildMaster final : public ClientPacket
{
public:
GuildSetGuildMaster(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_LEADER, std::move(packet)) { }
void Read() override;
std::string NewMasterName;
};
class SaveGuildEmblem final : public ClientPacket
{
public:
SaveGuildEmblem(WorldPacket&& packet) : ClientPacket(MSG_SAVE_GUILD_EMBLEM, std::move(packet)) { }
void Read() override;
ObjectGuid Vendor;
int32 BStyle = 0;
int32 EStyle = 0;
int32 BColor = 0;
int32 EColor = 0;
int32 Bg = 0;
};
class PlayerSaveGuildEmblem final : public ServerPacket
{
public:
PlayerSaveGuildEmblem() : ServerPacket(MSG_SAVE_GUILD_EMBLEM, 4) { }
WorldPacket const* Write() override;
int32 Error = 0;
};
}
}
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData);
ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData);
#endif // GuildPackets_h__