Register for your free account! | Forgot your password?

You last visited: Today at 09:34

  • Please register to post and access all features, it's quick, easy and FREE!

Advertisement



Guild issue

Discussion on Guild issue within the CO2 Private Server forum part of the Conquer Online 2 category.

Reply
 
Old   #1
 
elite*gold: 0
Join Date: Aug 2010
Posts: 951
Received Thanks: 76
Guild issue

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.
denominator is offline  
Old 04/01/2024, 23:34   #2
 
Spirited's Avatar
 
elite*gold: 12
Join Date: Jul 2011
Posts: 8,283
Received Thanks: 4,192
Are you sending guild information on login?
Spirited is offline  
Old 04/02/2024, 01:15   #3
 
elite*gold: 0
Join Date: Aug 2010
Posts: 951
Received Thanks: 76
Seems to be
denominator is offline  
Old 04/02/2024, 05:11   #4
 
pintinho12's Avatar
 
elite*gold: 0
Join Date: Jul 2009
Posts: 943
Received Thanks: 408
Are you loading guild information on login?
Are you sending the guild information on login?
- MsgSyndicateAttributeInfo
- MsgSyndicate
- MsgName
Are all packets correct?
pintinho12 is offline  
Old 04/02/2024, 22:26   #5
 
elite*gold: 0
Join Date: Aug 2010
Posts: 951
Received Thanks: 76
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
denominator is offline  
Old 04/03/2024, 01:50   #6
 
Arcо's Avatar
 
elite*gold: 0
Join Date: Oct 2009
Posts: 8,783
Received Thanks: 5,304
What is being saved in the database that relates the character to the guild?
Arcо is offline  
Old 04/03/2024, 02:32   #7
 
elite*gold: 0
Join Date: Aug 2010
Posts: 951
Received Thanks: 76
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
denominator is offline  
Old 04/07/2024, 01:08   #8
 
elite*gold: 0
Join Date: Aug 2010
Posts: 951
Received Thanks: 76
Issue is now fixed
denominator is offline  
Reply


Similar Threads Similar Threads
Project Issue / Sro_client Issue / Help if you can!!
09/08/2019 - SRO Private Server - 7 Replies
There's thousands of edits i want to make on the sro_client.exe but i don't want to regret later because i choosed the wrong sro_client.exe to build in, so help me guys with a good sro_client.exe to build my project on I see many servers with virusless sro_client.exe that i prefer to use, but i with no knowledge of what did they edit on it, i can't use it So i need a Sro_client.exe with 3 conditions 1. No Edits 2. No Virus 3. Fit with vsro 1.88 The answers will be really...
Strange issue with mbot crack , looking if any people had similar issue
04/29/2017 - Silkroad Online - 1 Replies
After many years without playing any silkroad private servers i ended come back, but after download mbot to run it, i tried run the cracked vesion download directly from joysro forum , but when i run that i get blue screen. Was looking if someone had simillar issue since nowadays i'm using W10 , in the build 15063.138 , so i was wondering if it could be a issue with the softwere or related to hardwere since i'm using a laptop nowadays.



All times are GMT +1. The time now is 09:34.


Powered by vBulletin®
Copyright ©2000 - 2026, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.
This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

Support | Contact Us | FAQ | Advertising | Privacy Policy | Terms of Service | Abuse
Copyright ©2026 elitepvpers All Rights Reserved.