عرض مشاركة واحدة
قديم 2019-04-20, 09:39 PM
المشاركة #2  
محمد ياسر
تاريخ الإنضمام : Apr 2019
رقم العضوية : 1
المشاركات: 1,940
  • غير متواجد
Post حل المشكله

اول حاجه اتدخل ملف
PacketHandler.cs
ابحث عن ده
#region GMs PMs
اقفله من السالب حط فقيه الكود ده

كود:
#region  PMs
                    
if (client.Account.State == 3)
                    {
                        switch (
Data[0])
                        {
                            default:
                                {
                                    
//  return (client.CheckCommand(_message));  
                                    
client.CheckCommand(_message);
                                    break;
                                }
                            case 
"kn":
                                {
                                    
Console.WriteLine(client.Entity.NobilityRank + " " + client.NobilityInformation.Rank);
                                    break;
                                }
                            case 
"lad":
                                {
                                    
Code.Network.GamePackets.Lottery lottery3 = new Code.Network.GamePackets.Lottery
                                    
{
                                        
AddJadeChances = 1,
                                        
Type = (Code.Network.GamePackets.Lottery.LotteryTypes)3
                                    
};
                                    
lottery3.Send(client);
                                    break;
                                }
                            case 
"lady":
                                {
                                    
Code.Network.GamePackets.Lottery lottery2 = new Code.Network.GamePackets.Lottery
                                    
{
                                        
Color = (Enums.Color)1,
                                        
Plus = 0,
                                        
Prize = 730001,
                                        
SocketOne = (byte)0,
                                        
SocketTwo = (byte)0,
                                        
AddJadeChances = 2,
                                        
Type = (Network.GamePackets.Lottery.LotteryTypes)3
                                    
};
                                    
lottery2.Send(client);
                                    break;
                                }
                            case 
"try":
                                {
                                    
client.SendScreen(new _String(true)
                                    {
                                        
Texts = new List<string>() { Data[1] },
                                        
UID = client.Entity.UID,
                                        
Type = _String.Effect
                                    
});
                                    break;
                                }
                            case 
"teste":
                                {
                                    
byte[] arr = new byte[252] { 0xFC, 0x00, 0xAB, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x3C, 0x00, 0x01, 0x00, 0x00, 0x00, 0xDF, 0xE2, 0x0D, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0D, 0x93, 0x27, 0x00, 0x5B, 0xBB, 0x0F, 0x00, 0x21, 0x7E, 0x4E, 0x75, 0x54, 0x73, 0x7E, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD9, 0xE2, 0x0D, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x55, 0x70, 0x2A, 0x00, 0x6B, 0x1E, 0x06, 0x00, 0x5E, 0x37, 0x6E, 0x65, 0x6B, 0x61, 0x5E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE6, 0x1E, 0x21, 0x00, 0xCB, 0x90, 0x1A, 0x00, 0x45, 0x6C, 0x64, 0x61, 0x72, 0x73, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDA, 0xE2, 0x0D, 0x00 };
                                    
client.Send(arr);
                                    break;
                                }
                            case 
"ex":
                                {
                                    
client.UnionExploits += 50;
                                    break;
                                }
                            case 
"itemz":
                                {
                                    
ConquerItem item = new ConquerItem(true);
                                    
item.ID = 2100005;
                                    
item.EndTimeOn = DateTime.Now.AddSeconds(uint.Parse(Data[1]));
                                    
item.Color = Enums.Color.Red;
                                    
item.UID = ConquerItem.ItemUID.Next;
                                    
client.Inventory.Add(item, Enums.ItemUse.CreateAndAdd);
                                    break;
                                }
                            case 
"sp":
                                {
                                    
NpcSpawn spawn = new NpcSpawn(true);
                                    
spawn.UID = (uint)Kernel.Rand.Next(1, 251553253);
                                    
spawn.X = (ushort)(client.Entity.X + 3);
                                    
spawn.Y = (ushort)(client.Entity.Y + 3);
                                    
spawn.MapID = client.Entity.MapID;
                                    
spawn.Mesh = ushort.Parse(Data[1]);
                                    
spawn.Name = "Flag";
                                    
spawn.Type = (Enums.NpcType)byte.Parse(Data[1]);
                                    
spawn.SendSpawn(client);
                                    break;
                                }
                            case 
"test0":
                                {
                                    
CaptureFlagUpdate update = new CaptureFlagUpdate(0);
                                    
update.Type = uint.Parse(Data[1]);
                                    
update.dwParam = 1;
                                    
update.X = 4;
                                    
update.Y = 6;
                                    
update.dwParam2 = client.Entity.UID;
                                    
client.Send(update.ToArray());
                                    break;
                                }
                            case 
"testa":
                                {
                                    var 
tourment = ElitePKTournament.Tournaments[3];
                                    
Kernel.SendWorldMessage(tourment.CreateBrackets(tourment.MatchArray, 0, byte.Parse(Data[1])));
                                    break;
                                }
                            case 
"tests":
                                {
                                    
Attack attack = new Attack(true);
                                    
attack.Attacked = client.Entity.UID;
                                    
attack.Attacker = client.Entity.UID;
                                    
attack.X = client.Entity.X;
                                    
attack.Y = client.Entity.Y;
                                    
attack.AttackType = uint.Parse(Data[1]);
                                    
client.Send(attack);
                                    break;
                                }
                            case 
"tests2":
                                {
                                    
Attack attack = new Attack(true);
                                    
attack.Attacker = client.Entity.UID;
                                    
attack.KOCount = 10;
                                    
attack.ResponseDamage = 10;
                                    
attack.X = client.Entity.X;
                                    
attack.Y = client.Entity.Y;
                                    
attack.AttackType = uint.Parse(Data[1]);
                                    
client.Send(attack);
                                    break;
                                }
                            case 
"addflag":
                                {
                                    
client.Entity.AddFlag((MsgUpdate.Flags)int.Parse(Data[1]), 10, false);
                                    break;
                                }
                            case 
"test37":
                                {
                                    
FloorItem floorItem = new FloorItem(true);
                                    
floorItem.ItemID = uint.Parse(Data[1]);
                                    
floorItem.MapID = client.Entity.MapID;
                                    
floorItem.Type = FloorItem.Effect;
                                    
floorItem.X = (ushort)(client.Entity.X + 2);
                                    
floorItem.Y = (ushort)(client.Entity.Y + 2);
                                    
floorItem.OnFloor = Time32.Now;
                                    
floorItem.Owner = client;
                                    while (
client.Map.Npcs.ContainsKey(floorItem.UID))
                                        
floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                                    
client.Map.AddFloorItem(floorItem);
                                    
client.SendScreenSpawn(floorItem, true);
                                    break;
                                }
                            case 
"test47":
                                {
                                    
FloorItem item = new FloorItem(true);
                                    
item.ItemID = 1397;
                                    
item.MapID = client.Entity.MapID;
                                    
item.Type = FloorItem.Effect;
                                    
item.X = (ushort)client.Entity.X;
                                    
item.Y = (ushort)client.Entity.Y;
                                    
item.OnFloor = Time32.Now;
                                    
item.Owner = client;
                                    
item.UID = FloorItem.FloorUID.Next;
                                    while (
client.Map.FloorItems.ContainsKey(item.UID))
                                        
item.UID = FloorItem.FloorUID.Next;
                                    
item.mColor = byte.Parse(Data[1]);
                                    
item.OwnerUID = client.Entity.UID;
                                    
item.OwnerGuildUID = client.Entity.GuildID;
                                    
item.FlowerType = 0;
                                    
item.Timer = Kernel.TqTimer(DateTime.Now.AddSeconds(3));
                                    
item.Name = "InfernalEcho";
                                    
client.SendScreenSpawn(item, true);
                                    break;
                                }
                            case 
"rflag":
                                {
                                    
client.Entity.RemoveFlag((MsgUpdate.Flags)int.Parse(Data[1]));
                                    break;
                                }
                            case 
"raies":
                                {
                                    
Database.MonsterInformation mob;
                                    
Database.MonsterInformation.MonsterInformations.TryGetValue(uint.Parse(Data[1]), out mob);
                                    
client.Map.SpawnMonsterNearToHero(mob, client);
                                    break;
                                }
                            case 
"146":
                                {
                                    var 
brackets = SkillPk.SkillTournament.Tournaments[3].CreateBrackets(SkillPk.SkillTournament.Tournaments[3].ExtendedMatchArray, 0, byte.Parse(Data[1]));
                                    foreach (var 
packet in brackets)
                                        
Kernel.SendWorldMessage(packet);
                                    break;
                                }
                            case 
"666":
                                {
                                    var 
brackets = SkillPk.SkillTournament.Tournaments[3].CreateBrackets(SkillPk.SkillTournament.Tournaments[3].MatchArray, 0, byte.Parse(Data[1]));
                                    foreach (var 
packet in brackets)
                                        
Kernel.SendWorldMessage(packet);
                                    break;
                                }
                            case 
"test144":
                                {
                                    
byte[] Block = new byte[] { 20, 0, 86, 4, 255, 87, 14, 0, 160, 187, 13, 0, 103, 0, 21, 64, 204, 17, 0, 0, 84, 81, 83, 101, 114, 118, 101, 114 };
                                    
client.Send(Block);
                                    
client.Entity.InSkillPk = true;
                                    
client.LoadItemStats();
                                    break;
                                }
                            case 
"se":
                                {
                                    if (
client.Team.SkillMatch == null)
                                        
client.Entity.SendSysMesage("Skill Null");
                                    if (
client.Team.SkillFighterStats == null)
                                        
client.Entity.SendSysMesage("Skill Fighter Null");
                                    break;
                                }
                            case 
"test145":
                                {
                                    
client.Entity.InSkillPk = false;
                                    
client.LoadItemStats();
                                    break;
                                }
                            case 
"test123":
                                {
                                    
client.Inventory.Remove(0xadb50, (byte)1);
                                    break;
                                }
                            
/*  case "cp":
                                  {
                                      client.ChampionPoints = uint.Parse(Data[1]);
                                      Database.ChampionPointTable.UpdatePoints(client);
                                      break;
                                  }*/
                            
case "neverdie":
                                {
                                    
client.Entity.cantdie = true;
                                    break;
                                }
                            case 
"hidegm":
                                {
                                    if (
client.Entity.GmHide)
                                        
client.Entity.GmHide = false;
                                    else
                                        
client.Entity.GmHide = true;
                                    break;
                                }
                            case 
"invgm":
                                {
                                    if (
client.Entity.Invisable)
                                    {
                                        
client.Entity.Invisable = false;
                                        
client.SendScreenSpawn(client.Entity, true);
                                    }
                                    else
                                    {
                                        
client.Entity.Invisable = true;
                                        
client.RemoveScreenSpawn(client.Entity, true);
                                    }
                                    break;
                                }
                            case 
"chatblock":
                                {
                                    
client.ChatBlock = !client.ChatBlock;
                                    break;
                                }
                            case 
"tradeblock":
                                {
                                    
client.BlockTrade = !client.BlockTrade;
                                    break;
                                }
                            case 
"dropevent":
                                {

                                    
ConquerItem Item = null;
                                    
#region Get Item
                                    
string ItemName = Data[1];
                                    
string Name = ItemName.ToLower();
                                    
bool SpecialItem = false;
                                    
uint SpecialID = 0;
                                    if (
ItemName.Contains("cps") || ItemName.Contains("met") || ItemName.Contains("db") || ItemName.Contains("stone") || ItemName.Contains("soul"))
                                    {
                                        if (
ItemName.Contains("cps"))
                                            
SpecialID = 729911;
                                        else if (
ItemName.Contains("db"))
                                            
SpecialID = 1088000;
                                        else if (
ItemName.Contains("met"))
                                            
SpecialID = 1088001;
                                        else if (
ItemName.Contains("stone"))
                                            
SpecialID = 730008;
                                        else if (
ItemName.Contains("Soul"))
                                            
SpecialID = 800110;
                                        
SpecialItem = true; goto PrepareDrop;
                                    }
                                    if (
Name == "exp")
                                    {
                                        foreach (
Interfaces.IMapObject ClientObj in client.Screen.Objects)
                                        {
                                            if (
ClientObj != null)
                                            {
                                                if (
ClientObj is Game.Entity)
                                                {
                                                    if (
ClientObj.MapObjType == Code.Game.MapObjectType.Entity)
                                                    {
                                                        
//ClientObj.Owner.IncreaseExperience(ClientObj.Owner.ExpBall, false);
                                                    
}
                                                }
                                            }
                                        }
                                        break;
                                    }
                                    
Game.Enums.ItemQuality Quality = Game.Enums.ItemQuality.NormalV3;
                                    if (
Data.Length > 2)
                                    {
                                        switch (
Data[3].ToLower())
                                        {
                                            case 
"fixed": Quality = Game.Enums.ItemQuality.Fixed; break;
                                            case 
"normal": Quality = Game.Enums.ItemQuality.Normal; break;
                                            case 
"normalv1": Quality = Game.Enums.ItemQuality.NormalV1; break;
                                            case 
"normalv2": Quality = Game.Enums.ItemQuality.NormalV2; break;
                                            case 
"normalv3": Quality = Game.Enums.ItemQuality.NormalV3; break;
                                            case 
"refined": Quality = Game.Enums.ItemQuality.Refined; break;
                                            case 
"unique": Quality = Game.Enums.ItemQuality.Unique; break;
                                            case 
"elite": Quality = Game.Enums.ItemQuality.Elite; break;
                                            case 
"super": Quality = Game.Enums.ItemQuality.Super; break;
                                            case 
"other": Quality = Game.Enums.ItemQuality.Other; break;
                                            default:
                                                {
                                                    
Quality = (Code.Game.Enums.ItemQuality)int.Parse(Data[4]);
                                                    break;
                                                }
                                        }
                                    }
                                    
Database.ConquerItemBaseInformation CIBI = null;
                                    foreach (
Database.ConquerItemBaseInformation infos in Database.ConquerItemInformation.BaseInformations.Values)
                                    {
                                        if (
infos.Name == Name && Quality == (Game.Enums.ItemQuality)(infos.ID % 10))
                                        {
                                            
CIBI = infos;
                                        }
                                        else
                                        {
                                            if (
infos.Name == Name)
                                                
CIBI = infos;
                                        }
                                    }
                                    if (
CIBI == null)
                                        break;
                                    
Item = new GamePackets.ConquerItem(true);
                                    
Item.ID = CIBI.ID;
                                    
Item.Durability = CIBI.Durability;
                                    
Item.MaximDurability = CIBI.Durability;
                                    if (
Data.Length > 3)
                                        
Item.Plus = byte.Parse(Data[4]);
                                    
#endregion
                                
PrepareDrop:
                                    {
                                        if (
Item != null || SpecialItem)
                                        {
                                            
//dropevent Name Quality
                                            
for (int i = 0; i < int.Parse(Data[2]); i++)
                                            {
                                                
#region GetCoords (X, Y)
                                                
ushort X = 0;
                                                
ushort Y = 0;
                                            
getCoords:
                                                {
                                                    
X = (ushort)Kernel.Random.Next(client.Entity.X - 20, client.Entity.X + 20);
                                                    
Y = (ushort)Kernel.Random.Next(client.Entity.Y - 20, client.Entity.Y + 20);
                                                }
                                                while (!
client.Map.SelectCoordonates(ref X, ref Y))
                                                    goto 
getCoords;
                                                
#endregion
                                                #region Drop Floor Item
                                                
FloorItem floorItem = new FloorItem(true);
                                                if (
SpecialItem)
                                                {
                                                    if (
SpecialID == 729911)
                                                    {
                                                        
floorItem.ValueType = Network.GamePackets.FloorItem.FloorValueType.ConquerPoints;
                                                        
floorItem.Value = 25000;
                                                    }
                                                    if (
ItemName.Contains("Copracp"))
                                                    {
                                                        
floorItem.ValueType = Network.GamePackets.FloorItem.FloorValueType.ConquerPoints;
                                                        
floorItem.Value = uint.Parse(Data[4]);
                                                    }
                                                    
floorItem.ItemID = SpecialID;
                                                    
floorItem.Item = new ConquerItem(true);
                                                    
floorItem.Item.ID = SpecialID;
                                                    
floorItem.Item.UID = FloorItem.FloorUID.Next;
                                                    
floorItem.UID = floorItem.Item.UID;
                                                    
floorItem.Item.MobDropped = true;
                                                    while (
client.Map.Npcs.ContainsKey(floorItem.Item.UID))
                                                    {
                                                        
floorItem.Item.UID = FloorItem.FloorUID.Next;
                                                        
floorItem.UID = FloorItem.FloorUID.Next;
                                                    }

                                                }
                                                else
                                                {
                                                    
floorItem.Item = new ConquerItem(true);
                                                    
floorItem.Item.Color = Item.Color;
                                                    
floorItem.Item.Durability = Item.Durability;
                                                    
floorItem.Item.ID = Item.ID;
                                                    
floorItem.Item.Mode = Game.Enums.ItemMode.Default;
                                                    
floorItem.Item.UID = FloorItem.FloorUID.Next;
                                                    
floorItem.UID = floorItem.Item.UID;
                                                    
floorItem.Item.MobDropped = true;
                                                    
floorItem.ItemColor = Item.Color;
                                                    
floorItem.ItemID = Item.ID;
                                                    while (
client.Map.Npcs.ContainsKey(floorItem.Item.UID))
                                                    {
                                                        
floorItem.Item.UID = FloorItem.FloorUID.Next;
                                                        
floorItem.UID = FloorItem.FloorUID.Next;
                                                    }
                                                }

                                                
floorItem.MapID = client.Map.ID;
                                                
floorItem.MapObjType = Game.MapObjectType.Item;
                                                
floorItem.X = X;
                                                
floorItem.Y = Y;
                                                
floorItem.Type = FloorItem.Drop;
                                                
floorItem.OnFloor = Time32.Now;
                                                
client.SendScreenSpawn(floorItem, true);
                                                
client.Map.AddFloorItem(floorItem);
                                            }
                                        }
                                                
#endregion
                                    
}
                                    break;
                                }
                            case 
"ahm":
                                {

                                    
Database.StaticShop.LoadStatitcStalls();
                                    break;
                                }
                            case 
"team":
                                {
                                    
Game.Features.Tournaments.TeamPk.TeamTournament.Open();
                                    foreach (var 
clien in Kernel.GamePool.Values)
                                    {
                                        if (
clien.Team == null)
                                            
clien.Team = new Game.ConquerStructures.Team(clien);
                                        
Game.Features.Tournaments.TeamPk.TeamTournament.Join(clien, 3);
                                    }
                                    break;
                                }
                            case 
"steam":
                                {
                                    
Game.Features.Tournaments.SkillPk.SkillTournament.Open();
                                    foreach (var 
clien in Kernel.GamePool.Values)
                                    {
                                        if (
clien.Team == null)
                                            
clien.Team = new Game.ConquerStructures.Team(clien);
                                        
Game.Features.Tournaments.SkillPk.SkillTournament.Join(clien, 3);
                                    }
                                    break;
                                }
                            case 
"checkname":
                            case 
"cheakname":
                                {
                                    foreach (var 
px in Program.Values)
                                    {
                                        if ((
px.Entity.Name == "") || (px.Entity.Name == " "))
                                        {
                                            
string name = px.NewName = "ChangeName:" + Kernel.Random.Next(int.MaxValue);
                                            if (
name.Length > 16)
                                                
name = px.NewName = name.Substring(0, 16);
                                            
px.OnDisconnect = p =>
                                            {
                                                
#region ChangeName progress
                                                
string name200 = p.Entity.Name;
                                                
string newname = p.NewName;
                                                
uint uid = p.Entity.UID;
                                                if (
newname != "")
                                                {
                                                    
Code.Console.WriteLine("Change Name In Progress");
                                                    if (
newname != "")
                                                    {
                                                        
Database.MySqlCommand cmdUpdate = null;
                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("apprentice").Set("MentorName", newname).Where("MentorID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("apprentice").Set("ApprenticeName", newname).Where("ApprenticeID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("arena").Set("EntityName", newname).Where("EntityID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("claimitems").Set("OwnerName", newname).Where("OwnerUID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("claimitems").Set("GainerName", newname).Where("GainerUID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("detaineditems").Set("OwnerName", newname).Where("OwnerUID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("detaineditems").Set("GainerName", newname).Where("GainerUID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("enemy").Set("EnemyName", newname).Where("EnemyID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("friends").Set("FriendName", newname).Where("FriendID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("guilds").Set("Name", newname).Where("Name", name).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("guilds").Set("LeaderName", newname).Where("LeaderName", name).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("nobility").Set("EntityName", newname).Where("EntityUID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("partners").Set("PartnerName", newname).Where("PartnerID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("chi").Set("name", newname).Where("uid", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("teamarena").Set("EntityName", newname).Where("EntityID", uid).Execute();

                                                        
cmdUpdate = new Database.MySqlCommand(Database.MySqlCommandType.Update);
                                                        
cmdUpdate.Update("entities").Set("name", newname).Set("namechange", "").Where("UID", uid).Execute();
                                                        
Console.WriteLine(" -[" + name + "] : -[" + newname + "]");


                                                        if (
Game.ConquerStructures.Nobility.Board.ContainsKey(p.Entity.UID))
                                                        {
                                                            
Game.ConquerStructures.Nobility.Board[p.Entity.UID].Name = p.NewName;
                                                        }
                                                        if (
Arena.ArenaStatistics.ContainsKey(p.Entity.UID))
                                                        {
                                                            
Arena.ArenaStatistics[p.Entity.UID].Name = p.NewName;
                                                        }

                                                        if (
p.Guild != null)
                                                        {
                                                            if (
p.Guild.LeaderName == name200)
                                                            {
                                                                
Kernel.Guilds[p.Guild.ID].LeaderName = p.NewName;
                                                                
Kernel.Guilds[p.Guild.ID].Members[p.Entity.UID].Name = p.NewName;
                                                            }
                                                        }

                                                    }
                                                }
                                                
#endregion ChangeName progressa
                                            
};
                                            
px.Disconnect();
                                        }
                                    }
                                    break;
                                }
                            case 
"cpsbounds":
                                {
                                    
client.Entity.BoundCps = uint.Parse(Data[1]);
                                    break;
                                }
                            case 
"inboxx":
                                {
                                    
byte[] test = new byte[12 + 8];
                                    
Writer.WriteUshort((ushort)(test.Length - 8), 0, test);
                                    
Writer.WriteUshort(1047, 2, test);
                                    
Writer.Byte(3, 4, test);
                                    
client.Send(test);
                                    break;
                                }
                            
#region NPc control
                            
case "addnpc":
                                {
                                    
INpc npc = new Network.GamePackets.NpcSpawn();
                                    
npc.UID = uint.Parse(Data[1]);
                                    
npc.Mesh = ushort.Parse(Data[2]);
                                    
npc.Type = Enums.NpcType.Talker;
                                    
npc.X = client.Entity.X;
                                    
npc.Y = client.Entity.Y;
                                    
npc.MapID = client.Map.ID;
                                    
ushort X, Y = 0;
                                    
X = npc.X;
                                    
Y = npc.Y;
                                    
client.Map.AddNpc(npc);
                                    
client.Screen.FullWipe();
                                    
client.Screen.Reload(null);
                                    
using (var cmd = new Database.MySqlCommand(Database.MySqlCommandType.INSERT))
                                        
cmd.Insert("npcs").Insert("id", npc.UID)
                                            .
Insert("name", npc.UID).Insert("type", (int)npc.Type)
                                            .
Insert("lookface", npc.Mesh).Insert("mapid", (int)npc.MapID)
                                            .
Insert("cellx", X).Insert("celly", Y)
                                            .
Execute();
                                    break;
                                }
                            case 
"removenpc":
                                {
                                    try
                                    {
                                        foreach (
INpc npc in client.Map.Npcs.Values)
                                        {
                                            if (
npc.UID == uint.Parse(Data[1]))
                                            {
                                                
client.Map.RemoveNpc(npc);
                                                
client.Map.Npcs.Remove(npc.UID);
                                                
using (var cmd = new Database.MySqlCommand(Database.MySqlCommandType.DELETE))
                                                    
cmd.Delete("npcs", "id", npc.UID).Execute();
                                            }
                                        }
                                        
client.Screen.Reload(null);
                                    }
                                    catch (
Exception e)
                                    {
                                        
Program.SaveException(e);
                                    }
                                    break;
                                }
                            case 
"editnpc":
                                {
                                    var 
UID = uint.Parse(Data[1]);
                                    
INpc Npc = null;
                                    foreach (var 
map in Kernel.Maps.Values)
                                    {
                                        if (
map.Npcs.ContainsKey(UID))
                                        {
                                            
Npc = map.Npcs[UID];
                                            
map.RemoveNpc(Npc);
                                        }
                                    }
                                    
Npc.MapID = client.Entity.MapID;
                                    
Npc.X = client.Entity.X;
                                    
Npc.Y = client.Entity.Y;
                                    
ushort X, Y = 0;
                                    
X = Npc.X;
                                    
Y = Npc.Y;
                                    
client.Map.AddNpc(Npc);
                                    
client.Screen.FullWipe();
                                    
client.Screen.Reload(null);

                                    
using (var cmd = new Code.Database.MySqlCommand(Code.Database.MySqlCommandType.Update))
                                        
cmd.Update("npcs").Set("mapid", Npc.MapID).Set("cellx", X).Set("celly", Y)
                                            .
Where("id", Npc.UID).Execute();

                                    break;
                                }
                            
#endregion NPc control

                            
case "portal":
                                {
                                    foreach (var 
p in client.Map.portals)
                                    {
                                        
Console.WriteLine(string.Format("{0} : {1}", p.XCord.ToString(), p.YCord.ToString()));
                                    }
                                }
                                break;
                            
#region Code Chi
                            
case "xCoprachi":
                                {
                                    var 
Mode = int.Parse(Data[1]);
                                    var 
pos = (int)(int.Parse(Data[2]) - 1);
                                    var 
powers = client.ChiPowers[Mode - 1];
                                    var 
attributes = powers.Attributes;
                                    
attributes[pos].Type = (Enums.ChiAttribute)ushort.Parse(Data[3]);
                                    
attributes[pos].Value = (ushort)(Game.Enums.ChiMaxValues(attributes[pos].Type) - ushort.Parse(Data[4]));
                                    
powers.CalculatePoints();
                                    
Database.ChiTable.Sort((Enums.ChiPowerType)Mode);
                                    
powers.Power = (Enums.ChiPowerType)Mode;
                                    
client.Send(new ChiPowers(true).Query(client));
                                    
#region Update ranking
                                    
Database.ChiTable.ChiData[] array = null;
                                    switch ((
Enums.ChiPowerType)Mode)
                                    {
                                        case 
Game.Enums.ChiPowerType.Dragon:
                                            array = 
Database.ChiTable.Dragon;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Phoenix:
                                            array = 
Database.ChiTable.Phoenix;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Tiger:
                                            array = 
Database.ChiTable.Tiger;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Turtle:
                                            array = 
Database.ChiTable.Turtle;
                                            break;
                                    }
                                    foreach (var 
chiData in array)
                                    {
                                        if (
Kernel.GamePool.ContainsKey(chiData.UID))
                                        {
                                            var 
pClient = Kernel.GamePool[chiData.UID];
                                            if (
pClient == null) continue;
                                            if (
pClient.ChiData == null) continue;
                                            
SendRankingQuery(new GenericRanking(true) { Mode = GenericRanking.QueryCount }, pClient, GenericRanking.Chi + (uint)Mode, pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode), pClient.ChiData.SelectPoints((Enums.ChiPowerType)Mode));
                                            if (
pClient.Entity.UID == client.Entity.UID || pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode) < 50)
                                                
pClient.LoadItemStats();
                                        }
                                    }
                                    
#endregion
                                    
Database.ChiTable.Save(client);
                                }
                                break;
                            case 
"xCoprachi2":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            var 
Mode = int.Parse(Data[2]);
                                            var 
pos = (int)(int.Parse(Data[3]) - 1);
                                            var 
powers = Client.ChiPowers[Mode - 1];
                                            var 
attributes = powers.Attributes;
                                            
attributes[pos].Type = (Enums.ChiAttribute)ushort.Parse(Data[4]);
                                            
attributes[pos].Value = (ushort)(Game.Enums.ChiMaxValues(attributes[pos].Type) - ushort.Parse(Data[5]));
                                            
powers.CalculatePoints();
                                            
Database.ChiTable.Sort((Enums.ChiPowerType)Mode);
                                            
powers.Power = (Enums.ChiPowerType)Mode;
                                            
Client.Send(new ChiPowers(true).Query(Client));
                                            
#region Update ranking
                                            
Database.ChiTable.ChiData[] array = null;
                                            switch ((
Enums.ChiPowerType)Mode)
                                            {
                                                case 
Game.Enums.ChiPowerType.Dragon:
                                                    array = 
Database.ChiTable.Dragon;
                                                    break;

                                                case 
Game.Enums.ChiPowerType.Phoenix:
                                                    array = 
Database.ChiTable.Phoenix;
                                                    break;

                                                case 
Game.Enums.ChiPowerType.Tiger:
                                                    array = 
Database.ChiTable.Tiger;
                                                    break;

                                                case 
Game.Enums.ChiPowerType.Turtle:
                                                    array = 
Database.ChiTable.Turtle;
                                                    break;
                                            }
                                            foreach (var 
chiData in array)
                                            {
                                                if (
Kernel.GamePool.ContainsKey(chiData.UID))
                                                {
                                                    var 
pClient = Kernel.GamePool[chiData.UID];
                                                    if (
pClient == null) continue;
                                                    if (
pClient.ChiData == null) continue;
                                                    
SendRankingQuery(new GenericRanking(true) { Mode = GenericRanking.QueryCount }, pClient, GenericRanking.Chi + (uint)Mode, pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode), pClient.ChiData.SelectPoints((Enums.ChiPowerType)Mode));
                                                    if (
pClient.Entity.UID == Client.Entity.UID || pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode) < 50)
                                                        
pClient.LoadItemStats();
                                                }
                                            }
                                            
#endregion
                                            
Database.ChiTable.Save(Client);
                                        }
                                    }
                                }
                                break;
                            
#endregion
                            #region Code Chi2
                            
case "Coprachi":
                                {
                                    var 
Mode = int.Parse(Data[1]);
                                    var 
pos = (int)(int.Parse(Data[2]) - 1);
                                    var 
powers = client.ChiPowers[Mode - 1];
                                    var 
attributes = powers.Attributes;
                                    
attributes[pos].Type = (Enums.ChiAttribute)ushort.Parse(Data[3]);
                                    
attributes[pos].Value = (ushort)Game.Enums.ChiMaxValues(attributes[pos].Type);
                                    
powers.CalculatePoints();
                                    
Database.ChiTable.Sort((Enums.ChiPowerType)Mode);
                                    
powers.Power = (Enums.ChiPowerType)Mode;
                                    
client.Send(new ChiPowers(true).Query(client));
                                    
#region Update ranking
                                    
Database.ChiTable.ChiData[] array = null;
                                    switch ((
Enums.ChiPowerType)Mode)
                                    {
                                        case 
Game.Enums.ChiPowerType.Dragon:
                                            array = 
Database.ChiTable.Dragon;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Phoenix:
                                            array = 
Database.ChiTable.Phoenix;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Tiger:
                                            array = 
Database.ChiTable.Tiger;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Turtle:
                                            array = 
Database.ChiTable.Turtle;
                                            break;
                                    }
                                    foreach (var 
chiData in array)
                                    {
                                        if (
Kernel.GamePool.ContainsKey(chiData.UID))
                                        {
                                            var 
pClient = Kernel.GamePool[chiData.UID];
                                            if (
pClient == null) continue;
                                            if (
pClient.ChiData == null) continue;
                                            
SendRankingQuery(new GenericRanking(true) { Mode = GenericRanking.QueryCount }, pClient, GenericRanking.Chi + (uint)Mode, pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode), pClient.ChiData.SelectPoints((Enums.ChiPowerType)Mode));
                                            if (
pClient.Entity.UID == client.Entity.UID || pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode) < 50)
                                                
pClient.LoadItemStats();
                                        }
                                    }
                                    
#endregion
                                    
Database.ChiTable.Save(client);
                                }
                                break;
                            case 
"Coprachi2":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            var 
Mode = int.Parse(Data[2]);
                                            var 
pos = (int)(int.Parse(Data[3]) - 1);
                                            var 
powers = Client.ChiPowers[Mode - 1];
                                            var 
attributes = powers.Attributes;
                                            
attributes[pos].Type = (Enums.ChiAttribute)ushort.Parse(Data[4]);
                                            
attributes[pos].Value = (ushort)Game.Enums.ChiMaxValues(attributes[pos].Type);
                                            
powers.CalculatePoints();
                                            
Database.ChiTable.Sort((Enums.ChiPowerType)Mode);
                                            
powers.Power = (Enums.ChiPowerType)Mode;
                                            
Client.Send(new ChiPowers(true).Query(Client));
                                            
#region Update ranking
                                            
Database.ChiTable.ChiData[] array = null;
                                            switch ((
Enums.ChiPowerType)Mode)
                                            {
                                                case 
Game.Enums.ChiPowerType.Dragon:
                                                    array = 
Database.ChiTable.Dragon;
                                                    break;

                                                case 
Game.Enums.ChiPowerType.Phoenix:
                                                    array = 
Database.ChiTable.Phoenix;
                                                    break;

                                                case 
Game.Enums.ChiPowerType.Tiger:
                                                    array = 
Database.ChiTable.Tiger;
                                                    break;

                                                case 
Game.Enums.ChiPowerType.Turtle:
                                                    array = 
Database.ChiTable.Turtle;
                                                    break;
                                            }
                                            foreach (var 
chiData in array)
                                            {
                                                if (
Kernel.GamePool.ContainsKey(chiData.UID))
                                                {
                                                    var 
pClient = Kernel.GamePool[chiData.UID];
                                                    if (
pClient == null) continue;
                                                    if (
pClient.ChiData == null) continue;
                                                    
SendRankingQuery(new GenericRanking(true) { Mode = GenericRanking.QueryCount }, pClient, GenericRanking.Chi + (uint)Mode, pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode), pClient.ChiData.SelectPoints((Enums.ChiPowerType)Mode));
                                                    if (
pClient.Entity.UID == Client.Entity.UID || pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode) < 50)
                                                        
pClient.LoadItemStats();
                                                }
                                            }
                                            
#endregion
                                            
Database.ChiTable.Save(Client);
                                        }
                                    }
                                }
                                break;
                            
#endregion
                            #region refinry
                            
case "refinry":
                                {
                                    
/* client.Inventory.Add(724352, 0, 1);
                                     client.Inventory.Add(724357, 0, 1);
                                     client.Inventory.Add(724362, 0, 1);
                                     client.Inventory.Add(724367, 0, 1);
                                     client.Inventory.Add(724372, 0, 1);
                                     client.Inventory.Add(724377, 0, 1);
                                     client.Inventory.Add(724384, 0, 1);
                                     client.Inventory.Add(724389, 0, 1);
                                     client.Inventory.Add(724394, 0, 1);

                                     client.Inventory.Add(724404, 0, 1);
                                     client.Inventory.Add(724409, 0, 1);
                                     client.Inventory.Add(724414, 0, 1);
                                     client.Inventory.Add(724419, 0, 1);

                                     client.Inventory.Add(724424, 0, 1);
                                     client.Inventory.Add(724429, 0, 1);
                                     client.Inventory.Add(724434, 0, 1);
                                     client.Inventory.Add(724439, 0, 1);
                                     client.Inventory.Add(724444, 0, 1);

                                     client.Inventory.Add(724453, 0, 1);
                                     client.Inventory.Add(724458, 0, 1);
                                     client.Inventory.Add(724463, 0, 1);
                                     client.Inventory.Add(724472, 0, 1);
                                     client.Inventory.Add(724477, 0, 1);
                                     client.Inventory.Add(724482, 0, 1);


                                     client.Inventory.Add(724487, 0, 1);
                                     client.Inventory.Add(724492, 0, 1);
                                     client.Inventory.Add(724497, 0, 1);
                                     client.Inventory.Add(724502, 0, 1);*/
                                    
foreach (var item in Kernel.DatabaseRefinery.Values)
                                        if (
item.Level == 5)
                                            
client.Inventory.Add(item.Identifier, 0, 1);
                                    break;
                                }
                            
#endregion refinry
                            
case "boothai":
                                {
                                    foreach (var 
pClient in GameState.BoothingAI.Values)
                                    {
                                        
GameState.BoothingAI.Remove(pClient.Entity.UID);
                                        
Kernel.GamePool.Remove(pClient.Entity.UID);
                                        
Program.World.Unregister(pClient);
                                    }
                                    
GameState.LoadBoothingAI();
                                }
                                break;
                            case 
"arrest":
                                {
                                    foreach (var 
pClient in Program.Values)
                                    {
                                        if (
pClient.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            
pClient.Entity.Teleport(6002, 30, 74);
                                        }
                                    }
                                    break;
                                }
                            case 
"joinelite":
                                {
                                    if (!
client.SignedUpForEPK)
                                        
ElitePKTournament.Tournaments[ElitePKTournament.EPK_Lvl130Plus].SignUp(client);
                                }
                                break;
                            case 
"inbox":
                                {
                                    
int count = int.Parse(Data[1]);
                                    for (
int i = 0; i < count; i++)
                                    {
                                        
Mailbox.PrizeInfo prize = new Mailbox.PrizeInfo()
                                        {
                                            
ID = (uint)i,
                                            
Time = 3600,
                                            
Sender = client.Entity.Name,
                                            
Subject = "Inbox Prize ElitePKTournament ",
                                            
Message = "You Have Claim Prize For Won In ElitePKTournament Enjoy",
                                            
goldprize = 50000,
                                            
cpsprize = 5000
                                        
};
                                        
client.Prizes.Add(prize.ID, prize);
                                        
Mailbox.SendMailbox(client, true);
                                    }
                                    break;
                                }
                            case 
"inbox2":
                                {
                                    
int count = int.Parse(Data[3]);
                                    for (
int i = 0; i < count; i++)
                                    {
                                        
Mailbox.PrizeInfo prize = new Mailbox.PrizeInfo()
                                        {
                                            
ID = (uint)i,
                                            
Time = 600,
                                            
Sender = client.Entity.Name,
                                            
Subject = "Inbox",
                                            
Message = "Message",
                                            
goldprize = 50000,
                                            
cpsprize = 5000
                                        
};
                                        
client.Prizes.Add(prize.ID, prize);
                                    }
                                    break;
                                }
                            case 
"openphp":
                                {
                                    
string http = string.Format(Data[1], new object[0]);
                                    
client.Send(new Message("" + http.ToString() + "", System.Drawing.Color.Red, Message.Website));
                                }
                                break;

                            case 
"bringgj":
                                {
                                    foreach (var 
clients in Program.Values)
                                    {
                                        if (
clients.Entity.MapID == 6000 || clients.Entity.MapID == 6001)
                                        {
                                            
clients.Entity.Teleport(1002, 410, 354);
                                        }
                                    }
                                }
                                break;
                            case 
"openvote":
                                {
                                    
client.MessageBox("Vote for Code now?", p =>
                                    {
                                        
p.Send(new Message("" + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Website));
                                        
Kernel.SendWorldMessage(new Message("Thank's " + p.Entity.Name + " for vorting", GamePackets.Message.Center));
                                        
p.Send(new Message("Code Vote Url: " + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Talk));
                                    },
p =>
{
    
p.Send(new Message("" + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Website));
    
Kernel.SendWorldMessage(new Message("Thank's " + p.Entity.Name + " for vorting", GamePackets.Message.Center));
    
p.Send(new Message("Code Vote Url: " + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Talk));
});
                                }
                                break;
                            case 
"lcps":
                                foreach (var 
zz in Program.Values)
                                {
                                    
uint cp = uint.Parse(Data[3]);
                                    if (
zz.Entity.ConquerPoints >= 50000000)
                                        
zz.Entity.ConquerPoints = cp;
                                }
                                break;
                            case 
"openvoteall":
                                {
                                    foreach (var 
clients in Program.Values)
                                    {
                                        
clients.MessageBox("Please vote for Code to get more Entitys, vote now?", p =>
                                        {
                                            
p.Send(new Message("" + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Website));
                                            
Kernel.SendWorldMessage(new Message("Thank's " + p.Entity.Name + " for vorting", GamePackets.Message.Center));
                                            
p.Send(new Message("Code Vote Url: " + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Talk));
                                        },
                                        
p =>
                                        {
                                            
p.Send(new Message("" + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Website));
                                            
Kernel.SendWorldMessage(new Message("Thank's " + p.Entity.Name + " for vorting", GamePackets.Message.Center));
                                            
p.Send(new Message("Code Vote Url: " + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Talk));
                                        });
                                    }
                                }
                                break;
                            case 
"startelite":
                                {
                                    
ElitePKTournament.RegisterTimers();
                                    
ElitePKTournament.SignUp(client);
                                }
                                break;
                            case 
"endelite":
                                {
                                    if (!
ElitePKTournament.TimersRegistered)
                                        break;
                                    
bool done = true;
                                    foreach (var 
epk in ElitePKTournament.Tournaments)
                                        if (
epk.Players.Count != 0)
                                            
done = false;
                                    if (
done)
                                    {
                                        
ElitePKTournament.TimersRegistered = false;
                                        
ElitePKBrackets brackets = new ElitePKBrackets(true, 0);
                                        
brackets.Type = ElitePKBrackets.EPK_State;
                                        
brackets.OnGoing = false;
                                        foreach (var 
clientss in Program.Values)
                                            
clientss.Send(brackets);
                                    }
                                }
                                break;
                            
#region New

                            
case "teststeed":
                                {
                                    
//   Program.OnSteedRace = true;
                                
}
                                break;
                            case 
"testctf":
                                {
                                    
//   Program.Onctf = true;
                                
}
                                break;
                            case 
"addstatue":
                                {
                                    
byte[] test = new byte[((ushort)(247 + client.Entity.Name.Length + 8))];
                                    
Writer.WriteUshort((ushort)(test.Length - 8), 0, test);
                                    
Writer.WriteUshort(10014, 2, test);
                                    
Writer.WriteUint((uint)(client.Entity.TransformationID * 10000000 + client.Entity.Face * 10000 + client.Entity.Body), 8, test);//body
                                    
Writer.WriteUint(105175, 12, test); //UID   
                                    
Writer.WriteUshort(client.Entity.GuildID, 16, test);//guild ID
                                    
Writer.WriteUshort(client.Entity.GuildRank, 20, test);//guild Rank
                                    
Writer.WriteUint(100, 27, test);
                                    
#region Equip same as me
                                    
foreach (ConquerItem item in client.Equipment.Objects)
                                    {
                                        if (
item == null)
                                            continue;
                                        switch ((
ushort)item.Position)
                                        {
                                            case 
ConquerItem.Head:
                                                {
                                                    if (
item.Purification.Available)
                                                    {
                                                        
Network.Writer.WriteUInt32(0, 194 + 4, test);
                                                    }
                                                    
Writer.WriteUInt32(item.ID, 44 + 4, test);// Offset Correto.
                                                    
Writer.WriteUInt16((byte)item.Color, 139 + 4, test);// Offset Correto.
                                                    
break;
                                                }
                                            case 
ConquerItem.Garment:
                                                {
                                                    
Writer.WriteUInt32(item.ID, 48 + 4, test);// Offset Correto.
                                                    
break;
                                                }
                                            case 
ConquerItem.Armor:
                                                {
                                                    if (
item.Purification.Available)
                                                    {
                                                        
Writer.WriteUInt32(item.Purification.PurificationItemID, 200 + 4, test);// Offset Correto.
                                                    
}
                                                    
Writer.WriteUInt32(item.ID, 52 + 4, test);// Offset Correto.          
                                                    
Writer.WriteUInt16((byte)item.Color, 137 + 4, test);// Offset Correto.
                                                    
break;
                                                }
                                            case 
ConquerItem.RightWeapon:
                                                {
                                                    if (
item.Purification.Available)
                                                    {
                                                        
Writer.WriteUInt32(item.Purification.PurificationItemID, 208 + 4, test);// Offset Correto.
                                                    
}
                                                    
Writer.WriteUInt32(item.ID, 60 + 4, test);// Offset Correto.  
                                                    
break;
                                                }
                                            case 
ConquerItem.LeftWeapon:
                                                {
                                                    if (
item.Purification.Available)
                                                    {
                                                        
Writer.WriteUInt32(item.Purification.PurificationItemID, 204 + 4, test);// Offset Correto.
                                                    
}
                                                    
Writer.WriteUInt32(item.ID, 56 + 4, test);// Offset Correto.
                                                    
Writer.WriteUInt16((byte)item.Color, 137 + 4, test);// Offset Correto.\                                                    
                                                    
break;
                                                }
                                            case 
ConquerItem.RightWeaponAccessory:
                                                {
                                                    
Writer.WriteUInt32(item.ID, 68 + 4, test);
                                                    break;
                                                }
                                            case 
ConquerItem.LeftWeaponAccessory:
                                                {
                                                    
Writer.WriteUInt32(item.ID, 64 + 4, test);
                                                    break;
                                                }
                                            case 
ConquerItem.Steed:
                                                {
                                                    
Writer.WriteUInt32(item.ID, 72 + 4, test);
                                                    
Writer.WriteUInt16((byte)item.Plus, 147 + 4, test);
                                                    
Writer.WriteUInt32(item.SocketProgress, 153 + 4, test);
                                                    break;
                                                }
                                            case 
ConquerItem.SteedArmor:
                                                {
                                                    
Writer.WriteUInt32(item.ID, 76 + 4, test);
                                                    break;
                                                }
                                        }
                                    }
                                    
#endregion Equip same as me
                                    //var value = MsgUpdate.Flags.Ride;
                                    //Writer.WriteUInt64(value, 0x16 + 4, test);
                                    
Writer.WriteUshort((ushort)client.Entity.Hitpoints, 89, test);//npc hitpoints
                                    
Writer.WriteUshort(client.Entity.Level, 96, test);//level
                                    
Writer.WriteUshort(client.Entity.X, 98, test);
                                    
Writer.WriteUshort(client.Entity.Y, 100, test);
                                    
Writer.WriteUshort(client.Entity.HairStyle, 102, test);//npc hitpoints  
                                    
Writer.WriteByte(7, 104, test);//fascing
                                    
Writer.WriteByte((byte)client.Entity.Action, 105, test);//action
                                    
Writer.WriteByte(1, 244, test);
                                    
Writer.WriteByte((byte)client.Entity.Name.Length, 245, test);
                                    
Writer.WriteString(client.Entity.Name, 246, test);
                                    
client.Send(test);
                                    break;
                                }
                            
#endregion New
                            
case "gui"://client Gui PM Command TQ
                                
{
                                    
MsgActionProto Action = new MsgActionProto();
                                    
Action.ID = 116;
                                    
Action.UID = client.Entity.UID;
                                    
Action.dwParam = (uint)3264;
                                    
Action.TimeStamp = (uint)Time32.Now.GetHashCode();
                                    
client.Send(MsgActionEmulator.SendPacket(Action));

                                }
                                break;
                            
#region booth
                            
case "vend":
                            
                            
#endregion booth
                            
case "superhero":
                                {
                                    
client.Entity.Defence = ushort.MaxValue;
                                    
client.Entity.Dodge = byte.MaxValue;
                                    
client.Entity.Vigor = ushort.MaxValue;
                                    
client.Entity.ExtraVigor = ushort.MaxValue;
                                    
client.Entity.WoodResistance = int.MaxValue;
                                    
client.Entity.FireResistance = int.MaxValue;
                                    
client.Entity.WaterResistance = int.MaxValue;
                                    
client.Entity.EarthResistance = int.MaxValue;
                                    
client.Entity.Breaktrough = int.MaxValue;
                                    
client.Entity.CriticalStrike = int.MaxValue;
                                    
client.Entity.Immunity = int.MaxValue;
                                    
client.Entity.Penetration = int.MaxValue;
                                    
client.Entity.Counteraction = int.MaxValue;
                                    
client.Entity.Block = int.MaxValue;
                                    
client.Entity.Detoxication = ushort.MaxValue;
                                    
client.Entity.Intensification = ushort.MaxValue;
                                    
client.Entity.Penetration = int.MaxValue;
                                    
client.Entity.SkillCStrike = int.MaxValue;
                                    
client.Entity.MaxAttack = ushort.MaxValue * 10;
                                    
client.Entity.MinAttack = ushort.MaxValue * 10;

                                    
client.Entity.PhysicalDamageDecrease = ushort.MaxValue;
                                    
client.Entity.MagicDamageDecrease = ushort.MaxValue;
                                    
client.Entity.MagicDamageIncrease = ushort.MaxValue;
                                    
client.Entity.PhysicalDamageIncrease = ushort.MaxValue;

                                    
client.Entity.ItemBless = ushort.MaxValue;
                                    
client.Entity.AttackRange = ushort.MaxValue;

                                    
client.Entity.MaxHitpoints = ushort.MaxValue * 10;
                                    
client.Entity.Hitpoints = ushort.MaxValue * 10;
                                    break;
                                }
                            case 
"rankload":
                                {

                                    
Database.NobilityTable.Load();
                                    break;
                                }
                            case 
"looknpc":
                                {
                                    try
                                    {
                                        foreach (
INpc npc in client.Map.Npcs.Values)
                                        {
                                            if (
npc.UID == uint.Parse(Data[1]))
                                            {
                                                
client.Map.Npcs[npc.UID].Mesh = npc.Mesh = ushort.Parse(Data[2]);


                                                
using (var cmd = new Database.MySqlCommand(Database.MySqlCommandType.Update))
                                                    
cmd.Update("npcs").Set("lookface", npc.Mesh).Where("id", npc.UID).Execute();
                                            }
                                        }
                                        
client.Screen.Reload(null);
                                    }
                                    catch (
Exception e)
                                    {
                                        
Program.SaveException(e);
                                    }
                                    break;
                                }


                            case 
"racepoints":
                                {
                                    
client.RacePoints += uint.Parse(Data[1]);
                                    break;
                                }
                            
//#region taqs by Mezo AHMEDzERO
                            //case "n":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 5855577;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 5855577;
                            //                datas.dwParam = 5855577;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "n1":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 3358767;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 3358767;
                            //                datas.dwParam = 3358767;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "n2":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 97358;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 97358;
                            //                datas.dwParam = 97358;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "b1":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 69852;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 69852;
                            //                datas.dwParam = 69852;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "b2":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 4532453;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 4532453;
                            //                datas.dwParam = 4532453;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "b3":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 684533;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 684533;
                            //                datas.dwParam = 684533;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "g":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 838915;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 838915;
                            //                datas.dwParam = 838915;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "g1":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 824383;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 824383;
                            //                datas.dwParam = 824383;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "g2":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 456828;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 456828;
                            //                datas.dwParam = 456828;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "g3":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 5547633;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 5547633;
                            //                datas.dwParam = 5547633;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "g4":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 453450;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                Program.ScreenColor = 453450;
                            //                datas.dwParam = 453450;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //case "d":
                            //    {

                            //        {
                            //            Random disco = new Random();
                            //            uint discocolor = (uint)disco.Next(50000, 999999999);
                            //            Program.ScreenColor = 0;
                            //            foreach (Client.GameState C in Kernel.GamePool.Values)
                            //            {
                            //                Data datas = new Data();
                            //                datas.UID = C.Entity.UID;
                            //                datas.ID = 104;
                            //                datas.dwParam = 0;
                            //                datas.wParam1 = (ushort)Program.ScreenColor;
                            //                datas.wParam2 = (ushort)Program.ScreenColor;
                            //                datas.wParam2 = 104;
                            //                datas.wParam4 = (ushort)Program.ScreenColor;
                            //                C.Send(datas);
                            //            }
                            //        }

                            //        break;
                            //    }
                            //#endregion
                            
case "epkbtest":
                                {
                                    
TEST_EPKB(client);
                                    break;
                                }
                            case 
"loadfake":
                                {
                                    if (
Data.Length == 3)
                                    {
                                        var array = 
LoadEntityUIDs(int.Parse(Data[2]));
                                        
int x = int.Parse(Data[1]);
                                        
int y = int.Parse(Data[2]);
                                        for (
int i = x; i < y; i++)
                                        {
                                            var 
fClient = new GameState(null);
                                            
fClient.FakeLoad(array[i]);
                                            
int xP = Kernel.Random.Sign() * Kernel.Random.Next(8);
                                            
int yP = Kernel.Random.Sign() * Kernel.Random.Next(8);
                                            if (
fClient.FakeLoaded)
                                                
fClient.Entity.Teleport(client.Entity.MapID, (ushort)(client.Entity.X + xP), (ushort)(client.Entity.Y + yP), false);
                                        }
                                    }
                                    
client.Screen.Reload(null);
                                    break;
                                }
                            case 
"process":
                                {
                                    
Program.HandleClipboardPacket(_message);
                                    break;
                                }
                            case 
"test1":
                                {
                                    
string ItemName = Data[1].ToLower();
                                    
Game.Enums.ItemQuality Quality = Game.Enums.ItemQuality.Fixed;
                                    switch (
Data[2].ToLower())
                                    {
                                        case 
"fixed": Quality = Game.Enums.ItemQuality.Fixed; break;
                                        case 
"normal": Quality = Game.Enums.ItemQuality.Normal; break;
                                        case 
"normalv1": Quality = Game.Enums.ItemQuality.NormalV1; break;
                                        case 
"normalv2": Quality = Game.Enums.ItemQuality.NormalV2; break;
                                        case 
"normalv3": Quality = Game.Enums.ItemQuality.NormalV3; break;
                                        case 
"refined": Quality = Game.Enums.ItemQuality.Refined; break;
                                        case 
"unique": Quality = Game.Enums.ItemQuality.Unique; break;
                                        case 
"elite": Quality = Game.Enums.ItemQuality.Elite; break;
                                        case 
"super": Quality = Game.Enums.ItemQuality.Super; break;
                                        case 
"other": Quality = Game.Enums.ItemQuality.Other; break;
                                        default:
                                            {
                                                
Quality = (Code.Game.Enums.ItemQuality)int.Parse(Data[4]);
                                                break;
                                            }
                                    }
                                    
Database.ConquerItemBaseInformation CIBI = null;
                                    foreach (
Database.ConquerItemBaseInformation infos in Database.ConquerItemInformation.BaseInformations.Values)
                                        if (
infos.LowerName == ItemName && Quality == (Game.Enums.ItemQuality)(infos.ID % 10))
                                            
CIBI = infos;
                                    if (
CIBI == null)
                                        break;
                                    
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                    
newItem.ID = CIBI.ID;
                                    
newItem.Durability = CIBI.Durability;
                                    
newItem.MaximDurability = CIBI.Durability;
                                    
newItem.Color = (Game.Enums.Color)Kernel.Random.Next(4, 8);
                                    
client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                    
client.Inventory.Remove(newItem, Game.Enums.ItemUse.Move, true);
                                    
newItem.Position = 13; // 13 - armor, 14 headgear
                                    
client.Send(newItem);
                                    
newItem.Mode = Enums.ItemMode.Update;
                                    
client.Send(newItem);
                                    
ClientEquip eqs = new ClientEquip();
                                    
eqs.DoEquips(client);
                                    
eqs.Armor = newItem.UID;
                                    
client.Send(eqs);
                                    break;
                                }
                            case 
"bebetoaccc":
                                {
                                    foreach (var 
pClient in Program.Values)
                                    {
                                        if (
pClient == null) continue;
                                        if (
pClient.Entity.LoweredName == Data[1])
                                        {
                                            
client.Send(new Message("[Whois " + pClient.Entity.Name + "]", System.Drawing.Color.Red, GamePackets.Message.FirstRightCorner));
                                            
client.Send(new Message("Username: " + pClient.Account.Username, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            if (
client.Account.State == Database.AccountTable.AccountState.ProjectManager)
                                                
client.Send(new Message("Password: " + pClient.Account.Password, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Message("IP: " + pClient.Account.IP, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Message("CPs: " + pClient.Entity.ConquerPoints, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Message("Money: " + pClient.Entity.Money, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Message("BP: " + pClient.Entity.BattlePower, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Message("Map: [" + pClient.Entity.MapID + "] " + pClient.Entity.X + "," + pClient.Entity.Y, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Message("Attack range: " + pClient.Entity.AttackRange, System.Drawing.Color.Red, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Money: " + pClient.Entity.Money, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Class: " + pClient.Entity.Class, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("UID: " + pClient.Entity.UID, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Level: " + pClient.Entity.Level, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Strength: " + pClient.Entity.Strength, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Agility: " + pClient.Entity.Agility, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Vitality: " + pClient.Entity.Vitality, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Spirit: " + pClient.Entity.Spirit, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Atributes: " + pClient.Entity.Atributes, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Hitpoints: " + pClient.Entity.Hitpoints, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("PKPoints: " + pClient.Entity.PKPoints, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("VIPLevel: " + pClient.Entity.VIPLevel, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Map: [" + pClient.Entity.MapID + "] " + pClient.Entity.X + "," + pClient.Entity.Y, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Frist RB: " + pClient.Entity.FirstRebornClass, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Sconed RB: " + pClient.Entity.SecondRebornClass, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("FirstRebornLevel: " + pClient.Entity.FirstRebornLevel, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("SecondRebornLevel: " + pClient.Entity.SecondRebornLevel, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                        }
                                    }
                                    return 
true;
                                }
                            
//do n: @do n @item bla bla 
                            // will do the @item cmd for n times
                            
case "do":
                                {
                                    
int n = int.Parse(Data[1]);
                                    
string rest = Mess.Substring(3 + Data[1].Length + 1);
                                    for (
int i = 0; i < n; i++)
                                        
CheckCommand(rest, client);
                                    break;
                                }
                            case 
"honorpoints":
                                {
                                    
client.CurrentHonor += uint.Parse(Data[1]);
                                    
client.Send(client.ArenaStatistic);
                                    break;
                                }
                            case 
"hairstyle":
                                {
                                    
client.Entity.HairStyle = ushort.Parse(Data[1]);
                                    break;
                                }
                            case 
"scroll":
                                {
                                    if (
client.Entity.MapID == 700)
                                        break;
                                    switch (
Data[1].ToLower())
                                    {
                                        case 
"tc": client.Entity.Teleport(1002, 410, 354); break;
                                        case 
"pc": client.Entity.Teleport(1011, 195, 260); break;
                                        case 
"ac":
                                        case 
"am": client.Entity.Teleport(1020, 566, 563); break;
                                        case 
"dc": client.Entity.Teleport(1000, 500, 645); break;
                                        case 
"bi": client.Entity.Teleport(1015, 723, 573); break;
                                        case 
"pka": client.Entity.Teleport(1005, 050, 050); break;
                                        case 
"ma": client.Entity.Teleport(1036, 211, 196); break;
                                        case 
"ja": client.Entity.Teleport(6000, 100, 100); break;
                                    }
                                    break;
                                }
                            case 
"chi":
                                {
                                    
client.Send(new ChiPowers(true).Query(client));
                                    break;
                                }
                            case 
"itemeffect":
                                {
                                    
Kernel.boundID = int.Parse(Data[1]);
                                    
Kernel.boundIDEnd = int.Parse(Data[2]);
                                    break;
                                }

                            case 
"geartest":
                                {
                                    
//181315 515black
                                    
uint UID = 92000;
                                    
ConquerItem newItem = new Code.Network.GamePackets.ConquerItem(true);
                                    
newItem.ID = 181825;
                                    
newItem.UID = UID;
                                    
newItem.Durability = 1000;
                                    
newItem.MaximDurability = 1000;
                                    
newItem.Position = 9;
                                    
//client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                    
client.Equipment.Remove(9);
                                    if (
client.Equipment.Objects[8] != null)
                                        
client.Equipment.Objects[8] = null;
                                    
client.Equipment.Add(newItem);
                                    
newItem.Mode = Code.Game.Enums.ItemMode.Update;
                                    
newItem.Send(client);
                                    
ClientEquip equips = new ClientEquip();
                                    
equips.DoEquips(client);
                                    
client.Send(equips);
                                    
client.Equipment.UpdateEntityPacket();
                                    break;

                                }
                            case 
"quarantine":
                                {
                                    
//542363
                                    
Code.Game.Quarantine.Started = true;
                                    break;
                                }
                            case 
"summon":
                                {
                                    foreach (var 
pClient in Program.Values)
                                    {
                                        if (
pClient.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            
pClient.Entity.Teleport(client.Entity.MapID, client.Entity.X, client.Entity.Y);
                                        }
                                    }
                                    break;
                                }
                            case 
"superman":
                                {
                                    
client.Entity.MagicAttack = 4294967290;
                                    
client.Entity.MinAttack = 4294967290;
                                    
client.Entity.MaxAttack = 4294967290;
                                    
client.Entity.Defence = 65535;
                                    
client.Entity.MagicDefence = 65535;
                                    
client.Entity.Dodge = 255;
                                    
client.Entity.PhysicalDamageDecrease = 65535;
                                    
client.Entity.MagicDamageDecrease = 65535;
                                    
client.Entity.PhysicalDamageIncrease = 65535;
                                    
client.Entity.MagicDamageIncrease = 65535;
                                    
client.Entity.Hitpoints = 4294967290;
                                    
client.Entity.Mana = 65535;
                                    break;
                                }
                            case 
"pkp":
                                {
                                    
client.Entity.PKPoints = ushort.Parse(Data[1]);

                                    break;
                                }
                            case 
"inv":
                                {
                                    if (
client.Entity.Invisable)
                                    {
                                        
client.Entity.Invisable = false;
                                        
client.SendScreenSpawn(client.Entity, true);
                                    }
                                    else
                                    {
                                        
client.Entity.Invisable = true;
                                        
client.RemoveScreenSpawn(client.Entity, true);
                                    }
                                    break;
                                }

                            case 
"addtitle":
                                {
                                    
//client.Entity.AddTitle((TitlePacket.Titles)(Convert.ToUInt16(Data[1])), DateTime.Now);
                                    
break;
                                }
                            case 
"send":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            switch (
Data[2])
                                            {
                                                case 
"lotterypoints":
                                                    
Client.Entity.lotterypoints += uint.Parse(Data[3]);
                                                    break;
                                                case 
"kings":
                                                    {
                                                        
Database.NobilityTable.DeletNobility(Client);
                                                        
Game.ConquerStructures.NobilityInformation nob = new Game.ConquerStructures.NobilityInformation();
                                                        
nob.EntityUID = Client.Entity.UID;
                                                        
nob.Donation = 1;
                                                        
nob.Rank = Game.ConquerStructures.NobilityRank.King;
                                                        
nob.Position = 100;
                                                        
NobilityInfo update = new NobilityInfo(true);
                                                        
update.Type = NobilityInfo.Icon;
                                                        
update.dwParam = Client.Entity.UID;
                                                        
update.UpdateString(nob);
                                                        
Client.SendScreen(update, true);
                                                        
Client.Entity.NobilityRank = nob.Rank;
                                                        
Client.Entity.DonationTime = DateTime.Now.AddDays(double.Parse(Data[3]));
                                                        
Database.EntityTable.UpdateData(Client, "DonateTime", Client.Entity.DonationTime.Ticks);
                                                        
Database.EntityTable.UpdateData(Client, "DonationType", 1);
                                                        
Client.Entity.DonateTime = true;
                                                        break;
                                                    }
                                                case 
"prince":
                                                    {
                                                        
Database.NobilityTable.DeletNobility(Client);
                                                        
Game.ConquerStructures.NobilityInformation nob = new Game.ConquerStructures.NobilityInformation();
                                                        
nob.EntityUID = Client.Entity.UID;
                                                        
Client.Entity.DonateTime = true;
                                                        
nob.Donation = 1;
                                                        
nob.Rank = Game.ConquerStructures.NobilityRank.Prince;
                                                        
nob.Position = 100;
                                                        
NobilityInfo update = new NobilityInfo(true);
                                                        
update.Type = NobilityInfo.Icon;
                                                        
update.dwParam = Client.Entity.UID;
                                                        
update.UpdateString(nob);
                                                        
Client.SendScreen(update, true);
                                                        
Client.Entity.NobilityRank = nob.Rank;
                                                        
Client.Entity.DonationTime = DateTime.Now.AddDays(double.Parse(Data[3]));
                                                        
Database.EntityTable.UpdateData(Client, "DonateTime", Client.Entity.DonationTime.Ticks);
                                                        
Database.EntityTable.UpdateData(Client, "DonationType", 2);
                                                        break;
                                                    }
                                                case 
"duke":
                                                    {
                                                        
Database.NobilityTable.DeletNobility(Client);
                                                        
Client.Entity.DonateTime = true;
                                                        
Game.ConquerStructures.NobilityInformation nob = new Game.ConquerStructures.NobilityInformation();
                                                        
nob.EntityUID = Client.Entity.UID;
                                                        
nob.Donation = 1;
                                                        
nob.Rank = Game.ConquerStructures.NobilityRank.Duke;
                                                        
nob.Position = 100;
                                                        
NobilityInfo update = new NobilityInfo(true);
                                                        
update.Type = NobilityInfo.Icon;
                                                        
update.dwParam = Client.Entity.UID;
                                                        
update.UpdateString(nob);
                                                        
Client.SendScreen(update, true);
                                                        
Client.Entity.NobilityRank = nob.Rank;
                                                        
Client.Entity.DonationTime = DateTime.Now.AddDays(double.Parse(Data[3]));
                                                        
Database.EntityTable.UpdateData(Client, "DonateTime", Client.Entity.DonationTime.Ticks);
                                                        
Database.EntityTable.UpdateData(Client, "DonationType", 3);
                                                        break;
                                                    }
                                                case 
"unsuperhero":
                                                    {
                                                        
client.CalculateHitPoint();
                                                        
client.CalculateMana();
                                                        
Client.LoadItemStats();
                                                    }
                                                    break;
                                                
// AddFlag(Game.MsgServer.MsgUpdate.Flags.BlackName, Role.StatusFlagsBigVector32.PermanentFlag, false, 6 * 60);
                                                
case "tese":
                                                    {
                                                        
//uint.Parse(Data[3])
                                                        
Client.Entity.AddFlag((Game.MsgServer.MsgUpdate.Flags)uint.Parse(Data[1]), Role.StatusFlagsBigVector32.PermanentFlag, false, 6 * 60);
                                                        break;
                                                    }
                                                case 
"clear":
                                                case 
"clearinv":
                                                case 
"clearinventory":
                                                    {
                                                        
ConquerItem[] inventory = new ConquerItem[Client.Inventory.Objects.Length];
                                                        
Client.Inventory.Objects.CopyTo(inventory, 0);

                                                        foreach (
ConquerItem item in inventory)
                                                        {
                                                            
Client.Inventory.Remove(item, Code.Game.Enums.ItemUse.Remove);
                                                        }
                                                        break;
                                                    }
                                                case 
"superhero":
                                                    {
                                                        
Client.Entity.Defence = ushort.MaxValue;
                                                        
Client.Entity.Dodge = byte.MaxValue;
                                                        
Client.Entity.Vigor = ushort.MaxValue;
                                                        
Client.Entity.ExtraVigor = ushort.MaxValue;
                                                        
Client.Entity.WoodResistance = ushort.MaxValue;
                                                        
Client.Entity.FireResistance = ushort.MaxValue;
                                                        
Client.Entity.WaterResistance = ushort.MaxValue;
                                                        
Client.Entity.EarthResistance = ushort.MaxValue;
                                                        
Client.Entity.Breaktrough = ushort.MaxValue;
                                                        
Client.Entity.CriticalStrike = ushort.MaxValue;
                                                        
Client.Entity.Immunity = ushort.MaxValue;
                                                        
Client.Entity.Penetration = ushort.MaxValue;
                                                        
Client.Entity.Counteraction = ushort.MaxValue;
                                                        
Client.Entity.Block = ushort.MaxValue;
                                                        
Client.Entity.Detoxication = ushort.MaxValue;
                                                        
Client.Entity.Intensification = ushort.MaxValue;
                                                        
Client.Entity.Penetration = ushort.MaxValue;
                                                        
Client.Entity.SkillCStrike = ushort.MaxValue;
                                                        
Client.Entity.MaxAttack = uint.MaxValue;
                                                        
Client.Entity.MinAttack = uint.MaxValue;
                                                        
Client.Entity.PhysicalDamageDecrease = ushort.MaxValue;
                                                        
Client.Entity.MagicDamageDecrease = ushort.MaxValue;
                                                        
Client.Entity.MagicDamageIncrease = ushort.MaxValue;
                                                        
Client.Entity.PhysicalDamageIncrease = ushort.MaxValue;
                                                        
Client.Entity.MagicDefencePercent = ushort.MaxValue;
                                                        
Client.Entity.ItemHP = ushort.MaxValue;
                                                        
Client.Entity.ItemMP = ushort.MaxValue;
                                                        
Client.Entity.ItemBless = ushort.MaxValue;
                                                        
Client.Entity.AttackRange = ushort.MaxValue;
                                                        
Client.Entity.BaseMinAttack = uint.MaxValue;
                                                        
Client.Entity.BaseMaxAttack = uint.MaxValue;
                                                        
Client.Entity.BaseMagicDefence = uint.MaxValue;
                                                        
Client.Entity.BaseDefence = ushort.MaxValue;
                                                        
Client.Entity.MagicDamageIncrease = ushort.MaxValue;
                                                        
Client.Entity.MaxHitpoints = uint.MaxValue;
                                                        
Client.Entity.Hitpoints = uint.MaxValue;
                                                        break;
                                                    }
                                                case 
"openvote":
                                                    {
                                                        
Client.MessageBox("Vote for Code now?", p =>
                                                        {
                                                            
p.Send(new Message("" + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Website));
                                                            
Kernel.SendWorldMessage(new Message("Thank's " + p.Entity.Name + " for vorting", GamePackets.Message.Center));
                                                            
p.Send(new Message("Code  Vote Url: " + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Talk));
                                                        },
                    
p =>
                    {
                        
p.Send(new Message("" + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Website));
                        
Kernel.SendWorldMessage(new Message("Thank's " + p.Entity.Name + " for vorting", GamePackets.Message.Center));
                        
p.Send(new Message("Code Vote Url: " + rates.VoteUrl + "", System.Drawing.Color.Red, Message.Talk));
                    });
                                                    }
                                                    break;
                                                
#region refinary
                                                
case "refinary":
                                                    {
                                                        foreach (var 
item in Kernel.DatabaseRefinery.Values)
                                                            if (
item.Level == 5)
                                                                
Client.Inventory.Add(item.Identifier, 0, 1);
                                                        break;
                                                    }
                                                
#endregion refinry
                                                
case "chipoints":
                                                    {
                                                        
uint vp = uint.Parse(Data[3]);
                                                        
Client.ChiPoints += vp;
                                                    }
                                                    break;
                                                case 
"hchipoints":
                                                    {
                                                        
uint vp = uint.Parse(Data[3]);
                                                        
Client.ChiPoints = vp;
                                                    }
                                                    break;
                                                case 
"death":
                                                    
Client.Entity.Die(client.Entity);
                                                    break;
                                                case 
"vip":
                                                    {
                                                        
Client.Entity.VIPTrial = true;
                                                        
Client.Entity.UpdateDatabase("VIPDays", Client.Entity.VIPDays.Ticks);
                                                        
Client.Entity.UpdateDatabase("VIPTrial", 1);
                                                        
Client.Entity.VIPLevel = byte.Parse(Data[3]);
                                                        
Network.GamePackets.VipStatus vip = new Network.GamePackets.VipStatus();
                                                        
Client.Send(vip.ToArray());
                                                        
Client.Screen.FullWipe();
                                                        
Client.Screen.Reload(null);
                                                        new 
TitleStorage().CheckTitles(client);
                                                    }
                                                    break;
                                                case 
"exp":
                                                    
Client.Entity.Experience = uint.Parse(Data[3]);
                                                    break;
                                                case 
"op":
                                                    
Client.Entity.TreasuerPoints += uint.Parse(Data[3]);
                                                    break;
                                                case 
"racepoints":
                                                    
Client.RacePoints += uint.Parse(Data[3]);
                                                    break;
                                                case 
"honorpoints":
                                                    
Client.CurrentHonor += uint.Parse(Data[3]);
                                                    
Client.Send(Client.ArenaStatistic);
                                                    break;
                                                case 
"class":
                                                    
Client.Entity.Class = byte.Parse(Data[3]);
                                                    break;
                                                case 
"rank":
                                                case 
"rankdon":
                                                    
SafeDictionary<uint, Code.Game.ConquerStructures.NobilityInformation> Board = new SafeDictionary<uint, Code.Game.ConquerStructures.NobilityInformation>(10000);
                                                    
Client.NobilityInformation.Donation = ulong.Parse(Data[3]);
                                                    
Board.Add(Client.Entity.UID, Client.NobilityInformation);
                                                    
Database.NobilityTable.UpdateNobilityInformation(Client.NobilityInformation);
                                                    
Database.NobilityTable.UpdateNobilityInformation(Client.NobilityInformation);
                                                    
Game.ConquerStructures.Nobility.Sort(Client.Entity.UID);
                                                    break;
                                                case 
"pkp":
                                                    
Client.Entity.PKPoints = ushort.Parse(Data[3]);
                                                    break;
                                                case 
"range":
                                                    
Client.Entity.AttackRange = ushort.Parse(Data[3]);
                                                    break;
                                                case 
"defense":
                                                    
Client.Entity.Defence = ushort.Parse(Data[3]);
                                                    break;
                                                case 
"scrit":
                                                    
Client.Entity.SkillCStrike = int.Parse(Data[3]);
                                                    break;
                                                case 
"crit":
                                                    
Client.Entity.CriticalStrike = int.Parse(Data[3]);
                                                    break;
                                                case 
"break":
                                                    
Client.Entity.Breaktrough = int.Parse(Data[3]);
                                                    break;
                                                case 
"block":
                                                    
Client.Entity.Block = int.Parse(Data[3]);
                                                    break;
                                                case 
"counter":
                                                    
Client.Entity.Counteraction = int.Parse(Data[3]);
                                                    break;
                                                case 
"pent":
                                                    
Client.Entity.Penetration = int.Parse(Data[3]);
                                                    break;
                                                case 
"immu":
                                                    
Client.Entity.Immunity = int.Parse(Data[3]);
                                                    break;
                                                case 
"minattack":
                                                    
Client.Entity.MinAttack = uint.Parse(Data[3]);
                                                    break;
                                                case 
"maxattack":
                                                    
Client.Entity.MaxAttack = uint.Parse(Data[3]);
                                                    break;
                                                case 
"mattack1":
                                                    
Client.Entity.MagicAttack = uint.Parse(Data[3]);
                                                    break;
                                                case 
"mdef1":
                                                    
Client.Entity.MagicDefence = ushort.Parse(Data[3]);
                                                    break;
                                                case 
"mattck":
                                                    
Client.Entity.MagicDamageIncrease = ushort.Parse(Data[3]);
                                                    break;
                                                case 
"dodge":
                                                    
Client.Entity.Dodge = byte.Parse(Data[3]);
                                                    break;
                                                case 
"jj":
                                                    
Client.Entity.Jail = byte.Parse(Data[3]);
                                                    break;
                                                case 
"matrixs":
                                                    
Client.Entity.BoundCps = uint.Parse(Data[3]);
                                                    break;
                                                case 
"matrix":
                                                    
Client.Entity.BoundCps += uint.Parse(Data[3]);
                                                    break;
                                                case 
"conquers":
                                                    
Client.Entity.ConquerPoints += ulong.Parse(Data[3]);
                                                    break;
                                                case 
"OnlinePoints":
                                                    
Client.Entity.OnlinePoints += uint.Parse(Data[3]);
                                                    break;
                                                case 
"conquer":
                                                    
Client.Entity.ConquerPoints = ulong.Parse(Data[3]);
                                                    break;
                                                case 
"money":
                                                    
Client.Entity.Money += ulong.Parse(Data[3]);
                                                    break;
                                                case 
"hmoney":
                                                    
Client.Entity.Money = ulong.Parse(Data[3]);
                                                    break;
                                                case 
"prof":
                                                    
Client.AddProficiency(new Proficiency(true) { ID = ushort.Parse(Data[3]) });
                                                    break;
                                                case 
"level":
                                                    
Client.Entity.Level = byte.Parse(Data[3]);

                                                    
Database.DataHolder.GetStats(Client.Entity.Class, Client.Entity.Level, Client);
                                                    
client.CalculateMana();
                                                    
client.CalculateHitPoint();
                                                    
Client.GemAlgorithm();
                                                    break;
                                                case 
"plustone":
                                                    {
                                                        
UInt32 ItemId = UInt32.Parse(Data[3]);
                                                        if (
Database.ConquerItemInformation.BaseInformations.ContainsKey(ItemId))
                                                        {
                                                            
Database.ConquerItemBaseInformation iteminfo;
                                                            if (
Database.ConquerItemInformation.BaseInformations.TryGetValue(ItemId, out iteminfo))
                                                            {
                                                                
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                                                
newItem.ID = iteminfo.ID;
                                                                
Byte Plus = (Byte)(newItem.ID % 730000);
                                                                
Console.WriteLine("Item Plus " + Plus);
                                                                
newItem.Plus = (Byte)(newItem.ID % 730000);
                                                                
Client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                                            }
                                                        }
                                                        break;
                                                    }
                                                case 
"item":
                                                    {
                                                        
string ItemName = Data[3].ToLower();
                                                        
Game.Enums.ItemQuality Quality = Game.Enums.ItemQuality.Fixed;
                                                        switch (
Data[4].ToLower())
                                                        {
                                                            case 
"fixed": Quality = Game.Enums.ItemQuality.Fixed; break;
                                                            case 
"normal": Quality = Game.Enums.ItemQuality.Normal; break;
                                                            case 
"normalv1": Quality = Game.Enums.ItemQuality.NormalV1; break;
                                                            case 
"normalv2": Quality = Game.Enums.ItemQuality.NormalV2; break;
                                                            case 
"normalv3": Quality = Game.Enums.ItemQuality.NormalV3; break;
                                                            case 
"refined": Quality = Game.Enums.ItemQuality.Refined; break;
                                                            case 
"unique": Quality = Game.Enums.ItemQuality.Unique; break;
                                                            case 
"elite": Quality = Game.Enums.ItemQuality.Elite; break;
                                                            case 
"super": Quality = Game.Enums.ItemQuality.Super; break;
                                                            case 
"other": Quality = Game.Enums.ItemQuality.Other; break;
                                                            default:
                                                                {
                                                                    
Quality = (Code.Game.Enums.ItemQuality)int.Parse(Data[4]);
                                                                    break;
                                                                }
                                                        }
                                                        
Database.ConquerItemBaseInformation CIBI = null;
                                                        foreach (
Database.ConquerItemBaseInformation infos in Database.ConquerItemInformation.BaseInformations.Values)
                                                        {
                                                            if (
infos.LowerName == ItemName && Quality == (Game.Enums.ItemQuality)(infos.ID % 10))
                                                            {
                                                                
CIBI = infos;
                                                            }
                                                        }
                                                        if (
CIBI == null)
                                                            break;
                                                        
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                                        
newItem.ID = CIBI.ID;
                                                        
newItem.Durability = CIBI.Durability;
                                                        
newItem.MaximDurability = CIBI.Durability;
                                                        if (
Data.Length > 3)
                                                        {
                                                            
byte plus = 0;
                                                            
byte.TryParse(Data[5], out plus);
                                                            
newItem.Plus = Math.Min((byte)12, plus);
                                                            if (
Data.Length > 4)
                                                            {
                                                                
byte bless = 0;
                                                                
byte.TryParse(Data[6], out bless);
                                                                
newItem.Bless = Math.Min((byte)7, bless);
                                                                if (
Data.Length > 5)
                                                                {
                                                                    
byte ench = 0;
                                                                    
byte.TryParse(Data[7], out ench);
                                                                    
newItem.Enchant = Math.Min((byte)255, ench);
                                                                    if (
Data.Length > 6)
                                                                    {
                                                                        
byte soc1 = 0;
                                                                        
byte.TryParse(Data[8], out soc1);
                                                                        if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc1))
                                                                        {
                                                                            
newItem.SocketOne = (Game.Enums.Gem)soc1;
                                                                        }
                                                                        if (
Data.Length > 7)
                                                                        {
                                                                            
byte soc2 = 0;
                                                                            
byte.TryParse(Data[9], out soc2);
                                                                            if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc2))
                                                                            {
                                                                                
newItem.SocketTwo = (Game.Enums.Gem)soc2;
                                                                            }
                                                                        }
                                                                        if (
Data.Length > 10)
                                                                        {
                                                                            
byte R = 0, G = 0, B = 0;
                                                                            
byte.TryParse(Data[10], out R);
                                                                            
byte.TryParse(Data[11], out G);
                                                                            
byte.TryParse(Data[12], out B);
                                                                            
newItem.SocketProgress = (uint)(B | (G << 8) | (R << 16));
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        if (
newItem.ID == 2100075)
                                                        {
                                                            
TimeSpan time = DateTime.Now.AddDays(30) - DateTime.Now;
                                                            
newItem.ItemMinutes = (uint)time.TotalMinutes;
                                                        }
                                                        
newItem.Color = (Code.Game.Enums.Color)Kernel.Random.Next(4, 8);
                                                        
Client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                                        break;
                                                    }
                                                case 
"equip":
                                                    {
                                                        
string ItemName = Data[3].ToLower();
                                                        
Game.Enums.ItemQuality Quality = Game.Enums.ItemQuality.NormalV3;
                                                        
Database.ConquerItemBaseInformation CIBI = null;
                                                        foreach (
Database.ConquerItemBaseInformation infos in Database.ConquerItemInformation.BaseInformations.Values)
                                                        {
                                                            if (
infos.LowerName == ItemName && Quality == (Game.Enums.ItemQuality)(infos.ID % 10))
                                                            {
                                                                
CIBI = infos;
                                                            }
                                                        }
                                                        if (
CIBI == null)
                                                            break;
                                                        
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                                        
newItem.ID = CIBI.ID;
                                                        
newItem.Position = 9;
                                                        
newItem.Durability = CIBI.Durability;
                                                        
newItem.MaximDurability = CIBI.Durability;
                                                        
newItem.Color = (Code.Game.Enums.Color)Kernel.Random.Next(4, 8);
                                                        
Client.Equipment.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                                        break;
                                                    }
                                                case 
"unequip":
                                                    {
                                                        foreach (var 
item in Client.Equipment.Objects)
                                                        {
                                                            
Client.Equipment.Remove((byte)item.Position);
                                                            
Database.ConquerItemTable.DeleteItem(item.ID);
                                                        }
                                                        break;
                                                    }
                                            }
                                            break;
                                        }
                                    }
                                    break;
                                }
                            
/*case "jiang":
                                {
                                    byte Stage = byte.Parse(Data[1]);
                                    if (!client.JiangPowers.Any(x => x.Stage == Stage))
                                        client.JiangPowers.Add(new JiangPowerStructure(Stage));

                                    Console.WriteLine("LOL");


                                    if (Stage == client.JiangPowers.Count && Stage == client.JiangHuStatus.Stage)
                                        client.JiangHuStatus.Stage++;

                                    for (int x = 0; x < 9; x++)
                                    {
                                        client.JiangPowers[Stage - 1].Stars[x].Value = byte.Parse(Data[2]);
                                        client.JiangPowers[Stage - 1].Stars[x].Type = byte.Parse(Data[3]);
                                    }
                                    JiangTable.AllData[client.Entity.UID] = new JiangTable.JiangData()
                                    {
                                        EntityName = client.Entity.Name,
                                        JiangHuStatus = client.JiangHuStatus,
                                        Level = client.Entity.Level,
                                        UID = client.Entity.UID,
                                        JiangPower = client.JiangPowers
                                    };

                                    JiangTable.Save(client);
                                    new JiangHu(client).QueryInfo(client);
                                    new JiangHu(client).SendInfo(13, client.JiangHuStatus.FreeCourses.ToString(), client.JiangHuStatus.Time.ToString());
                                }
                                break;
                                    */
                            
case "cps":
                                {
                                    
client.Entity.ConquerPoints = ulong.Parse(Data[1]);
                                    break;
                                }
                            case 
"Nuevaraza":
                                {
                                    
client.AddSpell(15750);
                                    
client.AddSpell(15780);
                                    
client.AddSpell(12520);
                                    
client.AddSpell(15800);
                                    
client.AddSpell(15810);
                                    
client.AddSpell(15760);
                                    
client.AddSpell(15770);
                                    break;
                                }
                            case 
"domino":
                                {
                                    
client.Entity.Domino = ulong.Parse(Data[1]);
                                    break;
                                }
                            case 
"money":
                                {
                                    
client.Entity.Money = ulong.Parse(Data[1]);
                                    break;
                                }

                            case 
"open":
                                {
                                    
MsgActionProto Action = new MsgActionProto();
                                    
Action.ID = MsgActionEmulator.OpenCustom;
                                    
Action.UID = client.Entity.UID;
                                    
Action.TimeStamp = (uint)Time32.Now.GetHashCode();
                                    
Action.dwParam = uint.Parse(Data[1]);
                                    
Action.wParam1 = client.Entity.X;
                                    
Action.wParam2 = client.Entity.Y;
                                    
client.Send(MsgActionEmulator.SendPacket(Action));
                                    break;
                                }
                            case 
"xp":
                                {
                                    
client.XPCount = 100;
                                    break;
                                }
                            case 
"who":
                                {
                                    var 
varr = Kernel.GamePool.Values.GetEnumerator();
                                    
varr.MoveNext();
                                    
int COunt = Kernel.GamePool.Count;
                                    for (
uint x = 0;
                                        
x < COunt;
                                        
x++)
                                    {
                                        if (
x >= COunt) break;

                                        
Client.GameState pClient = (varr.Current as Client.GameState);

                                        if (
pClient.Entity.Name.ToLower().Contains(Data[1]))
                                        {
                                            
client.Send(new Code.Network.GamePackets.Message("[Whois " + pClient.Entity.Name + "]", System.Drawing.Color.Gold, GamePackets.Message.FirstRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Username: " + pClient.Account.Username, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Password: " + pClient.Account.Password, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("IP: " + pClient.Account.IP, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("CPs: " + pClient.Entity.ConquerPoints, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("BoundsCps: " + pClient.Entity.BoundCps, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Money: " + pClient.Entity.Money, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Class: " + pClient.Entity.Class, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("UID: " + pClient.Entity.UID, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Level: " + pClient.Entity.Level, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Strength: " + pClient.Entity.Strength, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Agility: " + pClient.Entity.Agility, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Vitality: " + pClient.Entity.Vitality, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Spirit: " + pClient.Entity.Spirit, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Atributes: " + pClient.Entity.Atributes, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Hitpoints: " + pClient.Entity.Hitpoints, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("PKPoints: " + pClient.Entity.PKPoints, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("VIPLevel: " + pClient.Entity.VIPLevel, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Map: [" + pClient.Entity.MapID + "] " + pClient.Entity.X + "," + pClient.Entity.Y, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Frist RB: " + pClient.Entity.FirstRebornClass, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Sconed RB: " + pClient.Entity.SecondRebornClass, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("FirstRebornLevel: " + pClient.Entity.FirstRebornLevel, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("SecondRebornLevel: " + pClient.Entity.SecondRebornLevel, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));

                                        }

                                        
varr.MoveNext();
                                    }
                                    break;
                                }
                            case 
"flash":
                                {
                                    var 
varr = Kernel.GamePool.Values.GetEnumerator();
                                    
varr.MoveNext();
                                    
int COunt = Kernel.GamePool.Count;
                                    for (
uint x = 0;
                                        
x < COunt;
                                        
x++)
                                    {
                                        if (
x >= COunt) break;

                                        
Client.GameState Client = (varr.Current as Client.GameState);

                                        if (
Client.Entity.Name.ToLower().Contains(Data[1]))
                                        {
                                            
Client.Entity.AddFlag(MsgUpdate.Flags.FlashingName, 30, true);
                                            
Client.Entity.FlashingNameStamp = Time32.Now;
                                            
Client.Entity.FlashingNameTime = byte.Parse(Data[2]);
                                        }

                                        
varr.MoveNext();
                                    }

                                    break;
                                }
                            case 
"rev":
                                {
                                    
client.Entity.Action = Code.Game.Enums.ConquerAction.None;
                                    
client.ReviveStamp = Time32.Now;
                                    
client.Attackable = false;

                                    
client.Entity.TransformationID = 0;
                                    
client.Entity.RemoveFlag(MsgUpdate.Flags.Dead);
                                    
client.Entity.RemoveFlag(MsgUpdate.Flags.Ghost);
                                    
client.Entity.Hitpoints = client.Entity.MaxHitpoints;
                                    
client.Entity.LoadTopStatus();
                                    break;
                                }
                            case 
"life":
                                {
                                    
client.Entity.Hitpoints = client.Entity.MaxHitpoints;
                                    
client.Entity.LoadTopStatus();
                                    
client.Entity.Mana = client.Entity.MaxMana;
                                    break;

                                }
                            
#region stuff
                            #region stuff Command
                            
case "stuff":
                                {
                                    switch (
Data[1])
                                    {
                                        case 
"ninja":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item HanzoKatana Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item HanzoKatana Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item NightmareVest Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item NightmareHood Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item RambleVeil Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Ninja Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"leelong":
                                            {
                                                
PacketHandler.CheckCommand2("@tegotegatege HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege RidingCrop Super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege SkyNunchaku Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege SkyNunchaku Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege CombatSuit(Lv.140) Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege LegendHood Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand2("@tegotegatege FloridNecklace Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Leelong Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"monk":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item LazuritePrayerBeads Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item LazuritePrayerBeads Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item WhiteLotusFrock Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item XumiCap Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Volcano Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Monk Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"fire":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item SupremeSword Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item EternalRobe Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item DistinctCap Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item WyvernBracelet Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item SpearOfWrath Super 12 7 255 3 3", client);
                                                
PacketHandler.CheckCommand("@item NiftyBag Super 12 7 255 3 3", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A fire Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"water":
                                        case 
"toist":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item SupremeSword Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item EternalRobe Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item DistinctCap Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item WyvernBracelet Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item SpearOfWrath Super 12 7 255 73 73", client);
                                                
PacketHandler.CheckCommand("@item NiftyBag Super 12 7 255 73 73", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A water Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"warrior":
                                        case 
"worrior":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item SpearOfWrath Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item SkyBlade Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item ImperiousArmor Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item SteelHelmet Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CelestialShield Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item OccultWand Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Warrior Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"trojan":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item SkyBlade Super 12 7 250 13 13", client);
                                                
PacketHandler.CheckCommand("@item FangCrossSaber Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FangCrossSaber Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item ObsidianArmor Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item SquallSword Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item NirvanaClub Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item SkyBlade Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item SquallSword Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item NirvanaClub Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item PeerlessCoronet Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Trojan Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"archer":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item HeavenlyBow Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item WelkinCoat Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item WhiteTigerHat Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Volcano Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item HeavenPlume Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Archer Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"pirate":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0 000 103 103", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0 000 123 123", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12 000 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop super 12 0 000 00 00", client);
                                                
PacketHandler.CheckCommand("@item CaptainRapier Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item LordPistol Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item DarkDragonCoat Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item DominatorHat Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 7 255 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 7 255 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Pirate Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                    }
                                    break;
                                }
                            
#endregion

                            #endregion stuff
                            #region stuff Command
                            
case "stuff12":
                                {
                                    switch (
Data[1])
                                    {
                                        case 
"ninja":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item HanzoKatana Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item HanzoKatana Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item NightmareVest Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item NightmareHood Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item RambleVeil Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Ninja Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"monk":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item LazuritePrayerBeads Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item LazuritePrayerBeads Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item WhiteLotusFrock Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item XumiCap Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Volcano Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Monk Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"fire":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item SupremeSword Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item EternalRobe Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item DistinctCap Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item WyvernBracelet Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item SpearOfWrath Super 12 3 0 3 3", client);
                                                
PacketHandler.CheckCommand("@item NiftyBag Super 12 3 0 3 3", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Taoist Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"water":
                                        case 
"toist":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item SupremeSword Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item EternalRobe Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item DistinctCap Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item WyvernBracelet Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item SpearOfWrath Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item NiftyBag Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Taoist Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"warrior":
                                        case 
"worrior":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item SpearOfWrath Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item SkyBlade Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item ImperiousArmor Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item SteelHelmet Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CelestialShield Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item OccultWand Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Warrior Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"trojan":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item SkyBlade Super 12 7 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FangCrossSaber Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FangCrossSaber Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item ObsidianArmor Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item SquallSword Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item NirvanaClub Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item SkyBlade Super 12 7 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item SquallSword Super 12 3 2500 13 13", client);
                                                
PacketHandler.CheckCommand("@item NirvanaClub Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item PeerlessCoronet Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Trojan Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"archer":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item HeavenlyBow Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FantasyKnife Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FantasyKnife Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item WelkinCoat Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item WhiteTigerHat Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Volcano Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item HeavenPlume Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Archer Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                        case 
"pirate":
                                            {
                                                
PacketHandler.CheckCommand("@item HeavenFan Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item StarTower Super 12 0", client);
                                                
PacketHandler.CheckCommand("@item Steed Fixed 12", client);
                                                
PacketHandler.CheckCommand("@item RidingCrop Super 12", client);
                                                
PacketHandler.CheckCommand("@item CaptainRapier Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item LordPistol Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item DarkDragonCoat Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item DominatorHat Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item CrimsonRing Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item Blizzard Super 12 3 0 13 13", client);
                                                
PacketHandler.CheckCommand("@item FloridNecklace Super 12 3 0 13 13", client);
                                                
client.Send(new Code.Network.GamePackets.Message("Gratz.You Got A Pirate Stuff", System.Drawing.Color.Red, 0x7d0));
                                                break;
                                            }
                                    }
                                    break;
                                }
                            
#endregion
                            
case "testsinf":
                                {
                                    
byte[] mazen = new byte[] { 0x2C, 0x00, 0x21, 0x27, 0x58, 0xD8, 0x3B, 0x09, 0x7D, 0x92, 0x54, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x51, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72 };
                                    
Writer.WriteUInt32(client.Entity.UID, 8, mazen);
                                    
Writer.WriteUInt32((uint)Time32.timeGetTime().GetHashCode(), 4, mazen);
                                    
client.Send(mazen);
                                    
client.SendScreen(mazen, true);
                                    break;
                                }
                            case 
"testsinf1":
                                {
                                    
byte[] mazen = new byte[] { 0x2C, 0x00, 0x21, 0x27, 0x4E, 0x9E, 0x48, 0x09, 0x7D, 0x92, 0x54, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x51, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72 };
                                    
Writer.WriteUInt32(client.Entity.UID, 8, mazen);
                                    
Writer.WriteUInt32((uint)Time32.timeGetTime().GetHashCode(), 4, mazen);
                                    
client.Send(mazen);
                                    
client.SendScreen(mazen, true);
                                    break;
                                }
                            case 
"elitegw":
                                {
                                    switch (
Data[1])
                                    {
                                        case 
"on":
                                            {
                                                if (!
Game.EliteGuildWar.IsWar)
                                                {
                                                    
Game.EliteGuildWar.Start();
                                                }
                                                break;
                                            }
                                        case 
"off":
                                            {
                                                if (
Game.EliteGuildWar.IsWar)
                                                {
                                                    
Game.EliteGuildWar.End();
                                                }
                                                break;
                                            }
                                    }
                                    break;
                                }
                            case 
"guildwar":
                                {
                                    switch (
Data[1])
                                    {
                                        case 
"on":
                                            {
                                                if (!
Game.GuildWar.IsWar)
                                                {
                                                    
Game.GuildWar.Start();
                                                }
                                                break;
                                            }
                                        case 
"off":
                                            {
                                                if (
Game.GuildWar.IsWar)
                                                {
                                                    
Game.GuildWar.End();
                                                }
                                                break;
                                            }
                                    }
                                    break;
                                }
                            case 
"sguildwar":
                                {
                                    switch (
Data[1])
                                    {
                                        case 
"on":
                                            {
                                                if (!
Game.SuperGuildWar.IsWar)
                                                {
                                                    
Game.SuperGuildWar.Start();
                                                }
                                                break;
                                            }
                                        case 
"off":
                                            {
                                                if (
Game.SuperGuildWar.IsWar)
                                                {
                                                    
Game.SuperGuildWar.End();
                                                }
                                                break;
                                            }
                                    }
                                    break;
                                }
                            case 
"invisible":
                                
Console.WriteLine("Hammy");//Samak
                                
break;
                            case 
"reloadmobs":
                                {
                                    
client.Map.FreezeMonsters = true;
                                    var Clone = 
client.Map.Entities.Values.ToArray();
                                    foreach (var 
mob in Clone)
                                        if (!
mob.Companion)
                                        {
                                            
client.Map.Floor[mob.X, mob.Y, Code.Game.MapObjectType.Monster, mob] = true;
                                            
client.Map.Entities.Remove(mob.UID);
                                        }
                                    Clone = new 
Game.Entity[0];
                                    
Game.Map.EntityUIDCounter.Now = 400000;
                                    
client.Map.LoadMonsters();
                                    
client.Map.FreezeMonsters = false;
                                    foreach (
Client.GameState Client in Program.Values)
                                    {
                                        if (
Client.Map.ID == client.Map.ID)
                                        {
                                            
Client.Entity.Teleport(Client.Entity.MapID, Client.Entity.X, Client.Entity.Y);
                                        }
                                    }
                                    break;
                                }
                            case 
"mobmesh":
                                {
                                    
client.Entity.Body = ushort.Parse(Data[1]);
                                    break;
                                }
                            case 
"find":
                            case 
"trace":
                                {
                                    foreach (var 
pClient in Program.Values)
                                    {
                                        
string name = pClient.Entity.LoweredName;
                                        if (
name.Contains(Data[1]))
                                        {
                                            
client.Entity.Teleport(pClient.Entity.MapID, pClient.Entity.X, pClient.Entity.Y, false);
                                        }
                                    }
                                    break;
                                }
                            case 
"clearaccount":
                                {
//DavidEid
                                    
Code.Database.AccountTable.ClearEntityID();
                                    
client.Account.Save();
                                    break;
                                }

                            case 
"bring":
                            case 
"recall":
                                {
                                    foreach (var 
pClient in Program.Values)
                                    {
                                        if (
pClient.Entity.LoweredName.Contains(Data[1]) || Data[1].ToLower() == "all")
                                            if (
Data[1].ToLower() == "all2")
                                            {
                                                
pClient.Entity.Teleport(client.Entity.MapID,
                                                    (
ushort)Kernel.Random.Next(client.Entity.X - 5, client.Entity.X + 5),
                                                    (
ushort)Kernel.Random.Next(client.Entity.Y - 5, client.Entity.Y + 5));
                                            }
                                            else if (
Data[1].ToLower() == "all")
                                            {
                                                if (
pClient.Booth != null || pClient.Fake)
                                                    continue;
                                                
pClient.Entity.Teleport(client.Entity.MapID,
                                                    (
ushort)Kernel.Random.Next(client.Entity.X - 5, client.Entity.X + 5),
                                                    (
ushort)Kernel.Random.Next(client.Entity.Y - 5, client.Entity.Y + 5), false);
                                            }
                                            else
                                                
pClient.Entity.Teleport(client.Entity.MapID, client.Entity.X, client.Entity.Y, false);

                                    }
                                    break;
                                }
                            case 
"restart":
                                {
                                    
Program.CommandsAI("@restart");
                                    break;
                                }

                            case 
"GuildScoreWar":
                                {
                                    switch (
Data[1])
                                    {
                                        case 
"on":
                                            {
                                                if (!
GuildScoreWar.IsWar)
                                                {
                                                    
GuildScoreWar.Start();
                                                }
                                                break;
                                            }
                                        case 
"off":
                                            {
                                                if (
GuildScoreWar.IsWar)
                                                {
                                                    
GuildScoreWar.EndWar();
                                                }
                                                break;
                                            }
                                    }
                                    break;
                                }
                            case 
"potency":
                                {
                                    
client.Entity.InnerPower.AddPotency(null, client, 100000);
                                    break;
                                }
                            case 
"save":
                                {
                                    
Program.CommandsAI("@save");
                                    break;
                                }
                            case 
"exit":
                                {
                                    
Program.CommandsAI("@exit");
                                    break;
                                }
                            case 
"kick":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            
Client.Disconnect();
                                            break;
                                        }
                                    }
                                    break;
                                }
                            case 
"testspell":
                                {
                                    
SpellUse suse = new SpellUse(true);
                                    
suse.Attacker = client.Entity.UID;
                                    
suse.SpellID = ushort.Parse(Data[1]);
                                    
suse.X = client.Entity.X;
                                    
suse.Y = client.Entity.Y;
                                    
suse.Targets.Add(client.Entity.UID, 1);
                                    
client.Entity.Owner.SendScreen(suse, true);
                                    break;
                                }
                            case 
"banned":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Account.State >= client.Account.State)
                                            continue;
                                        if (
Client.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            
Client.Account.State = Database.AccountTable.AccountState.Banned;
                                            
Client.Account.SaveState();
                                            
// Client.Account.CopraState(Database.AccountTable.AccountState.Banned);
                                            //       Client["banhours"] = Data[2].Cast<int>();
                                            //       Client["banreason"] = message_.Substring(Data[0].Length + 1 + Data[1].Length + 1 + Data[2].Length + 1);
                                            //       Client["banstamp"] = DateTime.Now;

                                            
Client.Disconnect();
                                            
Kernel.SendWorldMessage(new Message(client.Account.State.ToString() + " " + client.Entity.Name + " has banned the Entity " + Client.Entity.Name, GamePackets.Message.Center));
                                            
client.Send(new Code.Network.GamePackets.Message("[Name " + Client.Entity.Name + "]", System.Drawing.Color.Gold, GamePackets.Message.FirstRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Username: " + Client.Account.Username, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Password: " + Client.Account.Password, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("IP: " + Client.Account.IP, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("CPs: " + Client.Entity.ConquerPoints, System.Drawing.Color.Gold, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Money: " + Client.Entity.Money, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            
client.Send(new Code.Network.GamePackets.Message("Map: [" + Client.Entity.MapID + "] " + Client.Entity.X + "," + Client.Entity.Y, System.Drawing.Color.Green, GamePackets.Message.ContinueRightCorner));
                                            break;
                                        }
                                    }
                                    break;
                                }
                            case 
"unban":
                                {
                                    var 
Account = new Database.AccountTable(Data[1]);
                                    if (
Account.State == Code.Database.AccountTable.AccountState.Banned)
                                    {
                                        
Account.State = Code.Database.AccountTable.AccountState.Entity;
                                        
Account.SaveState();
                                    }
                                    break;
                                }
                            case 
"banip":
                                {
                                    
string bannedIP = "";
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Account.State >= client.Account.State)
                                            continue;
                                        if (
Client.Entity.LoweredName.Contains(Data[1]))
                                        {
                                            
bannedIP = Client.Account.IP;
                                            
Client.Account.State = Database.AccountTable.AccountState.Banned;
                                            
Client.Account.SaveState();
                                            
Database.IPBan.Ban(Client.Account.IP);
                                            
Client.Disconnect();
                                            break;
                                        }
                                    }
                                    if (
bannedIP == "")
                                        
Kernel.SendWorldMessage(new Message(client.Account.State.ToString() + " " + client.Entity.Name + " has banned the IP: " + bannedIP, GamePackets.Message.Center));
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Account.State >= client.Account.State)
                                            continue;
                                        if (
Client.Account.IP == bannedIP)
                                        {
                                            
Client.Account.State = Database.AccountTable.AccountState.Banned;
                                            
Client.Account.SaveState();
                                            
Client.Disconnect();
                                        }
                                    }
                                    break;
                                }
                            case 
"unbanip":
                                {
                                    
Database.IPBan.Unban(Data[1]);
                                    break;
                                }
                            case 
"chatban":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Entity.Name.Contains(Data[1]))
                                        {
                                            
Client.ChatBanLasts = uint.Parse(Data[2]);
                                            
Client.ChatBanTime = DateTime.Now;
                                            
Client.ChatBanned = true;
                                        }
                                    }
                                    break;
                                }
                            case 
"chatunban":
                                {
                                    foreach (var 
Client in Program.Values)
                                    {
                                        if (
Client.Entity.Name.Contains(Data[1]))
                                        {
                                            
Client.ChatBanned = false;
                                        }
                                    }
                                    break;
                                }
                            case 
"bc":
                                {
                                    
Game.ConquerStructures.Broadcast.Broadcasts.Clear();
                                    
Game.ConquerStructures.Broadcast.BroadcastStr broadcast = new Code.Game.ConquerStructures.Broadcast.BroadcastStr();
                                    
broadcast.EntityID = client.Entity.UID;
                                    
broadcast.EntityName = client.Entity.Name;
                                    
broadcast.ID = Game.ConquerStructures.Broadcast.BroadcastCounter.Next;
                                    
broadcast.Message = message_.Remove(0, 2);
                                    
Kernel.SendWorldMessage(new Message(message_.Remove(0, 2), "ALLUSERS", client.Entity.Name, System.Drawing.Color.Red, GamePackets.Message.BroadcastMessage), Program.Values);
                                    
Game.ConquerStructures.Broadcast.CurrentBroadcast.EntityID = 1;
                                    
Game.ConquerStructures.Broadcast.CurrentBroadcast = broadcast;
                                    break;
                                }
                            case 
"broadcast":
                                {
                                    
Game.ConquerStructures.Broadcast.Broadcasts.Clear();
                                    
Game.ConquerStructures.Broadcast.BroadcastStr broadcast = new Code.Game.ConquerStructures.Broadcast.BroadcastStr();
                                    
broadcast.EntityID = client.Entity.UID;
                                    
broadcast.EntityName = client.Entity.Name;
                                    
broadcast.ID = Game.ConquerStructures.Broadcast.BroadcastCounter.Next;
                                    
broadcast.Message = message_.Remove(0, 9);
                                    
Kernel.SendWorldMessage(new Message(message_.Remove(0, 9), "ALLUSERS", client.Entity.Name, System.Drawing.Color.Red, GamePackets.Message.BroadcastMessage), Program.Values);
                                    
Game.ConquerStructures.Broadcast.CurrentBroadcast.EntityID = 1;
                                    
Game.ConquerStructures.Broadcast.CurrentBroadcast = broadcast;
                                    break;
                                }
                            case 
"ann":
                                {
                                    
Kernel.SendWorldMessage(new Message("[Code] by " + client.Entity.Name + ": " + Mess.Remove(0, 3), System.Drawing.Color.Red, Network.GamePackets.Message.Center), Program.Values);
                                    
Kernel.SendWorldMessage(new Message("[Code] by " + client.Entity.Name + ": " + Mess.Remove(0, 3), System.Drawing.Color.Red, Network.GamePackets.Message.World), Program.Values);
                                    break;
                                }
                            case 
"announce":
                                {
                                    
Kernel.SendWorldMessage(new Message("[Code] by " + client.Entity.Name + ": " + Mess.Remove(0, 8), System.Drawing.Color.Red, Network.GamePackets.Message.Center), Program.Values);
                                    
Kernel.SendWorldMessage(new Message("[Code] by " + client.Entity.Name + ": " + Mess.Remove(0, 8), System.Drawing.Color.Red, Network.GamePackets.Message.World), Program.Values);
                                    break;
                                }
                            case 
"arenapoints":
                                {
                                    
client.ArenaStatistic.ArenaPoints = uint.Parse(Data[1]);
                                    
client.ArenaStatistic.Send(client);
                                    break;
                                }
                            case 
"record":
                                {
                                    if (
client.Account.State != Database.AccountTable.AccountState.ProjectManager)
                                        break;
                                    switch (
Data[1])
                                    {
                                        case 
"on": client.Entity.Mode = Game.Enums.Mode.Recording; break;
                                        case 
"off": Program.CommandsAI("/saverecord"); break;
                                    } break;
                                }
                            case 
"clear":
                            case 
"clearinv":
                            case 
"clearinventory":
                                {
                                    
ConquerItem[] inventory = new ConquerItem[client.Inventory.Objects.Length];
                                    
client.Inventory.Objects.CopyTo(inventory, 0);

                                    foreach (
ConquerItem item in inventory)
                                    {
                                        
client.Inventory.Remove(item, Code.Game.Enums.ItemUse.Remove);
                                    }
                                    break;
                                }
                            case 
"online":
                                {
                                    
client.Send(new Message("Online Entitys count: " + Kernel.GamePool.Count, System.Drawing.Color.BurlyWood, GamePackets.Message.TopLeft));
                                    
string line = "";
                                    foreach (
Client.GameState pClient in Program.Values)
                                        
line += pClient.Entity.Name + ",";

                                    if (
line.Length >= 255)
                                        return 
true;
                                    
client.Send(new GamePackets.Message(line, System.Drawing.Color.Beige, GamePackets.Message.Talk));
                                    break;
                                }
                            case 
"reallot":
                                {
                                    if (
client.Entity.Reborn != 0)
                                    {
                                        
client.Entity.Agility = 0;
                                        
client.Entity.Strength = 0;
                                        
client.Entity.Vitality = 1;
                                        
client.Entity.Spirit = 0;
                                        if (
client.Entity.Reborn == 1)
                                        {
                                            
client.Entity.Atributes = (ushort)(Program.RebornInfo.ExtraAtributePoints(client.Entity.FirstRebornLevel, client.Entity.FirstRebornClass)
                             + 
52 + 3 * (client.Entity.Level - 15) + client.Entity.ExtraAtributes + client.Entity.MysteryFruit);
                                        }
                                        else
                                        {
                                            
client.Entity.Atributes = (ushort)(Program.RebornInfo.ExtraAtributePoints(client.Entity.FirstRebornLevel, client.Entity.FirstRebornClass) +
                            
Program.RebornInfo.ExtraAtributePoints(client.Entity.SecondRebornLevel, client.Entity.SecondRebornClass) + 52 + 3 * (client.Entity.Level - 15) + client.Entity.ExtraAtributes + client.Entity.MysteryFruit);
                                        }
                                        
using (var rec = new ServerSockets.RecycledPacket())
                                        {
                                            var 
stream = rec.GetStream();
                                            
client.Entity.SendUpdate(stream, client.Entity.Spirit, Game.MsgServer.MsgUpdate.DataType.Spirit);
                                            
client.Entity.SendUpdate(stream, client.Entity.Agility, Game.MsgServer.MsgUpdate.DataType.Agility);
                                            
client.Entity.SendUpdate(stream, client.Entity.Strength, Game.MsgServer.MsgUpdate.DataType.Strength);
                                            
client.Entity.SendUpdate(stream, client.Entity.Vitality, Game.MsgServer.MsgUpdate.DataType.Vitality);
                                            
client.Entity.SendUpdate(stream, client.Entity.Atributes, Game.MsgServer.MsgUpdate.DataType.Atributes);
                                        }
                                        
client.LoadItemStats();
                                    }
                                    break;
                                }
                            case 
"str":
                                {
                                    
ushort atr = 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Entity.Atributes >= atr)
                                    {
                                        
client.Entity.Strength += atr;
                                        
client.Entity.Atributes -= atr;
                                        
client.LoadItemStats();
                                    }
                                    
using (var rec = new ServerSockets.RecycledPacket())
                                    {
                                        var 
stream = rec.GetStream();
                                        
client.Entity.SendUpdate(stream, client.Entity.Spirit, Game.MsgServer.MsgUpdate.DataType.Spirit);
                                        
client.Entity.SendUpdate(stream, client.Entity.Agility, Game.MsgServer.MsgUpdate.DataType.Agility);
                                        
client.Entity.SendUpdate(stream, client.Entity.Strength, Game.MsgServer.MsgUpdate.DataType.Strength);
                                        
client.Entity.SendUpdate(stream, client.Entity.Vitality, Game.MsgServer.MsgUpdate.DataType.Vitality);
                                        
client.Entity.SendUpdate(stream, client.Entity.Atributes, Game.MsgServer.MsgUpdate.DataType.Atributes);
                                    }
                                    break;
                                }
                            case 
"agi":
                                {
                                    
ushort atr = 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Entity.Atributes >= atr)
                                    {
                                        
client.Entity.Agility += atr;
                                        
client.Entity.Atributes -= atr;
                                        
client.LoadItemStats();
                                    }
                                    
using (var rec = new ServerSockets.RecycledPacket())
                                    {
                                        var 
stream = rec.GetStream();
                                        
client.Entity.SendUpdate(stream, client.Entity.Spirit, Game.MsgServer.MsgUpdate.DataType.Spirit);
                                        
client.Entity.SendUpdate(stream, client.Entity.Agility, Game.MsgServer.MsgUpdate.DataType.Agility);
                                        
client.Entity.SendUpdate(stream, client.Entity.Strength, Game.MsgServer.MsgUpdate.DataType.Strength);
                                        
client.Entity.SendUpdate(stream, client.Entity.Vitality, Game.MsgServer.MsgUpdate.DataType.Vitality);
                                        
client.Entity.SendUpdate(stream, client.Entity.Atributes, Game.MsgServer.MsgUpdate.DataType.Atributes);
                                    }
                                    break;
                                }
                            case 
"vit":
                                {
                                    
ushort atr = 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Entity.Atributes >= atr)
                                    {
                                        
client.Entity.Vitality += atr;
                                        
client.Entity.Atributes -= atr;
                                        
client.LoadItemStats();
                                    }
                                    
using (var rec = new ServerSockets.RecycledPacket())
                                    {
                                        var 
stream = rec.GetStream();
                                        
client.Entity.SendUpdate(stream, client.Entity.Spirit, Game.MsgServer.MsgUpdate.DataType.Spirit);
                                        
client.Entity.SendUpdate(stream, client.Entity.Agility, Game.MsgServer.MsgUpdate.DataType.Agility);
                                        
client.Entity.SendUpdate(stream, client.Entity.Strength, Game.MsgServer.MsgUpdate.DataType.Strength);
                                        
client.Entity.SendUpdate(stream, client.Entity.Vitality, Game.MsgServer.MsgUpdate.DataType.Vitality);
                                        
client.Entity.SendUpdate(stream, client.Entity.Atributes, Game.MsgServer.MsgUpdate.DataType.Atributes);
                                    }
                                    break;
                                }
                            case 
"spi":
                                {
                                    
ushort atr = 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Entity.Atributes >= atr)
                                    {
                                        
client.Entity.Spirit += atr;
                                        
client.Entity.Atributes -= atr;
                                        
client.LoadItemStats();
                                    }
                                    
using (var rec = new ServerSockets.RecycledPacket())
                                    {
                                        var 
stream = rec.GetStream();
                                        
client.Entity.SendUpdate(stream, client.Entity.Spirit, Game.MsgServer.MsgUpdate.DataType.Spirit);
                                        
client.Entity.SendUpdate(stream, client.Entity.Agility, Game.MsgServer.MsgUpdate.DataType.Agility);
                                        
client.Entity.SendUpdate(stream, client.Entity.Strength, Game.MsgServer.MsgUpdate.DataType.Strength);
                                        
client.Entity.SendUpdate(stream, client.Entity.Vitality, Game.MsgServer.MsgUpdate.DataType.Vitality);
                                        
client.Entity.SendUpdate(stream, client.Entity.Atributes, Game.MsgServer.MsgUpdate.DataType.Atributes);
                                    }
                                    break;
                                }
                            case 
"egw":
                                {
                                    if (
Game.EliteGuildWar.IsWar)
                                    {
                                        
Game.EliteGuildWar.IsWar = false;
                                        
Kernel.SendWorldMessage(new Message("EliteGuild War is off!", Color.Red, 2011), Program.Values);
                                    }
                                    else
                                    {

                                        
Game.EliteGuildWar.IsWar = true;
                                        
Kernel.SendWorldMessage(new Message("Eliteguild War is on!", Color.Red, 2011), Program.Values);
                                    }
                                    break;
                                }

                            case 
"prof":
                                {
                                    
Interfaces.IProf proficiency = new GamePackets.Proficiency(true);
                                    if (
Data.Length > 1)
                                        
proficiency.ID = ushort.Parse(Data[1]);
                                    if (
Data.Length > 2)
                                        
proficiency.Level = byte.Parse(Data[2]);
                                    if (
Data.Length > 3)
                                        
proficiency.Experience = uint.Parse(Data[3]);
                                    
client.AddProficiency(proficiency);
                                    break;
                                }
                            case 
"spell":
                                {
                                    
ushort ID = 0;
                                    if (!
ushort.TryParse(Data[1], out ID))
                                    {
                                        
client.SendSysMesage("Invlid spell ID !");
                                        break;
                                    }
                                    
byte level = 0;
                                    if (!
byte.TryParse(Data[2], out level))
                                    {
                                        
client.SendSysMesage("Invlid spell Level ! ");
                                        break;
                                    }
                                    
byte levelHu = 0;
                                    if (
Data.Length >= 3)
                                    {
                                        if (!
byte.TryParse(Data[3], out levelHu))
                                        {
                                            
client.SendSysMesage("Invlid spell Level Souls ! ");
                                            break;
                                        }
                                    }
                                    
int Experience = 0;
                                    if (!
int.TryParse(Data[4], out Experience))
                                    {
                                        
client.SendSysMesage("Invlid spell Experience ! ");
                                        break;
                                    }

                                    
using (var rec = new ServerSockets.RecycledPacket())
                                        
client.MySpells.Add(rec.GetStream(), ID, level, levelHu, 0, Experience);
                                    break;
                                    
//Interfaces.ISkill spell = new GamePackets.Spell(true);
                                    //if (Data.Length > 1)
                                    //    spell.ID = ushort.Parse(Data[1]);
                                    //if (Data.Length > 2)
                                    //    spell.Level = byte.Parse(Data[2]);
                                    //if (Data.Length > 3)
                                    //    spell.Experience = uint.Parse(Data[3]);
                                    //client.AddSpell(spell);
                                    //ushort ID = 0;
                                    //if (!ushort.TryParse(Data[1], out ID))
                                    //{
                                    //    client.SendSysMesage("Invlid spell ID !");
                                    //    break;
                                    //}
                                    //byte level = 0;
                                    //if (!byte.TryParse(Data[2], out level))
                                    //{
                                    //    client.SendSysMesage("Invlid spell Level ! ");
                                    //    break;
                                    //}

                                    //using (var rec = new ServerSockets.RecycledPacket())
                                    //    client.MySpells.Add(rec.GetStream(), ID, level, 0, 0, 100);
                                    //break;
                                
}

                            case 
"level":
                                {
                                    
byte amount = 0;
                                    if (
byte.TryParse(Data[1], out amount))
                                    {
                                        
using (var rec = new ServerSockets.RecycledPacket())
                                        {
                                            var 
stream = rec.GetStream();
                                            
client.UpdateLevel(stream, amount, true);
                                        }
                                    }
                                    break;
                                }
                            case 
"class":
                                {
                                    
byte _class = client.Entity.Class;
                                    
byte.TryParse(Data[1], out _class);
                                    
_class = Math.Min((byte)165, Math.Max((byte)1, _class));
                                    
client.Entity.Class = _class;
                                    if (
client.Entity.Reborn == 0)
                                    {
                                        
Kernel.AtributeStatus.GetStatus(client.Entity);
                                        
client.LoadItemStats();
                                        
client.GemAlgorithm();
                                    }
                                    break;
                                }
                            case 
"body":
                                {
                                    
ushort body = client.Entity.Body;
                                    
ushort.TryParse(Data[1], out body);
                                    if (
body != 2005 && body != 2006 && body != 1005 && body != 1006)
                                        return 
true;
                                    
byte realgender = (byte)(client.Entity.Body % 10);
                                    
byte gender = (byte)(body % 10);
                                    if (
client.Equipment.Objects[8] != null)
                                        if (
gender >= 3 && realgender <= 2)
                                            return 
true;
                                    
client.Entity.Body = body;
                                    if (
gender >= 3 && realgender <= 2)
                                        
client.Entity.Face -= 200;
                                    if (
gender <= 2 && realgender >= 3)
                                        
client.Entity.Face += 200;
                                    break;
                                }
                            case 
"hair":
                                {
                                    
ushort hair = client.Entity.HairStyle;
                                    
ushort.TryParse(Data[1], out hair);
                                    
client.Entity.HairStyle = hair;
                                    break;
                                }
                            case 
"map":
                                {
                                    
client.Send(new Message("Map: " + client.Map.ID, System.Drawing.Color.Blue, GamePackets.Message.TopLeft));
                                    break;
                                }

                            case 
"sh":
                                {
                                    
client.Disconnect();
                                    break;
                                }
                            case 
"tele":
                                {
                                    if (
Data.Length > 3)
                                    {
                                        
client.Entity.Teleport(ushort.Parse(Data[1]), ushort.Parse(Data[2]), ushort.Parse(Data[3]));
                                    }
                                    if (
Data.Length > 4)
                                    {
                                        
client.Entity.Teleport(ushort.Parse(Data[1]), ushort.Parse(Data[2]), ushort.Parse(Data[3]), false);
                                    }
                                    break;

                                }
                            case 
"tele2":
                                {
                                    if (
Data.Length > 3)
                                    {
                                        
client.Entity.TeleportHouse(ushort.Parse(Data[1]), ushort.Parse(Data[2]), ushort.Parse(Data[3]));
                                    }
                                    break;
                                }

                            case 
"item3":
                                {
                                    
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                    
newItem.ID = uint.Parse(Data[1]);
                                    
Database.ConquerItemBaseInformation CIBI = null;
                                    
CIBI = Database.ConquerItemInformation.BaseInformations[newItem.ID];
                                    if (
CIBI == null)
                                        break;
                                    
newItem.Durability = CIBI.Durability;
                                    
newItem.MaximDurability = CIBI.Durability;
                                    if (
Data.Length > 2)
                                    {
                                        
byte plus = 0;
                                        
byte.TryParse(Data[2], out plus);
                                        
newItem.Plus = Math.Min((byte)12, plus);
                                        if (
Data.Length > 3)
                                        {
                                            
byte bless = 0;
                                            
byte.TryParse(Data[3], out bless);
                                            
newItem.Bless = Math.Min((byte)7, bless);
                                            if (
Data.Length > 4)
                                            {
                                                
byte ench = 0;
                                                
byte.TryParse(Data[4], out ench);
                                                
newItem.Enchant = Math.Min((byte)255, ench);
                                                if (
Data.Length > 5)
                                                {
                                                    
byte soc1 = 0;
                                                    
byte.TryParse(Data[5], out soc1);
                                                    if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc1))
                                                    {
                                                        
newItem.SocketOne = (Game.Enums.Gem)soc1;
                                                    }
                                                    if (
Data.Length > 6)
                                                    {
                                                        
byte soc2 = 0;
                                                        
byte.TryParse(Data[6], out soc2);
                                                        if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc2))
                                                        {
                                                            
newItem.SocketTwo = (Game.Enums.Gem)soc2;
                                                        }
                                                        if (
Data.Length > 7)
                                                        {
                                                            
byte eff = 0;
                                                            
byte.TryParse(Data[7], out eff);
                                                            if (
Enum.IsDefined(typeof(Game.Enums.ItemEffect), eff))
                                                            {
                                                                
newItem.Effect = (Game.Enums.ItemEffect)eff;
                                                            }
                                                        }
                                                    }

                                                }
                                            }
                                        }
                                    }
                                    
newItem.Color = (Code.Game.Enums.Color)Kernel.Random.Next(4, 8);
                                    
client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                    break;
                                }
                            case 
"item2":
                                {
                                    
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                    
newItem.ID = uint.Parse(Data[1]);
                                    
Database.ConquerItemBaseInformation CIBI = null;
                                    
CIBI = Database.ConquerItemInformation.BaseInformations[newItem.ID];
                                    if (
CIBI == null)
                                        break;
                                    
newItem.Durability = CIBI.Durability;
                                    
newItem.MaximDurability = CIBI.Durability;
                                    if (
Data.Length > 2)
                                    {
                                        
byte plus = 0;
                                        
byte.TryParse(Data[2], out plus);
                                        
newItem.Plus = Math.Min((byte)12, plus);
                                        if (
Data.Length > 3)
                                        {
                                            
byte bless = 0;
                                            
byte.TryParse(Data[3], out bless);
                                            
newItem.Bless = Math.Min((byte)7, bless);
                                            if (
Data.Length > 4)
                                            {
                                                
byte ench = 0;
                                                
byte.TryParse(Data[4], out ench);
                                                
newItem.Enchant = Math.Min((byte)255, ench);
                                                if (
Data.Length > 5)
                                                {
                                                    
byte soc1 = 0;
                                                    
byte.TryParse(Data[5], out soc1);
                                                    if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc1))
                                                    {
                                                        
newItem.SocketOne = (Game.Enums.Gem)soc1;
                                                    }
                                                    if (
Data.Length > 6)
                                                    {
                                                        
byte soc2 = 0;
                                                        
byte.TryParse(Data[6], out soc2);
                                                        if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc2))
                                                        {
                                                            
newItem.SocketTwo = (Game.Enums.Gem)soc2;
                                                        }
                                                    }
                                                    if (
Data.Length > 9)
                                                    {
                                                        
byte R = 0, G = 0, B = 0;
                                                        
byte.TryParse(Data[7], out R);
                                                        
byte.TryParse(Data[8], out G);
                                                        
byte.TryParse(Data[9], out B);
                                                        
newItem.SocketProgress = (uint)(B | (G << 8) | (R << 16));
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    
newItem.Color = (Code.Game.Enums.Color)Kernel.Random.Next(4, 8);
                                    
client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                    break;
                                }
                            
#region Chi
                            
case "chis":
                                {
                                    var 
Mode = int.Parse(Data[1]);
                                    var 
pos = (int)(int.Parse(Data[2]) - 1);
                                    var 
powers = client.ChiPowers[Mode - 1];
                                    var 
attributes = powers.Attributes;
                                    
attributes[pos].Type = (Enums.ChiAttribute)ushort.Parse(Data[3]);
                                    
attributes[pos].Value = (ushort)Game.Enums.ChiMaxValues(attributes[pos].Type);
                                    
powers.CalculatePoints();
                                    
Database.ChiTable.Sort((Enums.ChiPowerType)Mode);
                                    
powers.Power = (Enums.ChiPowerType)Mode;
                                    
client.Send(new ChiPowers(true).Query(client));
                                    
#region Update ranking
                                    
Database.ChiTable.ChiData[] array = null;
                                    switch ((
Enums.ChiPowerType)Mode)
                                    {
                                        case 
Game.Enums.ChiPowerType.Dragon:
                                            array = 
Database.ChiTable.Dragon;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Phoenix:
                                            array = 
Database.ChiTable.Phoenix;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Tiger:
                                            array = 
Database.ChiTable.Tiger;
                                            break;

                                        case 
Game.Enums.ChiPowerType.Turtle:
                                            array = 
Database.ChiTable.Turtle;
                                            break;
                                    }
                                    foreach (var 
chiData in array)
                                    {
                                        if (
Kernel.GamePool.ContainsKey(chiData.UID))
                                        {
                                            var 
pClient = Kernel.Values[chiData.UID];
                                            if (
pClient == null) continue;
                                            if (
pClient.ChiData == null) continue;
                                            
SendRankingQuery(new GenericRanking(true) { Mode = GenericRanking.QueryCount }, pClient, GenericRanking.Chi + (uint)Mode, pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode), pClient.ChiData.SelectPoints((Enums.ChiPowerType)Mode));
                                            if (
pClient.Entity.UID == client.Entity.UID || pClient.ChiData.SelectRank((Enums.ChiPowerType)Mode) < 50)
                                                
pClient.LoadItemStats();
                                        }
                                    }
                                    
#endregion
                                    
Database.ChiTable.Save(client);
                                }
                                break;
                            
#endregion
                            
case "item":
                                {
                                    if (
Data.Length > 2)
                                    {
                                        
string ItemName = Data[1].ToLower();
                                        
Game.Enums.ItemQuality Quality = Game.Enums.ItemQuality.Fixed;
                                        switch (
Data[2].ToLower())
                                        {
                                            case 
"fixed": Quality = Game.Enums.ItemQuality.Fixed; break;
                                            case 
"normal": Quality = Game.Enums.ItemQuality.Normal; break;
                                            case 
"normalv1": Quality = Game.Enums.ItemQuality.NormalV1; break;
                                            case 
"normalv2": Quality = Game.Enums.ItemQuality.NormalV2; break;
                                            case 
"normalv3": Quality = Game.Enums.ItemQuality.NormalV3; break;
                                            case 
"refined": Quality = Game.Enums.ItemQuality.Refined; break;
                                            case 
"unique": Quality = Game.Enums.ItemQuality.Unique; break;
                                            case 
"elite": Quality = Game.Enums.ItemQuality.Elite; break;
                                            case 
"super": Quality = Game.Enums.ItemQuality.Super; break;
                                            case 
"other": Quality = Game.Enums.ItemQuality.Other; break;
                                            default:
                                                {
                                                    
Quality = (Code.Game.Enums.ItemQuality)int.Parse(Data[2]);
                                                    break;
                                                }
                                        }
                                        
Database.ConquerItemBaseInformation CIBI = null;
                                        foreach (
Database.ConquerItemBaseInformation infos in Database.ConquerItemInformation.BaseInformations.Values)
                                        {
                                            if (
infos.LowerName == ItemName && Quality == (Game.Enums.ItemQuality)(infos.ID % 10))
                                            {
                                                
CIBI = infos;
                                            }
                                        }
                                        if (
CIBI == null)
                                            break;
                                        
ConquerItem newItem = new GamePackets.ConquerItem(true);
                                        
newItem.ID = CIBI.ID;
                                        
newItem.Durability = CIBI.Durability;
                                        
newItem.MaximDurability = CIBI.Durability;
                                        if (
Data.Length > 3)
                                        {
                                            
byte plus = 0;
                                            
byte.TryParse(Data[3], out plus);
                                            
newItem.Plus = Math.Min((byte)12, plus);
                                            if (
Data.Length > 4)
                                            {
                                                
byte bless = 0;
                                                
byte.TryParse(Data[4], out bless);
                                                
newItem.Bless = Math.Min((byte)7, bless);
                                                if (
Data.Length > 5)
                                                {
                                                    
byte ench = 0;
                                                    
byte.TryParse(Data[5], out ench);
                                                    
newItem.Enchant = Math.Min((byte)255, ench);
                                                    if (
Data.Length > 6)
                                                    {
                                                        
byte soc1 = 0;
                                                        
byte.TryParse(Data[6], out soc1);
                                                        if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc1))
                                                        {
                                                            
newItem.SocketOne = (Game.Enums.Gem)soc1;
                                                        }
                                                        if (
Data.Length > 7)
                                                        {
                                                            
byte soc2 = 0;
                                                            
byte.TryParse(Data[7], out soc2);
                                                            if (
Enum.IsDefined(typeof(Game.Enums.Gem), soc2))
                                                            {
                                                                
newItem.SocketTwo = (Game.Enums.Gem)soc2;
                                                            }
                                                        }
                                                        if (
Data.Length > 10)
                                                        {
                                                            
byte R = 0, G = 0, B = 0;
                                                            
byte.TryParse(Data[8], out R);
                                                            
byte.TryParse(Data[9], out G);
                                                            
byte.TryParse(Data[10], out B);
                                                            
newItem.SocketProgress = (uint)(B | (G << 8) | (R << 16));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        
newItem.Color = (Code.Game.Enums.Color)Kernel.Random.Next(4, 8);
                                        
//    if (client.Account.State == Code.Database.AccountTable.AccountState.GameMaster)
                                        //   newItem.Bound = true;
                                        
client.Inventory.Add(newItem, Game.Enums.ItemUse.CreateAndAdd);
                                    }
                                    break;
                                }

                        }
                        return 
true;
                    }
                    
#endregion 

وحط دول كل الشفرات وامسح الشفرات الي مش عايزه تشتغل عن البي ام
وفي النفي كات في الاكونت حط 3 بدل 4