CypherCore/Source/Game/Networking/Packets/GuildPackets.cs

// Copyright (c) CypherCore <http://github.com/CypherCore> All rights reserved.
// Licensed under the GNU GENERAL PUBLIC LICENSE. See LICENSE file in the project root for full license information.

using Framework.Constants;
using Framework.Dynamic;
using Game.Entities;
using Game.Miscellaneous;
using System;
using System.Collections.Generic;

namespace Game.Networking.Packets
{
    public class QueryGuildInfo : ClientPacket
    {
        public QueryGuildInfo(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGuid = _worldPacket.ReadPackedGuid();
            PlayerGuid = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid GuildGuid;
        public ObjectGuid PlayerGuid;
    }

    public class QueryGuildInfoResponse : ServerPacket
    {
        public QueryGuildInfoResponse() : base(ServerOpcodes.QueryGuildInfoResponse) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(GuildGUID);
            _worldPacket.WriteBit(HasGuildInfo);
            _worldPacket.FlushBits();

            if (HasGuildInfo)
            {
                _worldPacket.WritePackedGuid(Info.GuildGuid);
                _worldPacket.WriteUInt32(Info.VirtualRealmAddress);
                _worldPacket.WriteInt32(Info.Ranks.Count);
                _worldPacket.WriteUInt32(Info.EmblemStyle);
                _worldPacket.WriteUInt32(Info.EmblemColor);
                _worldPacket.WriteUInt32(Info.BorderStyle);
                _worldPacket.WriteUInt32(Info.BorderColor);
                _worldPacket.WriteUInt32(Info.BackgroundColor);
                _worldPacket.WriteBits(Info.GuildName.GetByteCount(), 7);
                _worldPacket.FlushBits();

                foreach (var rank in Info.Ranks)
                {
                    _worldPacket.WriteUInt32(rank.RankID);
                    _worldPacket.WriteUInt32(rank.RankOrder);

                    _worldPacket.WriteBits(rank.RankName.GetByteCount(), 7);
                    _worldPacket.WriteString(rank.RankName);
                }

                _worldPacket.WriteString(Info.GuildName);
            }

        }

        public ObjectGuid GuildGUID;
        public GuildInfo Info = new();
        public bool HasGuildInfo;

        public class GuildInfo
        {
            public ObjectGuid GuildGuid;

            public uint VirtualRealmAddress; // a special identifier made from the Index, BattleGroup and Region.

            public uint EmblemStyle;
            public uint EmblemColor;
            public uint BorderStyle;
            public uint BorderColor;
            public uint BackgroundColor;
            public List<RankInfo> Ranks = new();
            public string GuildName = "";

            public struct RankInfo
            {
                public RankInfo(uint id, uint order, string name)
                {
                    RankID = id;
                    RankOrder = order;
                    RankName = name;
                }

                public uint RankID;
                public uint RankOrder;
                public string RankName;
            }
        }
    }

    public class GuildGetRoster : ClientPacket
    {
        public GuildGetRoster(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildRoster : ServerPacket
    {
        public GuildRoster() : base(ServerOpcodes.GuildRoster)
        {
            MemberData = new List<GuildRosterMemberData>();
        }

        public override void Write()
        {
            _worldPacket.WriteInt32(NumAccounts);
            CreateDate.Write(_worldPacket);
            _worldPacket.WriteInt32(GuildFlags);
            _worldPacket.WriteInt32(MemberData.Count);
            _worldPacket.WriteBits(WelcomeText.GetByteCount(), 11);
            _worldPacket.WriteBits(InfoText.GetByteCount(), 10);
            _worldPacket.FlushBits();

            MemberData.ForEach(p => p.Write(_worldPacket));

            _worldPacket.WriteString(WelcomeText);
            _worldPacket.WriteString(InfoText);
        }

        public List<GuildRosterMemberData> MemberData;
        public string WelcomeText;
        public string InfoText;
        public WowTime CreateDate;
        public int NumAccounts;
        public int GuildFlags;
    }

    public class GuildUpdateMotdText : ClientPacket
    {
        public GuildUpdateMotdText(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint textLen = _worldPacket.ReadBits<uint>(11);
            MotdText = _worldPacket.ReadString(textLen);
        }

        public string MotdText;
    }

    public class GuildCommandResult : ServerPacket
    {
        public GuildCommandResult() : base(ServerOpcodes.GuildCommandResult) { }

        public override void Write()
        {
            _worldPacket.WriteUInt8((byte)Result);
            _worldPacket.WriteUInt8((byte)Command);

            _worldPacket.WriteBits(Name.GetByteCount(), 8);
            _worldPacket.WriteString(Name);
        }

        public string Name;
        public GuildCommandError Result;
        public GuildCommandType Command;
    }

    public class AcceptGuildInvite : ClientPacket
    {
        public ObjectGuid GuildGuid;

        public AcceptGuildInvite(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGuid = _worldPacket.ReadPackedGuid();
        }
    }

    public class GuildDeclineInvitation : ClientPacket
    {
        public ObjectGuid GuildGuid;
        public bool IsAuto;

        public GuildDeclineInvitation(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGuid = _worldPacket.ReadPackedGuid();
            IsAuto = _worldPacket.HasBit();
        }
    }

    public class DeclineGuildInvites : ClientPacket
    {
        public DeclineGuildInvites(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Allow = _worldPacket.HasBit();
        }

        public bool Allow;
    }

    public class GuildInviteByName : ClientPacket
    {
        public GuildInviteByName(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint nameLen = _worldPacket.ReadBits<uint>(9);
            bool hasArenaTeam = _worldPacket.HasBit();

            Name = _worldPacket.ReadString(nameLen);

            if (hasArenaTeam)
                ArenaTeam = _worldPacket.ReadInt32();
        }

        public string Name;
        public int? ArenaTeam;
    }

    public class GuildInvite : ServerPacket
    {
        public GuildInvite() : base(ServerOpcodes.GuildInvite) { }

        public override void Write()
        {
            _worldPacket.WriteBits(InviterName.GetByteCount(), 6);
            _worldPacket.WriteBits(GuildName.GetByteCount(), 7);
            _worldPacket.WriteBits(OldGuildName.GetByteCount(), 7);

            _worldPacket.WriteUInt32(InviterVirtualRealmAddress);
            _worldPacket.WriteUInt32(GuildVirtualRealmAddress);
            _worldPacket.WritePackedGuid(GuildGUID);
            _worldPacket.WriteUInt32(OldGuildVirtualRealmAddress);
            _worldPacket.WritePackedGuid(OldGuildGUID);
            _worldPacket.WriteUInt32(EmblemStyle);
            _worldPacket.WriteUInt32(EmblemColor);
            _worldPacket.WriteUInt32(BorderStyle);
            _worldPacket.WriteUInt32(BorderColor);
            _worldPacket.WriteUInt32(Background);
            _worldPacket.WriteInt32(AchievementPoints);

            _worldPacket.WriteString(InviterName);
            _worldPacket.WriteString(GuildName);
            _worldPacket.WriteString(OldGuildName);
        }

        public ObjectGuid GuildGUID;
        public ObjectGuid OldGuildGUID;
        public int AchievementPoints;
        public uint EmblemColor;
        public uint EmblemStyle;
        public uint BorderStyle;
        public uint BorderColor;
        public uint Background;
        public uint GuildVirtualRealmAddress;
        public uint OldGuildVirtualRealmAddress;
        public uint InviterVirtualRealmAddress;
        public string InviterName;
        public string GuildName;
        public string OldGuildName;
    }

    public class GuildEventStatusChange : ServerPacket
    {
        public GuildEventStatusChange() : base(ServerOpcodes.GuildEventStatusChange) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(Guid);
            _worldPacket.WriteBit(AFK);
            _worldPacket.WriteBit(DND);
            _worldPacket.FlushBits();
        }

        public ObjectGuid Guid;
        public bool AFK;
        public bool DND;
    }

    public class GuildEventPresenceChange : ServerPacket
    {
        public GuildEventPresenceChange() : base(ServerOpcodes.GuildEventPresenceChange) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(Guid);
            _worldPacket.WriteUInt32(VirtualRealmAddress);

            _worldPacket.WriteBits(Name.GetByteCount(), 6);
            _worldPacket.WriteBit(LoggedOn);

            _worldPacket.WriteString(Name);
        }

        public ObjectGuid Guid;
        public uint VirtualRealmAddress;
        public string Name;
        public bool LoggedOn;
    }

    public class GuildEventMotd : ServerPacket
    {
        public GuildEventMotd() : base(ServerOpcodes.GuildEventMotd) { }

        public override void Write()
        {
            _worldPacket.WriteBits(MotdText.GetByteCount(), 11);
            _worldPacket.WriteString(MotdText);
        }

        public string MotdText;
    }

    public class GuildEventPlayerJoined : ServerPacket
    {
        public GuildEventPlayerJoined() : base(ServerOpcodes.GuildEventPlayerJoined) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(Guid);
            _worldPacket.WriteUInt32(VirtualRealmAddress);

            _worldPacket.WriteBits(Name.GetByteCount(), 6);
            _worldPacket.WriteString(Name);
        }

        public ObjectGuid Guid;
        public string Name;
        public uint VirtualRealmAddress;
    }

    public class GuildEventRankChanged : ServerPacket
    {
        public GuildEventRankChanged() : base(ServerOpcodes.GuildEventRankChanged) { }

        public override void Write()
        {
            _worldPacket.WriteUInt32(RankID);
        }

        public uint RankID;
    }

    public class GuildEventRanksUpdated : ServerPacket
    {
        public GuildEventRanksUpdated() : base(ServerOpcodes.GuildEventRanksUpdated) { }

        public override void Write() { }
    }

    public class GuildEventBankMoneyChanged : ServerPacket
    {
        public GuildEventBankMoneyChanged() : base(ServerOpcodes.GuildEventBankMoneyChanged) { }

        public override void Write()
        {
            _worldPacket.WriteUInt64(Money);
        }

        public ulong Money;
    }

    public class GuildEventDisbanded : ServerPacket
    {
        public GuildEventDisbanded() : base(ServerOpcodes.GuildEventDisbanded) { }

        public override void Write() { }
    }

    public class GuildEventLogQuery : ClientPacket
    {
        public GuildEventLogQuery(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildEventLogQueryResults : ServerPacket
    {
        public GuildEventLogQueryResults() : base(ServerOpcodes.GuildEventLogQueryResults)
        {
            Entry = new List<GuildEventEntry>();
        }

        public override void Write()
        {
            _worldPacket.WriteInt32(Entry.Count);

            foreach (GuildEventEntry entry in Entry)
            {
                _worldPacket.WritePackedGuid(entry.PlayerGUID);
                _worldPacket.WritePackedGuid(entry.OtherGUID);
                _worldPacket.WriteUInt8(entry.TransactionType);
                _worldPacket.WriteUInt8(entry.RankID);
                _worldPacket.WriteUInt32(entry.TransactionDate);
            }
        }

        public List<GuildEventEntry> Entry;
    }

    public class GuildEventPlayerLeft : ServerPacket
    {
        public GuildEventPlayerLeft() : base(ServerOpcodes.GuildEventPlayerLeft) { }

        public override void Write()
        {
            _worldPacket.WriteBit(Removed);
            _worldPacket.WriteBits(LeaverName.GetByteCount(), 6);

            if (Removed)
            {
                _worldPacket.WriteBits(RemoverName.GetByteCount(), 6);
                _worldPacket.WritePackedGuid(RemoverGUID);
                _worldPacket.WriteUInt32(RemoverVirtualRealmAddress);
                _worldPacket.WriteString(RemoverName);
            }

            _worldPacket.WritePackedGuid(LeaverGUID);
            _worldPacket.WriteUInt32(LeaverVirtualRealmAddress);
            _worldPacket.WriteString(LeaverName);
        }

        public ObjectGuid LeaverGUID;
        public string LeaverName;
        public uint LeaverVirtualRealmAddress;
        public ObjectGuid RemoverGUID;
        public string RemoverName;
        public uint RemoverVirtualRealmAddress;
        public bool Removed;
    }

    public class GuildEventNewLeader : ServerPacket
    {
        public GuildEventNewLeader() : base(ServerOpcodes.GuildEventNewLeader) { }

        public override void Write()
        {
            _worldPacket.WriteBit(SelfPromoted);
            _worldPacket.WriteBits(OldLeaderName.GetByteCount(), 6);
            _worldPacket.WriteBits(NewLeaderName.GetByteCount(), 6);

            _worldPacket.WritePackedGuid(OldLeaderGUID);
            _worldPacket.WriteUInt32(OldLeaderVirtualRealmAddress);
            _worldPacket.WritePackedGuid(NewLeaderGUID);
            _worldPacket.WriteUInt32(NewLeaderVirtualRealmAddress);

            _worldPacket.WriteString(OldLeaderName);
            _worldPacket.WriteString(NewLeaderName);
        }

        public ObjectGuid NewLeaderGUID;
        public string NewLeaderName;
        public uint NewLeaderVirtualRealmAddress;
        public ObjectGuid OldLeaderGUID;
        public string OldLeaderName = "";
        public uint OldLeaderVirtualRealmAddress;
        public bool SelfPromoted;
    }

    public class GuildEventTabAdded : ServerPacket
    {
        public GuildEventTabAdded() : base(ServerOpcodes.GuildEventTabAdded) { }

        public override void Write() { }
    }

    public class GuildEventTabModified : ServerPacket
    {
        public GuildEventTabModified() : base(ServerOpcodes.GuildEventTabModified) { }

        public override void Write()
        {
            _worldPacket.WriteInt32(Tab);

            _worldPacket.WriteBits(Name.GetByteCount(), 7);
            _worldPacket.WriteBits(Icon.GetByteCount(), 9);
            _worldPacket.FlushBits();

            _worldPacket.WriteString(Name);
            _worldPacket.WriteString(Icon);
        }

        public string Icon;
        public string Name;
        public int Tab;
    }

    public class GuildEventTabTextChanged : ServerPacket
    {
        public GuildEventTabTextChanged() : base(ServerOpcodes.GuildEventTabTextChanged) { }

        public override void Write()
        {
            _worldPacket.WriteInt32(Tab);
        }

        public int Tab;
    }

    public class GuildEventBankContentsChanged : ServerPacket
    {
        public GuildEventBankContentsChanged() : base(ServerOpcodes.GuildEventBankContentsChanged) { }

        public override void Write() { }
    }

    public class GuildPermissionsQuery : ClientPacket
    {
        public GuildPermissionsQuery(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildPermissionsQueryResults : ServerPacket
    {
        public GuildPermissionsQueryResults() : base(ServerOpcodes.GuildPermissionsQueryResults)
        {
            Tab = new List<GuildRankTabPermissions>();
        }

        public override void Write()
        {
            _worldPacket.WriteUInt32(RankID);
            _worldPacket.WriteInt32(Flags);
            _worldPacket.WriteInt32(WithdrawGoldLimit);
            _worldPacket.WriteInt32(NumTabs);
            _worldPacket.WriteInt32(Tab.Count);

            foreach (GuildRankTabPermissions tab in Tab)
            {
                _worldPacket.WriteInt32(tab.Flags);
                _worldPacket.WriteInt32(tab.WithdrawItemLimit);
            }
        }

        public int NumTabs;
        public int WithdrawGoldLimit;
        public int Flags;
        public uint RankID;
        public List<GuildRankTabPermissions> Tab;

        public struct GuildRankTabPermissions
        {
            public int Flags;
            public int WithdrawItemLimit;
        }
    }

    public class GuildSetRankPermissions : ClientPacket
    {
        public GuildSetRankPermissions(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            RankID = _worldPacket.ReadUInt8();
            RankOrder = _worldPacket.ReadInt32();
            Flags = _worldPacket.ReadUInt32();
            WithdrawGoldLimit = _worldPacket.ReadUInt32();

            for (byte i = 0; i < GuildConst.MaxBankTabs; i++)
            {
                TabFlags[i] = _worldPacket.ReadUInt32();
                TabWithdrawItemLimit[i] = _worldPacket.ReadUInt32();
            }

            _worldPacket.ResetBitPos();
            uint rankNameLen = _worldPacket.ReadBits<uint>(7);

            RankName = _worldPacket.ReadString(rankNameLen);

            OldFlags = _worldPacket.ReadUInt32();
        }

        public byte RankID;
        public int RankOrder;
        public uint WithdrawGoldLimit;
        public uint Flags;
        public uint OldFlags;
        public uint[] TabFlags = new uint[GuildConst.MaxBankTabs];
        public uint[] TabWithdrawItemLimit = new uint[GuildConst.MaxBankTabs];
        public string RankName;
    }

    public class GuildAddRank : ClientPacket
    {
        public GuildAddRank(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint nameLen = _worldPacket.ReadBits<uint>(7);
            _worldPacket.ResetBitPos();

            RankOrder = _worldPacket.ReadInt32();
            Name = _worldPacket.ReadString(nameLen);
        }

        public string Name;
        public int RankOrder;
    }

    public class GuildAssignMemberRank : ClientPacket
    {
        public GuildAssignMemberRank(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Member = _worldPacket.ReadPackedGuid();
            RankOrder = _worldPacket.ReadInt32();
        }

        public ObjectGuid Member;
        public int RankOrder;
    }

    public class GuildDeleteRank : ClientPacket
    {
        public GuildDeleteRank(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            RankOrder = _worldPacket.ReadInt32();
        }

        public int RankOrder;
    }

    public class GuildGetRanks : ClientPacket
    {
        public GuildGetRanks(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGUID = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid GuildGUID;
    }

    public class GuildRanks : ServerPacket
    {
        public GuildRanks() : base(ServerOpcodes.GuildRanks)
        {
            Ranks = new List<GuildRankData>();
        }

        public override void Write()
        {
            _worldPacket.WriteInt32(Ranks.Count);

            Ranks.ForEach(p => p.Write(_worldPacket));
        }

        public List<GuildRankData> Ranks;
    }

    public class GuildSendRankChange : ServerPacket
    {
        public GuildSendRankChange() : base(ServerOpcodes.GuildSendRankChange) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(Officer);
            _worldPacket.WritePackedGuid(Other);
            _worldPacket.WriteUInt32(RankID);

            _worldPacket.WriteBit(Promote);
            _worldPacket.FlushBits();
        }

        public ObjectGuid Other;
        public ObjectGuid Officer;
        public bool Promote;
        public uint RankID;
    }

    public class GuildShiftRank : ClientPacket
    {
        public GuildShiftRank(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            RankOrder = _worldPacket.ReadInt32();
            ShiftUp = _worldPacket.HasBit();
        }

        public bool ShiftUp;
        public int RankOrder;
    }

    public class GuildUpdateInfoText : ClientPacket
    {
        public GuildUpdateInfoText(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint textLen = _worldPacket.ReadBits<uint>(11);
            InfoText = _worldPacket.ReadString(textLen);
        }

        public string InfoText;
    }

    public class GuildSetMemberNote : ClientPacket
    {
        public GuildSetMemberNote(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            NoteeGUID = _worldPacket.ReadPackedGuid();

            uint noteLen = _worldPacket.ReadBits<uint>(8);
            IsPublic = _worldPacket.HasBit();

            Note = _worldPacket.ReadString(noteLen);
        }

        public ObjectGuid NoteeGUID;
        public bool IsPublic;          // 0 == Officer, 1 == Public
        public string Note;
    }

    public class GuildMemberUpdateNote : ServerPacket
    {
        public GuildMemberUpdateNote() : base(ServerOpcodes.GuildMemberUpdateNote) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(Member);

            _worldPacket.WriteBits(Note.GetByteCount(), 8);
            _worldPacket.WriteBit(IsPublic);
            _worldPacket.FlushBits();

            _worldPacket.WriteString(Note);
        }

        public ObjectGuid Member;
        public bool IsPublic;          // 0 == Officer, 1 == Public
        public string Note;
    }

    public class GuildMemberDailyReset : ServerPacket
    {
        public GuildMemberDailyReset() : base(ServerOpcodes.GuildMemberDailyReset) { }

        public override void Write() { }
    }

    public class GuildDelete : ClientPacket
    {
        public GuildDelete(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildDemoteMember : ClientPacket
    {
        public GuildDemoteMember(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Demotee = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid Demotee;
    }

    public class GuildPromoteMember : ClientPacket
    {
        public GuildPromoteMember(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Promotee = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid Promotee;
    }

    public class GuildOfficerRemoveMember : ClientPacket
    {
        public GuildOfficerRemoveMember(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Removee = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid Removee;
    }

    public class GuildLeave : ClientPacket
    {
        public GuildLeave(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildChangeNameRequest : ClientPacket
    {
        public GuildChangeNameRequest(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint nameLen = _worldPacket.ReadBits<uint>(7);
            NewName = _worldPacket.ReadString(nameLen);
        }

        public string NewName;
    }

    public class GuildFlaggedForRename : ServerPacket
    {
        public GuildFlaggedForRename() : base(ServerOpcodes.GuildFlaggedForRename) { }

        public override void Write()
        {
            _worldPacket.WriteBit(FlagSet);
        }

        public bool FlagSet;
    }

    public class RequestGuildPartyState : ClientPacket
    {
        public RequestGuildPartyState(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGUID = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid GuildGUID;
    }

    public class GuildPartyState : ServerPacket
    {
        public GuildPartyState() : base(ServerOpcodes.GuildPartyState, ConnectionType.Instance) { }

        public override void Write()
        {
            _worldPacket.WriteInt32(NumMembers);
            _worldPacket.WriteInt32(NumRequired);
            _worldPacket.WriteFloat(GuildXPEarnedMult);
            _worldPacket.WriteBit(InGuildParty);
            _worldPacket.FlushBits();
        }

        public float GuildXPEarnedMult = 0.0f;
        public int NumMembers;
        public int NumRequired;
        public bool InGuildParty;
    }

    public class RequestGuildRewardsList : ClientPacket
    {
        public RequestGuildRewardsList(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            CurrentVersion = _worldPacket.ReadInt64();
        }

        public long CurrentVersion;
    }

    public class GuildRewardList : ServerPacket
    {
        public GuildRewardList() : base(ServerOpcodes.GuildRewardList)
        {
            RewardItems = new List<GuildRewardItem>();
        }

        public override void Write()
        {
            _worldPacket.WriteInt64(Version);
            _worldPacket.WriteInt32(RewardItems.Count);

            foreach (var item in RewardItems)
                item.Write(_worldPacket);
        }

        public List<GuildRewardItem> RewardItems;
        public long Version;
    }

    public class GuildBankActivate : ClientPacket
    {
        public GuildBankActivate(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            FullUpdate = _worldPacket.HasBit();
        }

        public ObjectGuid Banker;
        public bool FullUpdate;
    }

    public class GuildBankBuyTab : ClientPacket
    {
        public GuildBankBuyTab(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
    }

    public class GuildBankUpdateTab : ClientPacket
    {
        public GuildBankUpdateTab(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();

            _worldPacket.ResetBitPos();
            uint nameLen = _worldPacket.ReadBits<uint>(7);
            uint iconLen = _worldPacket.ReadBits<uint>(9);

            Name = _worldPacket.ReadString(nameLen);
            Icon = _worldPacket.ReadString(iconLen);
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public string Name;
        public string Icon;
    }

    public class GuildBankDepositMoney : ClientPacket
    {
        public GuildBankDepositMoney(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            Money = _worldPacket.ReadUInt64();
        }

        public ObjectGuid Banker;
        public ulong Money;
    }

    public class GuildBankQueryTab : ClientPacket
    {
        public GuildBankQueryTab(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            Tab = _worldPacket.ReadUInt8();

            FullUpdate = _worldPacket.HasBit();
        }

        public ObjectGuid Banker;
        public byte Tab;
        public bool FullUpdate;
    }

    public class GuildBankRemainingWithdrawMoneyQuery : ClientPacket
    {
        public GuildBankRemainingWithdrawMoneyQuery(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildBankRemainingWithdrawMoney : ServerPacket
    {
        public GuildBankRemainingWithdrawMoney() : base(ServerOpcodes.GuildBankRemainingWithdrawMoney) { }

        public override void Write()
        {
            _worldPacket.WriteInt64(RemainingWithdrawMoney);
        }

        public long RemainingWithdrawMoney;
    }

    public class GuildBankWithdrawMoney : ClientPacket
    {
        public GuildBankWithdrawMoney(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            Money = _worldPacket.ReadUInt64();
        }

        public ObjectGuid Banker;
        public ulong Money;
    }

    public class GuildBankQueryResults : ServerPacket
    {
        public GuildBankQueryResults() : base(ServerOpcodes.GuildBankQueryResults)
        {
            ItemInfo = new List<GuildBankItemInfo>();
            TabInfo = new List<GuildBankTabInfo>();
        }

        public override void Write()
        {
            _worldPacket.WriteUInt64(Money);
            _worldPacket.WriteInt32(Tab);
            _worldPacket.WriteInt32(WithdrawalsRemaining);
            _worldPacket.WriteInt32(TabInfo.Count);
            _worldPacket.WriteInt32(ItemInfo.Count);
            _worldPacket.WriteBit(FullUpdate);
            _worldPacket.FlushBits();

            foreach (GuildBankTabInfo tab in TabInfo)
            {
                _worldPacket.WriteInt32(tab.TabIndex);
                _worldPacket.WriteBits(tab.Name.GetByteCount(), 7);
                _worldPacket.WriteBits(tab.Icon.GetByteCount(), 9);

                _worldPacket.WriteString(tab.Name);
                _worldPacket.WriteString(tab.Icon);
            }

            foreach (GuildBankItemInfo item in ItemInfo)
            {
                _worldPacket.WriteInt32(item.Slot);
                _worldPacket.WriteInt32(item.Count);
                _worldPacket.WriteInt32(item.EnchantmentID);
                _worldPacket.WriteInt32(item.Charges);
                _worldPacket.WriteInt32(item.OnUseEnchantmentID);
                _worldPacket.WriteUInt32(item.Flags);

                item.Item.Write(_worldPacket);

                _worldPacket.WriteBits(item.SocketEnchant.Count, 2);
                _worldPacket.WriteBit(item.Locked);
                _worldPacket.FlushBits();

                foreach (ItemGemData socketEnchant in item.SocketEnchant)
                    socketEnchant.Write(_worldPacket);
            }
        }

        public List<GuildBankItemInfo> ItemInfo;
        public List<GuildBankTabInfo> TabInfo;
        public int WithdrawalsRemaining;
        public int Tab;
        public ulong Money;
        public bool FullUpdate;
    }

    class AutoGuildBankItem : ClientPacket
    {
        public AutoGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
    }

    class StoreGuildBankItem : ClientPacket
    {
        public StoreGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
    }

    class SwapItemWithGuildBankItem : ClientPacket
    {
        public SwapItemWithGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
    }

    class SwapGuildBankItemWithGuildBankItem : ClientPacket
    {
        public SwapGuildBankItemWithGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab[0] = _worldPacket.ReadUInt8();
            BankSlot[0] = _worldPacket.ReadUInt8();
            BankTab[1] = _worldPacket.ReadUInt8();
            BankSlot[1] = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte[] BankTab = new byte[2];
        public byte[] BankSlot = new byte[2];
    }

    class MoveGuildBankItem : ClientPacket
    {
        public MoveGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            BankTab1 = _worldPacket.ReadUInt8();
            BankSlot1 = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte BankTab1;
        public byte BankSlot1;
    }

    class MergeItemWithGuildBankItem : ClientPacket
    {
        public MergeItemWithGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();
            StackCount = _worldPacket.ReadUInt32();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
        public uint StackCount;
    }

    class SplitItemToGuildBank : ClientPacket
    {
        public SplitItemToGuildBank(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();
            StackCount = _worldPacket.ReadUInt32();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
        public uint StackCount;
    }

    class MergeGuildBankItemWithItem : ClientPacket
    {
        public MergeGuildBankItemWithItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();
            StackCount = _worldPacket.ReadUInt32();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
        public uint StackCount;
    }

    class SplitGuildBankItemToInventory : ClientPacket
    {
        public SplitGuildBankItemToInventory(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            ContainerItemSlot = _worldPacket.ReadUInt8();
            StackCount = _worldPacket.ReadUInt32();

            if (_worldPacket.HasBit())
                ContainerSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte? ContainerSlot;
        public byte ContainerItemSlot;
        public uint StackCount;
    }

    class AutoStoreGuildBankItem : ClientPacket
    {
        public AutoStoreGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
    }

    class MergeGuildBankItemWithGuildBankItem : ClientPacket
    {
        public MergeGuildBankItemWithGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            BankTab1 = _worldPacket.ReadUInt8();
            BankSlot1 = _worldPacket.ReadUInt8();
            StackCount = _worldPacket.ReadUInt32();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte BankTab1;
        public byte BankSlot1;
        public uint StackCount;
    }

    class SplitGuildBankItem : ClientPacket
    {
        public SplitGuildBankItem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Banker = _worldPacket.ReadPackedGuid();
            BankTab = _worldPacket.ReadUInt8();
            BankSlot = _worldPacket.ReadUInt8();
            BankTab1 = _worldPacket.ReadUInt8();
            BankSlot1 = _worldPacket.ReadUInt8();
            StackCount = _worldPacket.ReadUInt32();
        }

        public ObjectGuid Banker;
        public byte BankTab;
        public byte BankSlot;
        public byte BankTab1;
        public byte BankSlot1;
        public uint StackCount;
    }
    public class GuildBankLogQuery : ClientPacket
    {
        public GuildBankLogQuery(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Tab = _worldPacket.ReadInt32();
        }

        public int Tab;
    }

    public class GuildBankLogQueryResults : ServerPacket
    {
        public GuildBankLogQueryResults() : base(ServerOpcodes.GuildBankLogQueryResults)
        {
            Entry = new List<GuildBankLogEntry>();
        }

        public override void Write()
        {
            _worldPacket.WriteInt32(Tab);
            _worldPacket.WriteInt32(Entry.Count);
            _worldPacket.WriteBit(WeeklyBonusMoney.HasValue);
            _worldPacket.FlushBits();

            foreach (GuildBankLogEntry logEntry in Entry)
            {
                _worldPacket.WritePackedGuid(logEntry.PlayerGUID);
                _worldPacket.WriteUInt32(logEntry.TimeOffset);
                _worldPacket.WriteInt8(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.WriteUInt64(logEntry.Money.Value);

                if (logEntry.ItemID.HasValue)
                    _worldPacket.WriteInt32(logEntry.ItemID.Value);

                if (logEntry.Count.HasValue)
                    _worldPacket.WriteInt32(logEntry.Count.Value);

                if (logEntry.OtherTab.HasValue)
                    _worldPacket.WriteInt8(logEntry.OtherTab.Value);
            }

            if (WeeklyBonusMoney.HasValue)
                _worldPacket.WriteUInt64(WeeklyBonusMoney.Value);
        }

        public int Tab;
        public List<GuildBankLogEntry> Entry;
        public ulong? WeeklyBonusMoney;
    }

    public class GuildBankTextQuery : ClientPacket
    {
        public GuildBankTextQuery(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Tab = _worldPacket.ReadInt32();
        }

        public int Tab;
    }

    public class GuildBankTextQueryResult : ServerPacket
    {
        public GuildBankTextQueryResult() : base(ServerOpcodes.GuildBankTextQueryResult) { }

        public override void Write()
        {
            _worldPacket.WriteInt32(Tab);

            _worldPacket.WriteBits(Text.GetByteCount(), 14);
            _worldPacket.WriteString(Text);
        }

        public int Tab;
        public string Text;
    }

    public class GuildBankSetTabText : ClientPacket
    {
        public GuildBankSetTabText(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Tab = _worldPacket.ReadInt32();
            TabText = _worldPacket.ReadString(_worldPacket.ReadBits<uint>(14));
        }

        public int Tab;
        public string TabText;
    }

    public class GuildQueryNews : ClientPacket
    {
        public GuildQueryNews(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGUID = _worldPacket.ReadPackedGuid();
        }

        public ObjectGuid GuildGUID;
    }

    public class GuildNewsPkt : ServerPacket
    {
        public GuildNewsPkt() : base(ServerOpcodes.GuildNews)
        {
            NewsEvents = new List<GuildNewsEvent>();
        }

        public override void Write()
        {
            _worldPacket.WriteInt32(NewsEvents.Count);
            foreach (var newsEvent in NewsEvents)
                newsEvent.Write(_worldPacket);
        }

        public List<GuildNewsEvent> NewsEvents;
    }

    public class GuildNewsUpdateSticky : ClientPacket
    {
        public GuildNewsUpdateSticky(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            GuildGUID = _worldPacket.ReadPackedGuid();
            NewsID = _worldPacket.ReadInt32();

            Sticky = _worldPacket.HasBit();
        }

        public int NewsID;
        public ObjectGuid GuildGUID;
        public bool Sticky;
    }

    class GuildReplaceGuildMaster : ClientPacket
    {
        public GuildReplaceGuildMaster(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildSetGuildMaster : ClientPacket
    {
        public GuildSetGuildMaster(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint nameLen = _worldPacket.ReadBits<uint>(9);
            NewMasterName = _worldPacket.ReadString(nameLen);
        }

        public string NewMasterName;
    }

    public class GuildChallengeUpdateRequest : ClientPacket
    {
        public GuildChallengeUpdateRequest(WorldPacket packet) : base(packet) { }

        public override void Read() { }
    }

    public class GuildChallengeUpdate : ServerPacket
    {
        public GuildChallengeUpdate() : base(ServerOpcodes.GuildChallengeUpdate) { }

        public override void Write()
        {
            for (int i = 0; i < GuildConst.ChallengesTypes; ++i)
                _worldPacket.WriteInt32(CurrentCount[i]);

            for (int i = 0; i < GuildConst.ChallengesTypes; ++i)
                _worldPacket.WriteInt32(MaxCount[i]);

            for (int i = 0; i < GuildConst.ChallengesTypes; ++i)
                _worldPacket.WriteInt32(MaxLevelGold[i]);

            for (int i = 0; i < GuildConst.ChallengesTypes; ++i)
                _worldPacket.WriteInt32(Gold[i]);
        }

        public int[] CurrentCount = new int[GuildConst.ChallengesTypes];
        public int[] MaxCount = new int[GuildConst.ChallengesTypes];
        public int[] Gold = new int[GuildConst.ChallengesTypes];
        public int[] MaxLevelGold = new int[GuildConst.ChallengesTypes];
    }

    public class SaveGuildEmblem : ClientPacket
    {
        public SaveGuildEmblem(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            Vendor = _worldPacket.ReadPackedGuid();
            EStyle = _worldPacket.ReadUInt32();
            EColor = _worldPacket.ReadUInt32();
            BStyle = _worldPacket.ReadUInt32();
            BColor = _worldPacket.ReadUInt32();
            Bg = _worldPacket.ReadUInt32();
        }

        public ObjectGuid Vendor;
        public uint BStyle;
        public uint EStyle;
        public uint BColor;
        public uint EColor;
        public uint Bg;
    }

    public class PlayerSaveGuildEmblem : ServerPacket
    {
        public PlayerSaveGuildEmblem() : base(ServerOpcodes.PlayerSaveGuildEmblem) { }

        public override void Write()
        {
            _worldPacket.WriteUInt32((uint)Error);
        }

        public GuildEmblemError Error;
    }

    class GuildSetAchievementTracking : ClientPacket
    {
        public GuildSetAchievementTracking(WorldPacket packet) : base(packet) { }

        public override void Read()
        {
            uint count = _worldPacket.ReadUInt32();

            for (uint i = 0; i < count; ++i)
                AchievementIDs.Add(_worldPacket.ReadUInt32());
        }

        public List<uint> AchievementIDs = new();
    }

    class GuildNameChanged : ServerPacket
    {
        public GuildNameChanged() : base(ServerOpcodes.GuildNameChanged) { }

        public override void Write()
        {
            _worldPacket.WritePackedGuid(GuildGUID);
            _worldPacket.WriteBits(GuildName.GetByteCount(), 7);
            _worldPacket.FlushBits();
            _worldPacket.WriteString(GuildName);
        }

        public ObjectGuid GuildGUID;
        public string GuildName;
    }

    //Structs
    public struct GuildRosterProfessionData
    {
        public void Write(WorldPacket data)
        {
            data.WriteInt32(DbID);
            data.WriteInt32(Rank);
            data.WriteInt32(Step);
        }

        public int DbID;
        public int Rank;
        public int Step;
    }

    public class GuildRosterMemberData
    {
        public void Write(WorldPacket data)
        {
            data.WritePackedGuid(Guid);
            data.WriteInt32(RankID);
            data.WriteInt32(AreaID);
            data.WriteInt32(PersonalAchievementPoints);
            data.WriteInt32(GuildReputation);
            data.WriteFloat(LastSave);

            for (byte i = 0; i < 2; i++)
                Profession[i].Write(data);

            data.WriteUInt32(VirtualRealmAddress);
            data.WriteUInt8(Status);
            data.WriteUInt8(Level);
            data.WriteUInt8(ClassID);
            data.WriteUInt8(Gender);
            data.WriteUInt64(GuildClubMemberID);
            data.WriteUInt8(RaceID);
            data.WriteInt32(TimerunningSeasonID);

            data.WriteBits(Name.GetByteCount(), 6);
            data.WriteBits(Note.GetByteCount(), 8);
            data.WriteBits(OfficerNote.GetByteCount(), 8);
            data.WriteBit(Authenticated);
            data.FlushBits();

            DungeonScore.Write(data);

            data.WriteString(Name);
            data.WriteString(Note);
            data.WriteString(OfficerNote);
        }

        public ObjectGuid Guid;
        public long WeeklyXP;
        public long TotalXP;
        public int RankID;
        public int AreaID;
        public int PersonalAchievementPoints;
        public int GuildReputation;
        public int GuildRepToCap;
        public float LastSave;
        public string Name;
        public uint VirtualRealmAddress;
        public string Note;
        public string OfficerNote;
        public byte Status;
        public byte Level;
        public byte ClassID;
        public byte Gender;
        public ulong GuildClubMemberID;
        public byte RaceID;
        public int TimerunningSeasonID;
        public bool Authenticated;
        public GuildRosterProfessionData[] Profession = new GuildRosterProfessionData[2];
        public DungeonScoreSummary DungeonScore = new();
    }

    public class GuildEventEntry
    {
        public ObjectGuid PlayerGUID;
        public ObjectGuid OtherGUID;
        public byte TransactionType;
        public byte RankID;
        public uint TransactionDate;
    }

    public class GuildRankData
    {
        public void Write(WorldPacket data)
        {
            data.WriteUInt8(RankID);
            data.WriteUInt32(RankOrder);
            data.WriteUInt32(Flags);
            data.WriteUInt32(WithdrawGoldLimit);

            for (byte i = 0; i < GuildConst.MaxBankTabs; i++)
            {
                data.WriteUInt32(TabFlags[i]);
                data.WriteUInt32(TabWithdrawItemLimit[i]);
            }

            data.WriteBits(RankName.GetByteCount(), 7);
            data.WriteString(RankName);
        }

        public byte RankID;
        public uint RankOrder;
        public uint Flags;
        public uint WithdrawGoldLimit;
        public string RankName;
        public uint[] TabFlags = new uint[GuildConst.MaxBankTabs];
        public uint[] TabWithdrawItemLimit = new uint[GuildConst.MaxBankTabs];
    }

    public class GuildRewardItem
    {
        public uint ItemID;
        public uint AchievementLogic;
        public List<uint> AchievementsRequired = new();
        public RaceMask<ulong> RaceMask;
        public int MinGuildLevel;
        public int MinGuildRep;
        public ulong Cost;

        public void Write(WorldPacket data)
        {
            data.WriteUInt32(ItemID);
            data.WriteUInt32(AchievementLogic);
            data.WriteInt32(AchievementsRequired.Count);
            data.WriteUInt64(RaceMask.RawValue);
            data.WriteInt32(MinGuildLevel);
            data.WriteInt32(MinGuildRep);
            data.WriteUInt64(Cost);

            foreach (var achievementId in AchievementsRequired)
                data.WriteUInt32(achievementId);
        }
    }

    public class GuildBankItemInfo
    {
        public ItemInstance Item = new();
        public int Slot;
        public int Count;
        public int EnchantmentID;
        public int Charges;
        public int OnUseEnchantmentID;
        public uint Flags;
        public bool Locked;
        public List<ItemGemData> SocketEnchant = new();
    }

    public struct GuildBankTabInfo
    {
        public int TabIndex;
        public string Name;
        public string Icon;
    }

    public class GuildBankLogEntry
    {
        public ObjectGuid PlayerGUID;
        public uint TimeOffset;
        public sbyte EntryType;
        public ulong? Money;
        public int? ItemID;
        public int? Count;
        public sbyte? OtherTab;
    }

    public class GuildNewsEvent
    {
        public void Write(WorldPacket data)
        {
            data.WriteInt32(Id);
            CompletedDate.Write(data);
            data.WriteInt8(Type);
            data.WriteInt32(Flags);

            for (byte i = 0; i < 2; i++)
                data.WriteInt32(Data[i]);

            data.WritePackedGuid(MemberGuid);
            data.WriteInt32(MemberList.Count);

            foreach (ObjectGuid memberGuid in MemberList)
                data.WritePackedGuid(memberGuid);

            data.WriteBit(Item != null);
            data.FlushBits();

            if (Item != null)
                Item.Write(data);
        }

        public int Id;
        public WowTime CompletedDate;
        public sbyte Type;
        public int Flags;
        public int[] Data = new int[2];
        public ObjectGuid MemberGuid;
        public List<ObjectGuid> MemberList = new();
        public ItemInstance Item;
    }
}