Guild issue

04/01/2024 23:26 denominator#1
So here is my issue, I create a guild then close the server and it saves in database then I start the server back up and login and my character is no longer in the guild? Guild is still in database and say my character is guild leader but my character says different.
04/01/2024 23:34 Spirited#2
Are you sending guild information on login?
04/02/2024 01:15 denominator#3
Seems to be
04/02/2024 05:11 pintinho12#4
Are you loading guild information on login?
Are you sending the guild information on login?
- MsgSyndicateAttributeInfo
- MsgSyndicate
- MsgName
Are all packets correct?
04/02/2024 22:26 denominator#5
Code:
using System;
using System.Collections.Generic;

namespace COServer.Network.GamePackets
{
    public unsafe class MsgName : Writer, Interfaces.IPacket
    {
        byte[] Packet;
        public const byte
            None = 0,
            Fireworks = 1,
            CreateSyn = 2,
            GuildName = 3,
            ChangeTitle = 4,
            DeleteRole = 5,
            Spouse = 6,
            QueryNPC = 7,
            Wanted = 8,
            MapEffect = 9,
            Effect = 10,
            GuildList = 11,
            KickOut_SynMem = 12,
            QueryWanted = 13,
            QueryPoliceWanted = 14,
            PoliceWanted = 15,
            QuerySpouse = 16,
            BeginGamble = 17,
            EndGamble = 18,
            BonusGamble = 19,
            Sound = 20,
            GuildAllies = 21,
            GuildEnemies = 22,
            WhisperDetails = 26,
            ServerName = 60,
            ServerName2 = 61;
       
        public MsgName(bool Create)
        {
            if (Create)
            {
                Packet = new byte[23];
                Writer.Write(17, 0, Packet);
                Writer.Write(1015, 2, Packet);
                Write((uint)Time32.timeGetTime().GetHashCode(), 4, Packet);
                Texts = new List<string>();
            }
        }
        public MsgName(Client.GameState client, ushort X, ushort Y, byte type, string effect)
        {
            MsgName str2 = new MsgName(true);
            str2.TextsCount = 1;
            str2.PositionX = X;
            str2.PositionY = Y;
            str2.Type = type;
            str2.Texts.Add(effect);
            client.SendScreen(str2, true);
        }
        public MsgName(Client.GameState client, byte type, uint UID, string effect)
        {
            MsgName str = new MsgName(true)
            {
                Type = type,
                UID = UID
            };
            str.Texts.Add(effect);
            client.SendScreen(str.ToArray(), true);
        }
        public ushort PositionX
        {
            get { return BitConverter.ToUInt16(Packet, 8); }
            set { Write(value, 8, Packet); }
        }

        public ushort PositionY
        {
            get { return BitConverter.ToUInt16(Packet, 10); }
            set { Write(value, 10, Packet); }
        }
        public uint UID
        {
            get { return BitConverter.ToUInt32(Packet, 8); }//
            set { WriteUInt32(value, 8, Packet); }
        }
        public byte Action
        {
            get { return Packet[12]; }//
            set { Packet[12] = (byte)value; }
        }
        public byte TextsCount
        {
            get { return Packet[13]; }//
            set { Packet[13] = value; }
        }
        public List<string> Texts;
        public byte[] ToArray()
        {
            ushort entirelength = 26;//23
            foreach (string list in Texts)
                entirelength += (ushort)list.Length;
            byte[] buffer = new byte[entirelength];
            WriteUInt16((ushort)(entirelength - 8), 0, buffer);
            WriteUInt16((ushort)MsgTypes.MsgName, 2, buffer);
            WriteUInt32(UID, 8, buffer);
            WriteUInt32((uint)Time32.timeGetTime().GetHashCode(), 4, buffer);
            buffer[12] = Action;
            Packet = buffer;
            WriteStringList(Texts, 13, Packet);
            return Packet;
        }
        public void Deserialize(byte[] buffer)
        {
            Packet = buffer;
            Texts = new List<string>(buffer[13]);
            ushort offset = 14;
            byte count = 0;
            while (count != TextsCount)
            {
                ushort textlength = buffer[offset]; offset++;
                string text = Server.Encoding.GetString(buffer, offset, textlength);
                offset += textlength;
                Texts.Add(text);
                count++;
            }
        }
        public ushort X
        {
            get { return BitConverter.ToUInt16(Packet, 8); }
            set { Write(value, 8, Packet); }
        }
        public ushort Y
        {
            get { return BitConverter.ToUInt16(Packet, 10); }
            set { Write(value, 8, Packet); }
        }
        public int Type;
        public void Send(Client.GameState client)
        {
            client.Send(Packet);
        }
        public static void Process(byte[] packet, Client.GameState client)
        {
            if (client.Action != 2) return;
            MsgName Name = new MsgName(false);
            Name.Deserialize(packet);
            switch (Name.Action)
            {
                case MsgName.ServerName:
                    {
                        Name = new MsgName(true);
                        Name.Action = MsgName.ServerName;
                        Name.Texts.Add("Ketos");
                        client.Send(Name);
                        client.Player.PKMode = Game.Enums.PKMode.CS;
                        client.Send(new MsgAction(true)
                        {
                            UID = client.Player.UID,
                            ID = MsgAction.Mode.ChangePKMode,
                            dwParam = (uint)Game.Enums.PKMode.CS
                        });
                        client.Send(Name);
                        break;
                    }
                case MsgName.ServerName2:
                    {
                        Name = new MsgName(true);
                        Name.Action = MsgName.ServerName2;
                        Name.Texts.Add("CS_1");
                        client.Send(Name);
                        client.Player.PKMode = Game.Enums.PKMode.Invade;
                        client.Send(new MsgAction(true)
                        {
                            UID = client.Player.UID,
                            ID = MsgAction.Mode.ChangePKMode,
                            dwParam = (uint)Game.Enums.PKMode.Invade
                        });
                        break;
                    }
                case MsgName.BeginGamble:
                    {
                        client.Player.MsgDice = new MsgDice(true);
                        client.Player.MsgDice.Action = MsgDice.Mode.BeginGamble;
                        client.Player.MsgDice.StartTime = DateTime.Now;
                        client.Player.MsgDice.Seconds = 50;
                        client.Player.MsgDice.ID = (ushort)Name.UID;
                        client.Send(packet);
                        client.Send(client.Player.MsgDice.ToArray());
                        break;
                    }
                case MsgName.EndGamble:
                    {
                        if (client.Player.MsgDice != null)
                        {
                            client.Player.MsgDice.Seconds = 0;
                            client.Player.MsgDice.Action = MsgDice.Mode.EndGamble;
                            client.Send(client.Player.MsgDice.ToArray());
                            client.Player.MsgDice = null;
                        }
                        break;
                    }
                case MsgName.QuerySpouse:
                    {
                        Client.GameState Client;
                        if (Kernel.GamePool.TryGetValue(Name.UID, out Client))
                        {
                            Name = new MsgName(true);
                            Name.Action = MsgName.QuerySpouse;
                            Name.UID = client.Player.UID;
                            Name.TextsCount = 1;
                            Name.Texts = new List<string>()
                            {
                               Client.Player.Spouse
                            };
                            client.Send(Name);
                            Client.Send(client.Player.Name + " is checking your equipment");
                        }
                        break;
                    }
                case MsgName.WhisperDetails:
                    {
                        if (Name.Texts.Count > 0)
                        {
                            foreach (var pClient in Kernel.GamePool.Values)
                            {
                                if (pClient.Player.Name == Name.Texts[0])
                                {
                                    string otherstring = "";
                                    otherstring += pClient.Player.UID + " ";
                                    otherstring += pClient.Player.Level + " ";
                                    otherstring += pClient.Player.BattlePower + " #";
                                    if (pClient.Player.GuildID != 0)
                                        otherstring += pClient.Guild.Name + " # ";
                                    else
                                        otherstring += "None # ";
                                    otherstring += pClient.Player.Spouse + " ";
                                    otherstring += (byte)(pClient.Player.NobilityRank) + " ";
                                    if (pClient.Player.Body % 10 < 6)
                                        otherstring += "2 ";
                                    else
                                        otherstring += "1 ";
                                    Name.Texts.Add(otherstring);
                                    client.Send(Name);
                                }
                            }
                        }
                        break;
                    }
                default: Console.WriteLine("MsgName Unknown Action " + Name.Action); break;
            }
        }
    }
}
MsgName above MsgSyndicate below
Code:
using System;
using System.Linq;
using System.Text;
using COServer.Game;
using System.Collections.Generic;

namespace COServer.Network.GamePackets
{
    public unsafe class MsgSyndicate : Writer, Interfaces.IPacket
    {
        public enum Mode : uint
        {
            None = 0,
            JoinRequest = 1,
            InviteRequest = 2,
            Quit = 3,
            Info = 6,
            Allied = 7,
            RemoveAlly = 8,
            Enemied = 9,
            RemoveEnemy = 10,
            DonateSilvers = 11,
            Refresh = 12,
            Disband = 19,
            DonateConquerPoints = 20,
            ChangeGuildRequirements = 24,
            GuildRequirements = 25,
            Bulletin = 27,
            PromoteSendRequest = 28,
            PromoteAcceptRequest = 29,
            Discharge = 30,
            ConfirmPromote = 34,
            Diseharge = 36,
            Promote = 37,
            PromoteInfo = 38,
            Unknown = 45,
            GuildBlackList = 47,
            MakeBlackList = 48,
            SmsBlackList = 49,
            RemoveBlackList = 50
        }
        byte[] Packet;
        public MsgSyndicate(bool Create)
        {
            if (Create)
            {
                Packet = new byte[36];
                WriteUInt16((ushort)(Packet.Length - 8), 0, Packet);
                WriteUInt16((ushort)MsgTypes.MsgSyndicate, 2, Packet);
            }
        }
        public MsgSyndicate(uint Date)
        {
            Packet = new byte[36 + Date];
            WriteUInt16((ushort)(Packet.Length - 8), 0, Packet);
            WriteUInt16((ushort)MsgTypes.MsgSyndicate, 2, Packet);
        }
        public Mode Action
        {
            get { return (Mode)Packet[4]; }
            set { fixed (byte* Pack = Packet) *((uint*)(Pack + 4)) = (uint)value; }
        }
        public uint dwParam
        {
            get { return BitConverter.ToUInt32(Packet, 8); }
            set { WriteUInt32(value, 8, Packet); }
        }
        public uint Level
        {
            get { return BitConverter.ToUInt32(Packet, 12); }
            set { WriteUInt32(value, 12, Packet); }
        }
        public uint Reborn
        {
            get { return BitConverter.ToUInt32(Packet, 16); }
            set { WriteUInt32(value, 16, Packet); }
        }
        public uint Class
        {
            get { return BitConverter.ToUInt32(Packet, 20); }
            set { WriteUInt32(value, 20, Packet); }
        }
        public string BulletinTime
        {
            set
            {
                WriteByte(1, 24, Packet);
                WriteByte((byte)(value.Length), 25, Packet);
                WriteString(value, 26, Packet);
            }
        }
        public byte[] ToArray()
        {
            return Packet;
        }
        public void Deserialize(byte[] Data)
        {
            Packet = Data;
        }
        public void Send(Client.GameState client)
        {
            client.Send(Packet);
        }
        static void AllyGuilds(string name, Client.GameState client)
        {
            foreach (var guild in Kernel.Guilds.Values)
            {
                if (guild.Name == name && client.Guild.Name != name)
                {
                    if (guild.Leader != null)
                    {
                        if (guild.Leader.IsOnline)
                        {
                            guild.Leader.Client.OnMessageBoxEventParams = new object[] { guild, client.Guild };
                            client.OnMessageBoxEventParams = new object[] { guild, client.Guild };
                            Client.GameState Leader = guild.Leader.Client;
                            Leader.MessageOK = delegate
                            {
                                Game.ConquerStructures.Society.Guild Guild1 = Leader.OnMessageBoxEventParams[0] as Game.ConquerStructures.Society.Guild;
                                Game.ConquerStructures.Society.Guild Guild2 = Leader.OnMessageBoxEventParams[1] as Game.ConquerStructures.Society.Guild;
                                if (Guild1.Ally.Count == 6 || Guild2.Ally.Count == 6) return;
                                Guild1.AddAlly(Guild2.Name);
                                Guild2.AddAlly(Guild1.Name);
                                if (Guild1.Leader.Client != null)
                                {
                                    if (Guild1.Leader.Client.Socket.Alive)
                                    {
                                        if (Guild2.Leader.Client != null && Guild2.Leader.Client.Socket.Alive)
                                        {
                                            Guild2.Leader.Client.Send(new MsgTalk(Guild1.Leader.Name + " has accepted your ally request.", System.Drawing.Color.Blue, MsgTalk.TopLeft));
                                        }
                                    }
                                }
                            };
                            guild.Leader.Client.MessageCancel = delegate
                            {
                                try
                                {
                                    if (guild.Leader.Client != null)
                                    {
                                        if (guild.Leader.Client.Socket.Alive)
                                        {
                                            if (guild.Leader.Client.OnMessageBoxEventParams != null)
                                            {
                                                Game.ConquerStructures.Society.Guild Guild2 = guild.Leader.Client.OnMessageBoxEventParams[1] as Game.ConquerStructures.Society.Guild;
                                                Game.ConquerStructures.Society.Guild Guild1 = guild.Leader.Client.OnMessageBoxEventParams[0] as Game.ConquerStructures.Society.Guild;
                                                if (Guild2.Leader.IsOnline)
                                                {
                                                    Guild2.Leader.Client.Send(new MsgTalk(Guild1.Leader.Name + " has declined your ally request.", System.Drawing.Color.Blue, MsgTalk.TopLeft));
                                                }
                                            }
                                        }
                                    }
                                }
                                catch (Exception e)
                                {
                                    Server.SaveException(e);
                                }
                            };
                            guild.Leader.Client.Send(new NpcReply(NpcReply.MessageBox, client.Player.Name + " , GuildLeader of " + client.Guild.Name + " wants to make with you an alliance."));
                        }
                    }
                }
            }
        }
        public void SendPromote(Client.GameState client, ushort typ)
        {
            if (client == null) return;
            if (client.AsMember == null) return;
            List<string> list = new List<string>();
            StringBuilder builder = new StringBuilder();
            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
            {
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.GuildLeader, 1, 1, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.DeputyLeader, (int)client.Guild.RanksCounts[990], 10, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HDeputyLeader, (int)client.Guild.RanksCounts[980], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 650));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonoraryManager, (int)client.Guild.RanksCounts[880], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 320));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonorarySuperv, (int)client.Guild.RanksCounts[840], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 270));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonorarySteward, (int)client.Guild.RanksCounts[680], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 100));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Aide, (int)client.Guild.RanksCounts[602], 6, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Steward, (int)client.Guild.RanksCounts[690], 3, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Follower, (int)client.Guild.RanksCounts[490], 10, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
            }
            if (client.AsMember.Rank == Enums.GuildMemberRank.LeaderSpouse)
            {
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HDeputyLeader, (int)client.Guild.RanksCounts[980], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 650));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonoraryManager, (int)client.Guild.RanksCounts[880], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 320));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonorarySuperv, (int)client.Guild.RanksCounts[840], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 270));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonorarySteward, (int)client.Guild.RanksCounts[680], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 100));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Aide, (int)client.Guild.RanksCounts[602], 10, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Steward, (int)client.Guild.RanksCounts[690], 3, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Follower, (int)client.Guild.RanksCounts[490], 10, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
            }
            if (client.AsMember.Rank == Enums.GuildMemberRank.Manager || client.AsMember.Rank == Enums.GuildMemberRank.HonoraryManager)
            {
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Aide, (int)client.Guild.RanksCounts[602], 6, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
            }
            if (client.AsMember.Rank == Enums.GuildMemberRank.DeputyLeader)
            {
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HDeputyLeader, (int)client.Guild.RanksCounts[980], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 650));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonoraryManager, (int)client.Guild.RanksCounts[880], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 320));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonorarySuperv, (int)client.Guild.RanksCounts[840], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 270));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.HonorarySteward, (int)client.Guild.RanksCounts[680], 4, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 100));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Steward, (int)client.Guild.RanksCounts[690], 3, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Aide, (int)client.Guild.RanksCounts[602], 6, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
                list.Add(this.CreatePromotionString(builder, Enums.GuildMemberRank.Follower, (int)client.Guild.RanksCounts[490], 10, (int)client.Guild.GetMemberPotency(Enums.GuildMemberRank.GuildLeader), 0));
            }
            int extraLength = 0;
            foreach (var str in list) extraLength += str.Length + 1;
            byte[] packet = new byte[28 + 8 + extraLength];
            WriteUInt16((ushort)(packet.Length - 8), 0, packet);
            WriteUInt16((ushort)MsgTypes.MsgSyndicate, 2, packet);
            WriteByte((byte)typ, 4, packet);
            WriteStringList(list, 24, packet);
            client.Send(packet);
        }
        private string CreatePromotionString(StringBuilder builder, Enums.GuildMemberRank rank, int occupants, int maxOccupants, int extraBattlePower, int conquerPoints)
        {
            builder.Remove(0, builder.Length);
            builder.Append((int)rank);
            builder.Append(" ");
            builder.Append(occupants);
            builder.Append(" ");
            builder.Append(maxOccupants);
            builder.Append(" ");
            builder.Append(extraBattlePower);
            builder.Append(" ");
            builder.Append(conquerPoints);
            builder.Append(" ");
            return builder.ToString();
        }
        public static void Process(byte[] Packet, Client.GameState client)
        {
            MsgSyndicate command = new MsgSyndicate(false);
            command.Deserialize(Packet);
            switch (command.Action)
            {
                case Mode.Info:
                    {
                        var Guild = Kernel.Guilds[command.dwParam];
                        if (Guild != null)
                            Guild.SendName(client);
                        break;
                    }
                case Mode.ChangeGuildRequirements:
                    {
                        if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                        {
                            client.Guild.LevelRequirement = Math.Min(command.Level, 140);
                            client.Guild.RebornRequirement = Math.Min(command.Reborn, 2);
                            client.Guild.ClassRequirement = Math.Min(command.Class, 127);
                            foreach (var member in client.Guild.Members.Values)
                                if (member.IsOnline)
                                    client.Guild.SendGuild(member.Client);
                            Database.GuildTable.SaveRequirements(client.Guild);
                        }
                        break;
                    }
                case Mode.RemoveAlly:
                case Mode.RemoveEnemy:
                    {
                        string name = Encoding.Default.GetString(Packet, 26, Packet[25]);
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                            {
                                client.Guild.RemoveAlly(name);
                                foreach (var guild in Kernel.Guilds.Values)
                                {
                                    if (guild.Name == name && client.Guild.Name != name)
                                    {
                                        guild.RemoveAlly(client.Guild.Name);
                                    }
                                }
                                client.Guild.RemoveEnemy(name);
                            }
                        }
                        break;
                    }
                case Mode.Allied:
                    {
                        string name = Encoding.Default.GetString(Packet, 26, Packet[25]);
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                            {
                                if (client.Guild.Ally.Count < 6)
                                {
                                    AllyGuilds(name, client);
                                }
                            }
                        }
                        break;
                    }
                case Mode.Enemied:
                    {
                        string name = Encoding.Default.GetString(Packet, 26, Packet[25]);
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                            {
                                if (client.Guild.Enemy.Count < 6)
                                {
                                    client.Guild.AddEnemy(name);
                                }
                            }
                        }
                        break;
                    }
                case Mode.Bulletin:
                    {
                        string message = Encoding.Default.GetString(Packet, 26, Packet[25]);
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                            {
                                client.Guild.Bulletin = message;
                                client.Guild.CreateBuletinTime();
                                client.Guild.SendGuild(client);
                            }
                        }
                        break;
                    }
                case Mode.DonateSilvers:
                    {
                        if (client.Guild != null)
                        {
                            if (client.Trade.InTrade) return;
                            if (client.PokerPlayer != null)
                                return;
                            if (client.Player.Money >= command.dwParam)
                            {
                                client.Guild.SilverFund += command.dwParam;
                                Database.GuildTable.SaveFunds(client.Guild);
                                client.AsMember.SilverDoantion += command.dwParam;
                                client.Player.Money -= command.dwParam;
                                client.Guild.SendGuild(client);
                                client.Guild.SendGuildMessage(new MsgTalk((client.Player.Name + " Donate " + command.dwParam + " Guild " + client.Guild.Name + " Silvers"), System.Drawing.Color.Red, MsgTalk.TopLeft));
                            }
                        }
                        break;
                    }
                case Mode.DonateConquerPoints:
                    {
                        if (client.Guild != null)
                        {
                            if (client.Trade.InTrade) return;
                            if (client.PokerPlayer != null)
                                return;
                            if (client.Player.ConquerPoints >= (ulong)command.dwParam)
                            {
                                client.Guild.ConquerPointFund += command.dwParam;
                                Database.GuildTable.SaveFunds(client.Guild);
                                client.AsMember.ConquerPointDonation += command.dwParam;
                                client.Player.ConquerPoints -= (uint)command.dwParam;
                                client.Guild.SendGuild(client);
                                client.Guild.SendGuildMessage(new MsgTalk((client.Player.Name + " Donate " + command.dwParam + " Guild " + client.Guild.Name + " ConquerPoints"), System.Drawing.Color.Red, MsgTalk.TopLeft));
                            }
                        }
                        break;
                    }
                case Mode.Refresh:
                    {
                        if (client.AsMember != null)
                        {
                            if (client.Guild != null)
                                client.Guild.SendGuild(client);
                        }
                        break;
                    }
                case Mode.PromoteInfo:
                    {
                        if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                        {
                            SafeDictionary<uint, Game.ConquerStructures.Society.Guild.Member> array2 = new SafeDictionary<uint, Game.ConquerStructures.Society.Guild.Member>();
                            foreach (var p in client.Guild.Members.Values)
                            {
                                if (p.Rank == (Enums.GuildMemberRank)command.dwParam)
                                {
                                    array2.Add(p.ID, p);
                                }
                            }
                            var array = array2.Values.ToArray();
                            if (array != null)
                            {
                                byte[] Buffer = new byte[8 + 48 + array.Length * 32];
                                WriteUInt16((ushort)(Buffer.Length - 8), 0, Buffer);
                                WriteUInt16((ushort)MsgTypes.MsgSynMemberList, 2, Buffer);
                                Uint(1, 4, Buffer);
                                Uint((uint)array.Length, 12, Buffer);
                                int offset = 16;
                                for (int i = 0; i < array.Length; i++)
                                {
                                    Uint((uint)array[i].Level, offset, Buffer);//Level
                                    offset += 4;
                                    Uint((uint)(array[i].IsOnline ? 1 : 0), offset, Buffer);//Online
                                    offset += 4;
                                    if (array[i].IsOnline)
                                        Uint((uint)array[i].Client.Player.BattlePower, offset, Buffer);//BattlePower  
                                    offset += 4;
                                    offset += 4;
                                    WriteString(array[i].Name, offset, Buffer);//Name
                                    offset += 16;
                                }
                                client.Send(Buffer);
                            }
                        }
                        client.Send(Packet);
                        break;
                    }
                case Mode.Discharge:
                    {
                        string name = Encoding.Default.GetString(Packet, 26, Packet[25]);
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                            {
                                var member = client.Guild.GetMemberByName(name);
                                if (member.ID != client.Player.UID)
                                {
                                    if (member.Rank == Enums.GuildMemberRank.DeputyLeader)
                                    {
                                        member.Rank = Enums.GuildMemberRank.Member;
                                        if (member.IsOnline)
                                        {
                                            client.Guild.SendGuild(member.Client);
                                            member.Client.Player.GuildRank = (ushort)member.Rank;
                                            member.Client.Screen.FullWipe();
                                            member.Client.Screen.Reload(null);
                                            member.Client.Player.GuildSharedBp = member.Guild.GetSharedBattlepower(member.Rank);
                                        }
                                        Database.EntityTable.UpdateData(member.ID, "GuildRank", (int)member.Rank);
                                        client.Guild.SendGuildMessage(new MsgTalk((member.Name + " was discharged from " + member.Rank + " position."), System.Drawing.Color.Yellow, MsgTalk.Guild));
                                    }
                                }
                            }
                        }
                        break;
                    }
                case Mode.Promote:
                    {
                        if (client.Guild == null || client.AsMember == null) return;
                        command.SendPromote(client, 37);
                        return;
                    }
                case Mode.PromoteAcceptRequest:
                case Mode.ConfirmPromote:
                case Mode.PromoteSendRequest:
                    {
                        if (client.Guild != null && client.AsMember != null)
                        {
                            string GetMemberName = GeneralData.ReadString(Packet, 26, Packet[25]);
                            ushort GetMemberRank = BitConverter.ToUInt16(Packet, 8);
                            Game.ConquerStructures.Society.Guild.Member MemberPromote = null;
                            if (client.Guild.GetMember(GetMemberName, out MemberPromote))
                            {
                                if (client.AsMember.Rank < MemberPromote.Rank)
                                {
                                    client.Send("Sorry, you have small rank for change he position!");
                                    break;
                                }
                                if (client.AsMember.Rank == Enums.GuildMemberRank.DeputyLeader)
                                {
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Steward)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 3)
                                        {
                                            client.Send("Sorry all Steward`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Follower)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 10)
                                        {
                                            client.Send("Sorry all Follower`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Aide)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 6)
                                        {
                                            client.Send("Sorry all Aide`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                }
                                if (client.AsMember.Rank == Enums.GuildMemberRank.Manager || client.AsMember.Rank == Enums.GuildMemberRank.HonoraryManager)
                                {
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Aide)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 6)
                                        {
                                            client.Send("Sorry all Aide`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                }
                                if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader || client.AsMember.Rank == Enums.GuildMemberRank.LeaderSpouse)
                                {
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.GuildLeader)
                                    {
                                        if (client.AsMember.Rank == Enums.GuildMemberRank.LeaderSpouse) return;
                                        MemberPromote.Rank = Game.Enums.GuildMemberRank.GuildLeader;
                                        client.Guild.LeaderName = MemberPromote.Name;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                        client.AsMember.Rank = Game.Enums.GuildMemberRank.DeputyLeader;
                                        client.Player.GuildRank = (ushort)client.AsMember.Rank;
                                        client.Guild.SendGuild(client);
                                        client.Screen.FullWipe();
                                        client.Screen.Reload(null);
                                        Database.GuildTable.SaveLeader(client.Guild);
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.DeputyLeader)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 6)
                                        {
                                            client.Send("Sorry all DeputyLeader`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Aide)
                                    {
                                        if (client.AsMember.Rank == Enums.GuildMemberRank.LeaderSpouse) return;
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 6)
                                        {
                                            client.Send("Sorry all Aide`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Steward)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 3)
                                        {
                                            client.Send("Sorry all Steward`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.HDeputyLeader)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 4)
                                        {
                                            client.Send("Sorry all HDeputyLeader`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.HonoraryManager)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 4)
                                        {
                                            client.Send("Sorry all HonoraryManager`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.HonorarySuperv)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 4)
                                        {
                                            client.Send("Sorry all HonorarySuperv`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.HonorarySteward)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 4)
                                        {
                                            client.Send("Sorry all HonorarySteward`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Follower)
                                    {
                                        if (client.Guild.RanksCounts[GetMemberRank] >= 10)
                                        {
                                            client.Send("Sorry all Follower`s ranks its ocupated!");
                                            return;
                                        }
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                    if (GetMemberRank == (ushort)Enums.GuildMemberRank.Member)
                                    {
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]--;
                                        MemberPromote.Rank = (Enums.GuildMemberRank)GetMemberRank;
                                        client.Guild.RanksCounts[(ushort)MemberPromote.Rank]++;
                                        if (MemberPromote.IsOnline)
                                        {
                                            client.Guild.SendGuild(MemberPromote.Client);
                                            MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                                            MemberPromote.Client.Player.GuildRank = (ushort)MemberPromote.Rank;
                                            MemberPromote.Client.Screen.FullWipe();
                                            MemberPromote.Client.Screen.Reload(null);
                                        }
                                    }
                                }
                                client.Guild.SendGuildMessage(new MsgTalk((client.Player.Name + " has appointed " + MemberPromote.Name + " as " + MemberPromote.Rank), System.Drawing.Color.Yellow, MsgTalk.Guild));
                                //MemberPromote.Client.Player.GuildSharedBp = client.Guild.GetSharedBattlepower(MemberPromote.Rank);
                            }
                            else client.Send("Sorry Can't Find " + GetMemberName);
                        }
                        break;
                    }
                case Mode.JoinRequest:
                    {
                        Client.GameState Target;
                        if (Kernel.GamePool.TryGetValue(command.dwParam, out Target))
                        {
                            if (Target.Guild.BlackList.Contains(client.Player.UID))
                            {
                                command.Action = Mode.GuildBlackList;
                                client.Send(command);
                                return;
                            }
                            client.GuildJoinTarget = Target.Player.UID;
                            if (client.GuildJoinTarget == Target.Player.UID && Target.GuildJoinTarget == client.Player.UID)
                            {
                                client.GuildJoinTarget = 0;
                                Target.GuildJoinTarget = 0;
                                Game.ConquerStructures.Society.Guild g;
                                if (Kernel.Guilds.TryGetValue(Target.Player.GuildID, out g))
                                {
                                    if (Target.AsMember.Rank != Game.Enums.GuildMemberRank.Member)
                                    {
                                        if (client.Player.GuildID == 0)
                                        {
                                            if (client.Union != null)
                                            {
                                                var Union = Kernel.Unions[client.UnionIDX];
                                                Union.RemoveMember(client);
                                            }
                                            g.AddMember(client);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                Game.ConquerStructures.Society.Guild tG;
                                if (Kernel.Guilds.TryGetValue(Target.Player.GuildID, out tG))
                                {
                                    if (Target.AsMember.Rank != Game.Enums.GuildMemberRank.Member)
                                    {
                                        if (MsgSynRecruitAdvertisingList.PassJoinRequirements(client, tG))
                                        {
                                            client.Player.GuildRequest = Time32.Now;
                                            command.dwParam = client.Player.UID;
                                            MsgRelation Relation = new MsgRelation();
                                            Relation.Level = (uint)client.Player.Level;
                                            Relation.BattlePower = (uint)client.Player.BattlePower;
                                            Relation.Receiver = Target.Player.UID;
                                            Relation.Requester = client.Player.UID;
                                            Relation.Spouse = Target.Player.Name == client.Player.Spouse;
                                            Relation.Friend = client.Friends.ContainsKey(Target.Player.UID);
                                            Relation.TradePartner = client.Partners.ContainsKey(Target.Player.UID);
                                            if (client.Mentor != null)
                                                Relation.Mentor = client.Mentor.ID == Target.Player.UID;
                                            Relation.Apprentice = client.Apprentices.ContainsKey(Target.Player.UID);
                                            if (client.Team != null)
                                                Relation.Teammate = client.Team.IsTeammate(Target.Player.UID);
                                            if (client.Guild != null)
                                                Relation.GuildMember = client.Guild.Members.ContainsKey(Target.Player.UID);
                                            Relation.Enemy = client.Enemy.ContainsKey(Target.Player.UID);
                                            Target.Send(Relation.ToArray());
                                            Target.Send(command);
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    }
                case Mode.InviteRequest:
                    {
                        Client.GameState Target;
                        if (Kernel.GamePool.TryGetValue(command.dwParam, out Target))
                        {
                            if (client.Guild.BlackList.Contains(Target.Player.UID))
                            {
                                command.Action = Mode.SmsBlackList;
                                client.Send(command);
                                return;
                            }
                            client.GuildJoinTarget = Target.Player.UID;
                            if (client.GuildJoinTarget == Target.Player.UID && Target.GuildJoinTarget == client.Player.UID)
                            {
                                client.GuildJoinTarget = 0;
                                Target.GuildJoinTarget = 0;
                                Game.ConquerStructures.Society.Guild g;
                                if (Kernel.Guilds.TryGetValue(client.Player.GuildID, out g))
                                {
                                    if (client.AsMember.Rank != Game.Enums.GuildMemberRank.Member)
                                    {
                                        if (Target.Union != null)
                                        {
                                            var Union = Kernel.Unions[Target.Union.ID];
                                            Union.RemoveMember(Target);
                                        }
                                        g.AddMember(Target);
                                    }
                                }
                            }
                            else
                            {
                                if (client.AsMember.Rank != Game.Enums.GuildMemberRank.Member)
                                {
                                    client.Player.GuildRequest = Time32.Now;
                                    command.dwParam = client.Player.UID;
                                    MsgRelation Relation = new MsgRelation();
                                    Relation.Level = (uint)client.Player.Level;
                                    Relation.BattlePower = (uint)client.Player.BattlePower;
                                    Relation.Receiver = Target.Player.UID;
                                    Relation.Requester = client.Player.UID;
                                    Relation.Spouse = Target.Player.Name == client.Player.Spouse;
                                    Relation.Friend = client.Friends.ContainsKey(Target.Player.UID);
                                    Relation.TradePartner = client.Partners.ContainsKey(Target.Player.UID);
                                    if (client.Mentor != null)
                                        Relation.Mentor = client.Mentor.ID == Target.Player.UID;
                                    Relation.Apprentice = client.Apprentices.ContainsKey(Target.Player.UID);
                                    if (client.Team != null)
                                        Relation.Teammate = client.Team.IsTeammate(Target.Player.UID);
                                    if (client.Guild != null)
                                        Relation.GuildMember = client.Guild.Members.ContainsKey(Target.Player.UID);
                                    Relation.Enemy = client.Enemy.ContainsKey(Target.Player.UID);
                                    Target.Send(Relation.ToArray());
                                    Target.Send(command);
                                }
                            }
                        }
                        break;
                    }
                case Mode.Unknown:
                    {
                        client.Send(command);
                        break;
                    }
                case Mode.MakeBlackList:
                    {
                        if (client.Guild != null)
                        {
                            uint UID = command.dwParam;
                            if (Kernel.GamePool.ContainsKey(UID))
                            {
                                var c = Kernel.GamePool[UID];
                                if (!client.Guild.BlackList.Contains(UID))
                                    client.Guild.BlackList.Add(UID);
                                c.Send(command);
                            }
                            client.Send("Tha target is addad to the Guild Blacklist.");
                        }
                        break;
                    }
                case Mode.RemoveBlackList:
                    {
                        if (client.Guild != null)
                        {
                            uint UID = command.dwParam;
                            if (client.Guild.BlackList.Contains(UID))
                                client.Guild.BlackList.Remove(UID);
                            client.Send(command);
                        }
                        client.Send("Removed from blacklist successfully. The target is recruitable, now.");
                        break;
                    }
                case Mode.Quit:
                    {
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank != Enums.GuildMemberRank.GuildLeader)
                            {
                                client.Guild.ExpelMember(client.Player.Name, true);
                            }
                            if (client.AsMember.Rank != Enums.GuildMemberRank.DeputyLeader)
                            {
                                client.Guild.ExpelMember(client.Player.Name, true);
                            }
                        }
                        break;
                    }
                case Mode.Diseharge:
                    {
                        string name = Encoding.Default.GetString(Packet, 26, Packet[25]);
                        if (client.Guild != null)
                        {
                            if (client.AsMember.Rank == Enums.GuildMemberRank.GuildLeader)
                            {
                                var member = client.Guild.GetMemberByName(name);
                                client.Guild.SendGuildMessage(new MsgTalk((member.Name + " was discharged from " + member.Rank + " position."), System.Drawing.Color.Yellow, MsgTalk.Guild));
                                if (member.ID != client.Player.UID)
                                {
                                    member.Rank = Enums.GuildMemberRank.Member;
                                    if (member.IsOnline)
                                    {
                                        client.Guild.SendGuild(member.Client);
                                        member.Client.Player.GuildRank = (ushort)member.Rank;
                                        member.Client.Screen.FullWipe();
                                        member.Client.Screen.Reload(null);
                                        member.Client.Player.GuildSharedBp = member.Guild.GetSharedBattlepower(member.Rank);
                                    }
                                    Database.EntityTable.UpdateData(member.ID, "GuildRank", (int)member.Rank);
                                }
                            }
                        }
                        break;
                    }
                default: Console.WriteLine("[GuildCommand] Unknown Action: " + command.Action + ""); break;
            }
        }
    }
}
Yes packets are correct, it's something to do with the code afaik
04/03/2024 01:50 Arcо#6
What is being saved in the database that relates the character to the guild?
04/03/2024 02:32 denominator#7
Entities in database
Code:
CREATE TABLE `entities` (
  `UID` bigint(18) unsigned NOT NULL DEFAULT '0',
  `Owner` varchar(45) NOT NULL DEFAULT '',
  `Name` varchar(16) NOT NULL DEFAULT '',
  `ConquerPoints` bigint(18) unsigned DEFAULT '0',
  `Money` bigint(18) unsigned DEFAULT '27500',
  `Class` tinyint(5) unsigned DEFAULT '10',
  `FirstCreditPoints` bigint(18) NOT NULL DEFAULT '8888',
  `TQPoint` bigint(18) NOT NULL,
  `ConquerPointsFake` bigint(18) NOT NULL DEFAULT '0',
  `Level` tinyint(5) unsigned NOT NULL DEFAULT '1',
  `VIPLevel` tinyint(5) unsigned NOT NULL DEFAULT '1',
  `BoundCps` bigint(18) unsigned DEFAULT '27',
  `Face` smallint(12) unsigned NOT NULL DEFAULT '0',
  `Body` smallint(12) unsigned NOT NULL DEFAULT '0',
  `HairStyle` smallint(12) unsigned DEFAULT '21',
  `Online` tinyint(2) unsigned DEFAULT '0',
  `Strength` smallint(12) unsigned DEFAULT '1',
  `Agility` smallint(12) unsigned DEFAULT '1',
  `Vitality` smallint(12) unsigned DEFAULT '1',
  `Spirit` smallint(12) unsigned DEFAULT '0',
  `Atributes` smallint(12) unsigned DEFAULT '0',
  `Hitpoints` mediumint(16) unsigned DEFAULT '93',
  `Mana` mediumint(16) unsigned DEFAULT '0',
  `MapID` smallint(12) unsigned DEFAULT '1002',
  `X` smallint(12) unsigned DEFAULT '301',
  `Y` smallint(12) unsigned DEFAULT '279',
  `PKPoints` smallint(12) unsigned DEFAULT '0',
  `Experience` bigint(255) unsigned DEFAULT '0',
  `QuizPoints` mediumint(30) unsigned DEFAULT '0',
  `PreviousMapID` smallint(12) unsigned DEFAULT '1010',
  `Reborn` tinyint(2) unsigned DEFAULT '0',
  `1stClass` tinyint(5) unsigned DEFAULT '10',
  `2ndClass` tinyint(2) unsigned DEFAULT '0',
  `3rdClass` tinyint(2) unsigned DEFAULT '0',
  `Spouse` varchar(16) DEFAULT 'None',
  `WarehousePW` varchar(16) DEFAULT '',
  `MoneySave` bigint(255) unsigned DEFAULT '0',
  `FirstRebornClass` tinyint(5) unsigned DEFAULT '0',
  `SecondRebornClass` tinyint(5) unsigned DEFAULT '0',
  `FirstRebornLevel` tinyint(5) unsigned DEFAULT '0',
  `SecondRebornLevel` tinyint(5) unsigned DEFAULT '0',
  `EnlightenPoints` bigint(18) unsigned DEFAULT '0',
  `DoubleExpTime` bigint(18) unsigned DEFAULT '0',
  `gwkill` bigint(18) unsigned DEFAULT '0',
  `HeavenBlessingTime` bigint(255) unsigned DEFAULT '0',
  `BlessTime` bigint(18) unsigned DEFAULT '0',
  `LastDragonBallUse` bigint(255) DEFAULT '0',
  `LastResetTime` bigint(255) DEFAULT '0',
  `EnlightsReceived` tinyint(5) unsigned DEFAULT '0',
  `EnlightmentWait` mediumint(100) unsigned DEFAULT '0',
  `DoubleExpToday` tinyint(5) unsigned DEFAULT '0',
  `GuildID` bigint(18) unsigned DEFAULT '0',
  `GuildRank` bigint(18) unsigned DEFAULT '0',
  `GuildSilverDonation` bigint(255) unsigned DEFAULT '0',
  `GuildConquerPointDonation` bigint(255) unsigned DEFAULT '0',
  `VirtuePoints` bigint(255) unsigned DEFAULT '0',
  `HeadgearClaim` tinyint(5) unsigned DEFAULT '0',
  `NecklaceClaim` tinyint(5) unsigned DEFAULT '0',
  `ArmorClaim` tinyint(5) unsigned DEFAULT '0',
  `WeaponClaim` tinyint(5) unsigned DEFAULT '0',
  `BootsClaim` tinyint(5) unsigned DEFAULT '0',
  `TowerClaim` tinyint(5) unsigned DEFAULT '0',
  `FanClaim` tinyint(5) unsigned DEFAULT '0',
  `RingClaim` tinyint(5) unsigned DEFAULT '0',
  `VendingDisguise` smallint(5) DEFAULT '0',
  `ChatBanTime` bigint(255) DEFAULT '0',
  `ChatBanLasts` bigint(255) DEFAULT '0',
  `ChatBanned` tinyint(5) DEFAULT '0',
  `InLottery` tinyint(5) DEFAULT '0',
  `LotteryEntries` mediumint(10) DEFAULT '0',
  `LastLotteryEntry` bigint(255) DEFAULT '0',
  `PreviousX` mediumint(10) DEFAULT '0',
  `PreviousY` mediumint(10) DEFAULT '0',
  `OfflineTGEnterTime` bigint(255) DEFAULT '0',
  `ExpBalls` mediumint(10) DEFAULT '0',
  `Status` bigint(18) DEFAULT '0',
  `Status2` bigint(18) DEFAULT '0',
  `UnionID` bigint(18) unsigned DEFAULT '0',
  `ClanId` int(36) unsigned DEFAULT '0',
  `ClanDonation` bigint(255) unsigned DEFAULT '0',
  `ClanRank` int(36) unsigned DEFAULT '0',
  `SubPro` int(36) unsigned NOT NULL DEFAULT '0',
  `SubProLevel` int(36) unsigned NOT NULL DEFAULT '0',
  `StudyPoints` int(36) unsigned DEFAULT '0',
  `LastLogin` bigint(16) DEFAULT '0',
  `My_Title` int(36) NOT NULL DEFAULT '0',
  `Status3` bigint(32) NOT NULL DEFAULT '0',
  `Status4` bigint(32) NOT NULL DEFAULT '0',
  `Quest` bigint(32) NOT NULL DEFAULT '0',
  `Flower` bigint(32) NOT NULL DEFAULT '0',
  `namechange` varchar(16) DEFAULT NULL,
  `CountryID` smallint(4) DEFAULT NULL,
  `spiritquestbead` int(4) NOT NULL DEFAULT '0',
  `canacceptspiritbead` int(1) NOT NULL DEFAULT '0',
  `collectedspirits` int(4) NOT NULL DEFAULT '0',
  `EditCount` smallint(12) DEFAULT '0',
  `EditAllowed` smallint(12) NOT NULL DEFAULT '1',
  `claimed` tinyint(2) NOT NULL DEFAULT '0',
  `RacePoints` bigint(18) NOT NULL DEFAULT '0',
  `TotalDoantionGuild` bigint(255) unsigned NOT NULL DEFAULT '0',
  `ArsenalDonation` bigint(255) unsigned NOT NULL DEFAULT '0',
  `OnlinePoints` bigint(18) NOT NULL DEFAULT '0',
  `LuckyPoints` int(4) NOT NULL DEFAULT '0',
  `updatelist` bigint(32) DEFAULT NULL,
  `Exploits` bigint(255) DEFAULT NULL,
  `ClaimedTeamPK` tinyint(2) NOT NULL,
  `ClaimedSTeamPK` tinyint(2) NOT NULL,
  `GuildLilies` bigint(255) DEFAULT NULL,
  `GuildRouses` bigint(255) DEFAULT NULL,
  `GuildOrchids` bigint(255) DEFAULT NULL,
  `GuildTulips` bigint(255) DEFAULT NULL,
  `GuildPkDonation` bigint(255) DEFAULT NULL,
  `CTFCpsReward` bigint(255) DEFAULT NULL,
  `CTFSilverReward` bigint(255) DEFAULT NULL,
  `joinkingtime` bigint(255) DEFAULT NULL,
  `Kingfight` bigint(255) DEFAULT NULL,
  `kingwin` bigint(255) DEFAULT NULL,
  `OnlineTrainning` bigint(18) DEFAULT NULL,
  `HuntingExp` bigint(18) DEFAULT NULL,
  `ForgetPassword` bigint(32) DEFAULT NULL,
  `VoteSystem` bigint(32) DEFAULT NULL,
  `FirstCredit` tinyint(2) NOT NULL,
  `ClaimedElitePk` tinyint(2) NOT NULL,
  `CursedTime` bigint(255) NOT NULL,
  `SwordSoul` bigint(32) NOT NULL,
  `BansheeSpirit` bigint(32) NOT NULL,
  `ProtectionTime` bigint(18) DEFAULT NULL,
  `ClaimedExp` bigint(32) NOT NULL,
  `Energy` bigint(255) DEFAULT NULL,
  `ExtraInventory` bigint(255) DEFAULT NULL,
  `Appearance` tinyint(5) NOT NULL,
  `JiangSettings` tinyint(5) NOT NULL,
  `strikePoints` bigint(16) DEFAULT NULL,
  `lacb` bigint(16) DEFAULT NULL,
  `TitlePoints` bigint(20) DEFAULT '0',
  `ChampionPoints` bigint(16) NOT NULL DEFAULT '0',
  `Offical` smallint(12) unsigned DEFAULT '0',
  `Harem` smallint(12) unsigned DEFAULT '0',
  `Guards` smallint(12) unsigned DEFAULT '0',
  `UnionExploits` bigint(18) unsigned DEFAULT '0',
  `TempestWings` int(12) NOT NULL,
  `InnerBook` bigint(18) NOT NULL DEFAULT '0',
  `ProsbertyPack` bigint(18) NOT NULL DEFAULT '0',
  `Champketos` bigint(18) NOT NULL DEFAULT '0',
  `EpicTimes` bigint(18) DEFAULT '5',
  `NemisisPoint` bigint(18) DEFAULT '0',
  `EpicMonkPrize` bigint(18) DEFAULT '27',
  `EpicMonkTimes` bigint(18) DEFAULT '1',
  `TrojanEpicOn` tinyint(5) DEFAULT NULL,
  `Epictrue` tinyint(5) DEFAULT NULL,
  `FirstStagetrojan` bigint(18) DEFAULT '0',
  `Stars` bigint(18) DEFAULT '0',
  `ewing` bigint(18) DEFAULT '0',
  `etitle` bigint(18) DEFAULT '0',
  `Windwalker` bigint(18) NOT NULL DEFAULT '0',
  `BlackList` longtext NOT NULL,
  `DailySignedDays` longtext NOT NULL,
  `DailySignRewards` bigint(255) NOT NULL DEFAULT '0',
  `DailySignVIPChances` bigint(255) NOT NULL DEFAULT '10',
  `TodayChangedBranch` bigint(18) NOT NULL DEFAULT '0',
  `Prestige` bigint(255) NOT NULL DEFAULT '0',
  `Kingdomquiz` int(40) NOT NULL,
  `DivineRXP` bigint(18) NOT NULL DEFAULT '0',
  `VIPLevelFake` bigint(18) DEFAULT '0',
  `VipStamp` bigint(255) DEFAULT '0',
  `VIPLevelParment` bigint(18) NOT NULL DEFAULT '0',
  `DidBrightFortune` bigint(255) NOT NULL DEFAULT '0',
  `DonefurtuneLastStage` bigint(255) NOT NULL DEFAULT '0',
  `Donefurtunefirststagege` bigint(255) NOT NULL DEFAULT '0',
  `TransferedMessage` bigint(20) NOT NULL DEFAULT '0',
  `winnerctf` bigint(255) NOT NULL DEFAULT '0',
  `s` varchar(16) DEFAULT '',
  `DidFirstHeavenTreasury` int(40) DEFAULT '0',
  `PowerLiquor` bigint(18) NOT NULL,
  `PowerLiquorPrize` bigint(18) DEFAULT NULL,
  `Prize_Reseved` bigint(255) DEFAULT '0',
  `DragonBallItemPromoter` bigint(255) DEFAULT '60',
  `StoneItemPromoter` bigint(255) DEFAULT '100',
  `PermanentStoneItemPromoter` bigint(255) DEFAULT '60',
  `ChiPackItemPromoter` bigint(255) DEFAULT '200',
  `ToughDrillItemPromoter` bigint(255) DEFAULT '40',
  `StarDrillItemPromoter` bigint(255) DEFAULT '10',
  `CPExchange` bigint(255) DEFAULT '0',
  `WardRobe` longblob,
  `TitleID` int(18) NOT NULL DEFAULT '0',
  `WingID` int(18) NOT NULL DEFAULT '0',
  `Domino` bigint(18) unsigned DEFAULT '0',
  `CpsBank` bigint(32) DEFAULT NULL,
  `MystreyFruit` bigint(18) DEFAULT NULL,
  `RunasEquipadas` bigint(18) DEFAULT NULL,
  PRIMARY KEY (`UID`,`Name`,`claimed`) USING BTREE,
  UNIQUE KEY `myIndex` (`UID`) USING BTREE
) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;
Guilds in database
Code:
DROP TABLE IF EXISTS `guilds`;
CREATE TABLE `guilds` (
  `ID` int(10) unsigned NOT NULL DEFAULT '0',
  `Name` varchar(45) NOT NULL DEFAULT '',
  `Bulletin` varchar(255) NOT NULL DEFAULT 'This is a new guild.',
  `SilverFund` bigint(255) unsigned DEFAULT '500000',
  `ConquerPointFund` bigint(255) unsigned DEFAULT '0',
  `Wins` bigint(255) unsigned DEFAULT '0',
  `Losts` bigint(255) unsigned DEFAULT '0',
  `LeaderName` varchar(45) NOT NULL DEFAULT '0',
  `LevelRequirement` int(4) unsigned DEFAULT '1',
  `RebornRequirement` int(4) unsigned DEFAULT '0',
  `ClassRequirement` int(4) unsigned DEFAULT '0',
  `CTFPoints` bigint(255) unsigned DEFAULT '0',
  `CTFReward` bigint(255) unsigned DEFAULT '0',
  `adv` varchar(255) DEFAULT NULL,
  `ad_rate` varchar(255) DEFAULT NULL,
  `adLevelRequirement` int(255) DEFAULT NULL,
  `adRebornRequirement` int(255) DEFAULT NULL,
  `adClassRequirement` int(255) DEFAULT NULL,
  `MaleFemale` int(255) DEFAULT NULL,
  `adend` bigint(255) DEFAULT NULL,
  `AutoRecruit` int(255) DEFAULT NULL,
  `BulletinDate` bigint(16) NOT NULL,
  `EnrollmentDate` bigint(16) NOT NULL,
  `CTFdonationCPs` bigint(255) DEFAULT NULL,
  `CTFdonationSilver` bigint(255) DEFAULT NULL,
  `CTFdonationSilverold` bigint(255) DEFAULT NULL,
  `CTFdonationCPsold` bigint(255) DEFAULT NULL,
  `UnionID` bigint(18) unsigned DEFAULT '0',
  PRIMARY KEY (`ID`) USING BTREE,
  UNIQUE KEY `myIndex` (`ID`) USING BTREE
) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;
The guild itself saves, character uses GuildID or at least it's meant to lol
04/07/2024 01:08 denominator#8
Issue is now fixed