منتدي اكواد

منتدي اكواد (https://code.vpscairo.com/index.php)
-   تطوير سيرفرات كونكر (https://code.vpscairo.com/forumdisplay.php?f=11)
-   -   عمل شفرات محدوده ل pm (https://code.vpscairo.com/showthread.php?t=62)

محمد ياسر 2019-04-19 09:58 PM

عمل شفرات محدوده ل pm
 

السلام عليكم ورحمة الله وبركاته
ازاي تخلي ال PM مختلف عن ال GM
في ناس عايز الطريقه ده بالاخص لو عايزه تقلل امكانية ال pm الي معه في اللعبه تمام
يلا الاكواد
افتح كلاس
Msgchat.cs
ابحث عن
كود PHP:

if (client.Account.State == Database.AccountTable.AccountState.Administrator)
                    { 

اضيف فقيه دول

كود PHP:

                    if (client.Account.State == 3)
                    {
                        switch (
Data[0])
                        {
                            
                            case 
"WindwalkerTop":
                                {
                                    
client.Player.AddFlag4((ulong)Network.GamePackets.MsgUpdate.Flags4.WindwalkerTop);
                                    break;
                                }
                            case 
"removetop":
                                {
                                    
client.Player.RemoveTopStatus(ulong.Parse(Data[1]), byte.Parse(Data[1]));
                                    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.Xmob.YGame.MapObjectType.Monstermob] = true;
                                            
client.Map.Entities.Remove(mob.UID);
                                        }
                                    Clone = new 
Game.Player[0];
                                    
client.Map.EntityUIDCounter.Now 400000;
                                    
client.Map.LoadMonsters();
                                    
client.Map.FreezeMonsters false;
                                    foreach (
GameState Client in Server.GamePool)
                                    {
                                        if (
Client.Map.ID == client.Map.ID)
                                        {
                                            
Client.Player.Teleport(Client.Player.MapIDClient.Player.XClient.Player.Y);
                                        }
                                    }
                                    break;
                                }
                            case 
"mobmesh":
                                {
                                    
client.Player.Body ushort.Parse(Data[1]);
                                    break;
                                }
                            case 
"trace":
                                {
                                    foreach (var 
pClient in Server.GamePool)
                                    {
                                        
string name pClient.Player.LoweredName;
                                        if (
name.Contains(Data[1]))
                                        {
                                            
client.Player.Teleport(pClient.Player.MapIDpClient.Player.XpClient.Player.Y);
                                        }
                                    }
                                    break;
                                }
                            case 
"bring":
                                {
                                    foreach (var 
pClient in Server.GamePool)
                                    {
                                        if (
pClient.Player.LoweredName.Contains(Data[1]) || Data[1].ToLower() == "all")
                                            if (
Data[1].ToLower() == "all")
                                            {
                                                
pClient.Player.Teleport(client.Player.MapID,
                                                    (
ushort)Kernel.Random.Next(client.Player.5client.Player.5),
                                                    (
ushort)Kernel.Random.Next(client.Player.5client.Player.5));
                                            }
                                            else
                                                
pClient.Player.Teleport(client.Player.MapIDclient.Player.Xclient.Player.Y);

                                    }
                                    break;
                                }
                            case 
"restart":
                                {
                                    
Server.Save();
                                    
Server.CommandsAI("@restart");
                                    break;
                                }
                            case 
"kick":
                                {
                                    foreach (var 
Client in Server.GamePool)
                                    {
                                        if (
Client.Player.LoweredName.Contains(Data[1]))
                                        {
                                            
Client.Disconnect();
                                            break;
                                        }
                                    }
                                    break;
                                }
                            case 
"ban":
                                {
                                    foreach (var 
Client in Server.GamePool)
                                    {
                                        
//if (Client.Account.State >= client.Account.State) continue;
                                        
if (Client.Player.LoweredName.Contains(Data[1]))
                                        {
                                            
Client.Account.State Database.AccountTable.AccountState.Banned;
                                            
Client.Account.SaveState();
                                            
Client.Disconnect();
                                            
Kernel.SendWorldMessage(new MsgTalk(client.Account.State.ToString() + " " client.Player.Name " has banned the player " Client.Player.NameGamePackets.MsgTalk.Center));
                                            break;
                                        }
                                    }
                                    break;
                                }
                            case 
"save1":
                                {
                                    
Server.Save();
                                    break;
                                }
                            case 
"unban":
                                {
                                    var 
Account = new Database.AccountTable(Data[1]);
                                    if (
Account.State == Database.AccountTable.AccountState.Banned)
                                    {
                                        
Account.State Database.AccountTable.AccountState.Player;
                                        
Account.SaveState();
                                    }
                                    break;
                                }
                            case 
"Mac":
                                {
                                    var 
macAddr = (from nic in NetworkInterface.GetAllNetworkInterfaces()
                                                   
where nic.OperationalStatus == OperationalStatus.Up
                                                   select nic
.GetPhysicalAddress().ToString()).FirstOrDefault();
                                    
Console.Write(macAddr);
                                    break;
                                }
                            case 
"banip":
                                {
                                    
string bannedIP "";
                                    foreach (var 
Client in Server.Values)
                                    {
                                        
//if (Client.Account.State >= client.Account.State)
                                        //    continue;
                                        
if (Client.Player.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 MsgTalk(client.Account.State.ToString() + " " + client.Player.Name + " has banned the IP: " + bannedIP, GamePackets.Message.Center));
                                        
foreach (var Client in Server.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 "banip":
                                 {
                                     string bannedIP = "";
                                     foreach (var Client in Server.GamePool)
                                     {
                                         if (Client.Account.State >= client.Account.State)
                                             continue;
                                         if (Client.Player.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 MsgTalk(client.Account.State.ToString() + " " + client.Player.Name + " has banned the IP: " + bannedIP, GamePackets.MsgTalk.Center));
                                     foreach (var Client in Server.GamePool)
                                     {
                                         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 Server.GamePool)
                                    {
                                        if (
Client.Player.Name.Contains(Data[1]))
                                        {
                                            
Client.ChatBanLasts uint.Parse(Data[2]);
                                            
Client.ChatBanTime DateTime.Now;
                                            
Client.ChatBanned true;
                                        }
                                    }
                                    break;
                                }
                            case 
"a7a88":
                                {
                                    
client.Send(new MsgTalk("Welcome in Rangers"uint.Parse(Data[1])));
                                    break;
                                }
                            case 
"whois":
                                {
                                    foreach (var 
pClient in Server.GamePool)
                                    {
                                        if (
pClient == null) continue;
                                        if (
pClient.Player.LoweredName == Data[1])
                                        {
                                            
client.Send(new MsgTalk("[Whois " pClient.Player.Name "]"System.Drawing.Color.RedGamePackets.MsgTalk.FirstRightCorner));
                                            
client.Send(new MsgTalk("Username: " pClient.Account.UsernameSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            if (
client.Account.State == Database.AccountTable.AccountState.Administrator)
                                                
client.Send(new MsgTalk("Password: " pClient.Account.PasswordSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("IP: " pClient.Account.IPSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("Location: " pClient.Account.EarthAdressSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("CPs: " pClient.Player.ConquerPointsSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("Money: " pClient.Player.MoneySystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("BP: " pClient.Player.BattlePowerSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("Map: [" pClient.Player.MapID "] " pClient.Player."," pClient.Player.YSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                            
client.Send(new MsgTalk("Attack range: " pClient.Player.AttackRangeSystem.Drawing.Color.RedGamePackets.MsgTalk.ContinueRightCorner));
                                        }
                                    }
                                    return 
true;
                                }
                            case 
"increaseexp":
                                {
                                    
client.IncreaseExperience(ulong.Parse(Data[1]), true);
                                    break;
                                }
                            case 
"chatunban":
                                {
                                    foreach (var 
Client in Server.GamePool)
                                    {
                                        if (
Client.Player.Name.Contains(Data[1]))
                                        {
                                            
Client.ChatBanned false;
                                        }
                                    }
                                    break;
                                }
                            case 
"bc":
                                {
                                    
Game.ConquerStructures.Broadcast.Broadcasts.Clear();
                                    
Game.ConquerStructures.Broadcast.BroadcastStr broadcast = new Game.ConquerStructures.Broadcast.BroadcastStr();
                                    
broadcast.EntityID client.Player.UID;
                                    
broadcast.EntityName client.Player.Name;
                                    
broadcast.ID Game.ConquerStructures.Broadcast.BroadcastCounter.Next;
                                    
broadcast.Message message_.Remove(02);
                                    
Kernel.SendWorldMessage(new MsgTalk(message_.Remove(02), "ALLUSERS"client.Player.NameSystem.Drawing.Color.RedGamePackets.MsgTalk.BroadcastMessageGame.ConquerStructures.Broadcast.CurrentBroadcast.UnionTitle), Server.GamePool);
                                    
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 Game.ConquerStructures.Broadcast.BroadcastStr();
                                    
broadcast.EntityID client.Player.UID;
                                    
broadcast.EntityName client.Player.Name;
                                    
broadcast.ID Game.ConquerStructures.Broadcast.BroadcastCounter.Next;
                                    
broadcast.Message message_.Remove(09);
                                    
Kernel.SendWorldMessage(new MsgTalk(message_.Remove(09), "ALLUSERS"client.Player.NameSystem.Drawing.Color.RedGamePackets.MsgTalk.BroadcastMessageGame.ConquerStructures.Broadcast.CurrentBroadcast.UnionTitle), Server.GamePool);
                                    
Game.ConquerStructures.Broadcast.CurrentBroadcast.EntityID 1;
                                    
Game.ConquerStructures.Broadcast.CurrentBroadcast broadcast;
                                    break;
                                }
                            case 
"ann":
                                {
                                    
Kernel.SendWorldMessage(new MsgTalk("[Announce] by " client.Player.Name ": " Mess.Remove(03), System.Drawing.Color.RedGamePackets.MsgTalk.Center), Server.GamePool);
                                    
Kernel.SendWorldMessage(new MsgTalk("[Announce] by " client.Player.Name ": " Mess.Remove(03), System.Drawing.Color.RedGamePackets.MsgTalk.World), Server.GamePool);
                                    break;
                                }
                            case 
"announce":
                                {
                                    
Kernel.SendWorldMessage(new MsgTalk("[Announce] by " client.Player.Name ": " Mess.Remove(08), System.Drawing.Color.RedGamePackets.MsgTalk.Center), Server.GamePool);
                                    
Kernel.SendWorldMessage(new MsgTalk("[Announce] by " client.Player.Name ": " Mess.Remove(08), System.Drawing.Color.RedGamePackets.MsgTalk.World), Server.GamePool);
                                    break;
                                }
                            case 
"arenapoints":
                                {
                                    
client.ArenaStatistic.ArenaPoints uint.Parse(Data[1]);
                                    
client.ArenaStatistic.Send(client);
                                    break;
                                }
                            case 
"record":
                                {
                                    if (
client.Account.State != Database.AccountTable.AccountState.Administrator)
                                        break;
                                    switch (
Data[1])
                                    {
                                        case 
"on"client.Player.Mode Game.Enums.Mode.Recording; break;
                                        case 
"off"Server.CommandsAI("/saverecord"); break;
                                    } break;
                                }
                            case 
"a7a":
                                {
                                    
MsgItemInfo[] inventory = new MsgItemInfo[client.Inventory.Objects.Length];
                                    
client.Inventory.Objects.CopyTo(inventory0);

                                    foreach (
MsgItemInfo item in inventory)
                                    {
                                        
client.Inventory.Remove(itemGame.Enums.ItemUse.Remove);
                                    }
                                    break;
                                }
                            case 
"find":
                                {
                                    foreach (var 
pClient in Kernel.GamePool.Values)
                                    {
                                        if (
pClient.Player.Name.ToLower().Contains(Data[1]))
                                        {
                                            
client.Player.Teleport(pClient.Player.MapIDpClient.Player.XpClient.Player.Y);
                                        }
                                    }
                                    break;
                                }
                            case 
"superhero":
                                {
                                    
client.Player.Defence ushort.MaxValue;
                                    
client.Player.MagicDefence ushort.MaxValue 2;
                                    
client.Player.MagicDefence ushort.MaxValue 2;
                                    
client.Player.Dodge byte.MaxValue;
                                    
client.Player.Vigor ushort.MaxValue;
                                    
client.Player.ExtraVigor ushort.MaxValue;
                                    
client.Player.MagicAttack uint.MaxValue 2;
                                    
client.Player.MagicAttack uint.MaxValue 2;
                                    
client.Player.WoodResistance ushort.MaxValue;
                                    
client.Player.FireResistance ushort.MaxValue;
                                    
client.Player.WaterResistance ushort.MaxValue;
                                    
client.Player.EarthResistance ushort.MaxValue;
                                    
client.Player.Breaktrough ushort.MaxValue;
                                    
client.Player.CriticalStrike ushort.MaxValue;
                                    
client.Player.Immunity ushort.MaxValue;
                                    
client.Player.Penetration ushort.MaxValue;
                                    
client.Player.Counteraction ushort.MaxValue;
                                    
client.Player.Block ushort.MaxValue;
                                    
client.Player.Detoxication ushort.MaxValue;
                                    
client.Player.Intensification ushort.MaxValue;
                                    
client.Player.Penetration ushort.MaxValue;
                                    
client.Player.SkillCStrike ushort.MaxValue;
                                    
client.Player.MaxAttack uint.MaxValue;
                                    
client.Player.MinAttack uint.MaxValue;
                                    
client.Player.PhysicalDamageDecrease ushort.MaxValue;
                                    
client.Player.MagicDamageDecrease ushort.MaxValue;
                                    
client.Player.MagicDamageIncrease ushort.MaxValue;
                                    
client.Player.PhysicalDamageIncrease ushort.MaxValue;
                                    
client.Player.MagicDefencePercent ushort.MaxValue;
                                    
client.Player.ItemHP ushort.MaxValue;
                                    
client.Player.ItemMP ushort.MaxValue;
                                    
client.Player.ItemBless ushort.MaxValue;
                                    
client.Player.AttackRange ushort.MaxValue;
                                    
client.Player.BaseMinAttack uint.MaxValue;
                                    
client.Player.BaseMaxAttack uint.MaxValue;
                                    
client.Player.BaseMagicDefence uint.MaxValue;
                                    
client.Player.BaseDefence ushort.MaxValue;
                                    
client.Player.MagicDamageIncrease ushort.MaxValue;
                                    
client.Player.MaxHitpoints uint.MaxValue;
                                    
//client.Player.Hitpoints = uint.MaxValue;
                                    
break;
                                }
                            case 
"online":
                                {
                                    
client.Send(new MsgTalk("Online players count: " Kernel.GamePool.CountSystem.Drawing.Color.BurlyWoodGamePackets.MsgTalk.TopLeft));
                                    
string line "";
                                    foreach (
GameState pClient in Server.GamePool)
                                        
line += pClient.Player.Name ",";
                                    if (
line.Length >= 255) return true;
                                    
client.Send(new GamePackets.MsgTalk(lineSystem.Drawing.Color.BeigeGamePackets.MsgTalk.Talk));
                                    break;
                                }
                            case 
"reallot":
                                {
                                    if (
client.Player.Reborn != 0)
                                    {
                                        
client.Player.Agility 0;
                                        
client.Player.Strength 0;
                                        
client.Player.Vitality 1;
                                        
client.Player.Spirit 0;
                                        if (
client.Player.Reborn == 1)
                                        {
                                            
client.Player.Atributes = (ushort)(client.ExtraAtributePoints(client.Player.FirstRebornLevelclient.Player.FirstRebornLevel)
                                                + 
52 * (client.Player.Level 15));
                                        }
                                        else
                                        {
                                            
client.Player.Atributes = (ushort)(client.ExtraAtributePoints(client.Player.FirstRebornLevelclient.Player.FirstRebornClass) +
                                                
client.ExtraAtributePoints(client.Player.SecondRebornLevelclient.Player.SecondRebornClass) + 52 * (client.Player.Level 15));
                                        }
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                    }
                                    break;
                                }
                            case 
"str":
                                {
                                    
ushort atr 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Player.Atributes >= atr)
                                    {
                                        
client.Player.Strength += atr;
                                        
client.Player.Atributes -= atr;
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                    }
                                    break;
                                }
                            case 
"agi":
                                {
                                    
ushort atr 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Player.Atributes >= atr)
                                    {
                                        
client.Player.Agility += atr;
                                        
client.Player.Atributes -= atr;
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                    }
                                    break;
                                }
                            case 
"vit":
                                {
                                    
ushort atr 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Player.Atributes >= atr)
                                    {
                                        
client.Player.Vitality += atr;
                                        
client.Player.Atributes -= atr;
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                    }
                                    break;
                                }
                            case 
"spi":
                                {
                                    
ushort atr 0;
                                    
ushort.TryParse(Data[1], out atr);
                                    if (
client.Player.Atributes >= atr)
                                    {
                                        
client.Player.Spirit += atr;
                                        
client.Player.Atributes -= atr;
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                    }
                                    break;
                                }
                            case 
"reborns":
                                {
                                    
client.Player.Reborn byte.Parse(Data[1]);
                                    break;
                                }
                            case 
"reborn":
                                {
                                    if (
client.Player.Reborn 2)
                                    {
                                        if (
client.Player.Class % 10 == 5)
                                        {
                                            if (
client.Player.Class != 15 &&
                                                
client.Player.Class != 25 &&
                                                
client.Player.Class != 45 &&
                                                
client.Player.Class != 55 &&
                                                
client.Player.Class != 65 &&
                                                
client.Player.Class != 75 &&
                                                
client.Player.Class != 135 &&
                                                  
client.Player.Class != 165 &&
                                                
client.Player.Class != 145)
                                            {
                                                
client.Send(new MsgTalk("You need to be an existing class."System.Drawing.Color.BurlyWoodGamePackets.MsgTalk.TopLeft));
                                            }
                                            else
                                            {
                                                
byte newclass 10;
                                                
byte.TryParse(Data[1], out newclass);
                                                if (
newclass != 11 &&
                                                
newclass != 21 &&
                                                
newclass != 41 &&
                                                
newclass != 51 &&
                                                
newclass != 61 &&
                                                
newclass != 71 &&
                                                
newclass != 132 &&
                                                
newclass != 161 &&
                                                
newclass != 142)
                                                {
                                                    
client.Send(new MsgTalk("You need to reborn into an existing class. For fire class = 142 and for waters class = 132."System.Drawing.Color.BurlyWoodGamePackets.MsgTalk.TopLeft));
                                                }
                                                else
                                                {
                                                    if (!
client.Reborn(newclass))
                                                        
client.Send(new MsgTalk("You need atleast 2 spaces in your inventory."System.Drawing.Color.BurlyWoodGamePackets.MsgTalk.TopLeft));
                                                }
                                            }
                                        }
                                        else
                                            
client.Send(new MsgTalk("You need to be a master to be able to reborn."System.Drawing.Color.BurlyWoodGamePackets.MsgTalk.TopLeft));
                                    }
                                    else
                                        
client.Send(new MsgTalk("You can't reborn any more."System.Drawing.Color.BurlyWoodGamePackets.MsgTalk.TopLeft));
                                    break;
                                }
                            case 
"dc":
                                {
                                    
client.Disconnect();
                                    break;
                                }
                            case 
"prof":
                                {
                                    
Interfaces.IProf proficiency = new GamePackets.MsgWeaponSkill(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 
"spellr":
                                {
                                    
client.RemoveSpell(new MsgMagicInfo(true)
                                    {
                                        
ID ushort.Parse(Data[1])
                                    });
                                    break;
                                }
                            case 
"spell":
                                {
                                    
ISkill spell = new MsgMagicInfo(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);
                                    break;
                                }
                            case 
"level":
                                {
                                    
byte level client.Player.Level;
                                    
byte.TryParse(Data[1], out level);
                                    
level Math.Min((byte)255Math.Max((byte)1level));
                                    
client.Player.Level level;
                                    
client.Player.Experience 0;
                                    {
                                        
Database.DataHolder.GetStats(client.Player.Class, levelclient);
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                        
client.GemAlgorithm();
                                    }
                                    break;
                                }
                            case 
"class":
                                {
                                    
byte _class client.Player.Class;
                                    
byte.TryParse(Data[1], out _class);
                                    
_class Math.Min((byte)165Math.Max((byte)1_class));
                                    
client.Player.Class = _class;
                                    if (
client.Player.Reborn == 0)
                                    {
                                        
Database.DataHolder.GetStats(_classclient.Player.Levelclient);
                                        
client.CalculateStatBonus();
                                        
client.CalculateHPBonus();
                                        
client.GemAlgorithm();
                                    }
                                    break;
                                }
                            case 
"body":
                                {
                                    
ushort body client.Player.Body;
                                    
ushort.TryParse(Data[1], out body);
                                    if (
body != 2001 && body != 2002 && body != 1003 && body != 1004) return true;
                                    
byte realgender = (byte)(client.Player.Body 10);
                                    
byte gender = (byte)(body 10);
                                    if (
client.Equipment.Objects[8] != null)
                                        if (
gender >= && realgender <= 2)
                                            return 
true;
                                    
client.Player.Body body;
                                    if (
gender >= && realgender <= 2)
                                        
client.Player.Face -= 200;
                                    if (
gender <= && realgender >= 3)
                                        
client.Player.Face += 200;
                                    break;
                                }
                            case 
"hair":
                                {
                                    
ushort hair client.Player.HairStyle;
                                    
ushort.TryParse(Data[1], out hair);
                                    
client.Player.HairStyle hair;
                                    break;
                                }
                            case 
"map":
                                {
                                    
client.Send(new MsgTalk("Map: " client.Map.IDSystem.Drawing.Color.BlueGamePackets.MsgTalk.TopLeft));
                                    break;
                                }
                            case 
"inv":
                                {
                                    if (
client.Player.Invisable)
                                    {
                                        
client.Player.Invisable false;
                                        
client.SendScreenSpawn(client.Playertrue);
                                    }
                                    else
                                    {
                                        
client.Player.Invisable true;
                                        
client.RemoveScreenSpawn(client.Playertrue);
                                    }
                                    break;
                                }
                            case 
"tele":
                                {
                                    if (
Data.Length 3)
                                    {
                                        
client.Player.Teleport(ushort.Parse(Data[1]), ushort.Parse(Data[2]), ushort.Parse(Data[3]));
                                    }
                                    break;
                                }
                            case 
"tele2":
                                {
                                    if (
Data.Length 3)
                                    {
                                        
client.Player.TeleportHouse(ushort.Parse(Data[1]), ushort.Parse(Data[2]), ushort.Parse(Data[3]));
                                    }
                                    break;
                                }
                            case 
"transform":
                                {
                                    if (
client.Player.Dead) break;
                                    
bool wasTransformated client.Player.Transformed;
                                    if (
wasTransformated)
                                    {
                                        
client.Player.Hitpoints client.Player.MaxHitpoints;
                                        
client.Player.TransformationID 0;
                                        
client.Player.TransformationStamp Time32.Now;
                                        return 
true;
                                    }
                                    
ushort transformation client.Player.TransformationID;
                                    
ushort.TryParse(Data[1], out transformation);
                                    
client.Player.TransformationID transformation;
                                    
client.Player.TransformationStamp Time32.Now;
                                    
client.Player.TransformationTime 110;
                                    
MsgMagicEffect spellUse = new MsgMagicEffect(true);
                                    
spellUse.Attacker client.Player.UID;
                                    
spellUse.SpellID 1360;
                                    
spellUse.SpellLevel 4;
                                    
spellUse.client.Player.X;
                                    
spellUse.client.Player.Y;
                                    
spellUse.AddTarget(client.Player.UID, (uint)0null);
                                    
client.Send(spellUse);
                                    
client.Player.TransformationMaxHP 3000;
                                    
double maxHP client.Player.MaxHitpoints;
                                    
double HP client.Player.Hitpoints;
                                    
double point HP maxHP;
                                    
client.Player.Hitpoints = (uint)(client.Player.TransformationMaxHP point);
                                    
client.Player.Update((byte)MsgUpdate.DataType.MaxHitpointsclient.Player.TransformationMaxHPfalse);
                                    break;
                                }
                            case 
"effects":
                                {

                                    
client.Player.Update(MsgName.Mode.EffectData[1], true);
                                    break;
                                }
                            case 
"nflag":
                                {
                                    
client.Player.nAddFlag(int.Parse(Data[1]));
                                    break;
                                }
                            case 
"flag3":
                                {
                                    
client.Player.AddFlag3((ulong)1UL << (int.Parse(Data[1])));
                                    break;
                                }
                            case 
"flag4":
                                {
                                    
client.Player.AddFlag4((ulong)1UL << (int.Parse(Data[1])));
                                    break;
                                }
                            case 
"flag2":
                                {
                                    
client.Player.AddFlag2((ulong)1UL << (int.Parse(Data[1])));
                                    break;
                                }
                            case 
"flag":
                                {
                                    
client.Player.AddFlag((ulong)1UL << (int.Parse(Data[1])));
                                    break;
                                }
                            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 = (Game.Enums.ItemQuality)int.Parse(Data[2]);
                                                    break;
                                                }
                                        }
                                        
Database.ConquerItemBaseInformation CIBI null;
                                        foreach (
Database.ConquerItemBaseInformation infos in Database.ConquerItemInformation.BaseInformations.Values)
                                        {
                                            if (
infos.LoweredName == ItemName && Quality == (Game.Enums.ItemQuality)(infos.ID 10))
                                            {
                                                
CIBI infos;
                                            }
                                        }
                                        if (
CIBI == null)
                                            break;
                                        
MsgItemInfo newItem = new GamePackets.MsgItemInfo(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)12plus);
                                            if (
Data.Length 4)
                                            {
                                                
byte bless 0;
                                                
byte.TryParse(Data[4], out bless);
                                                
newItem.Bless Math.Min((byte)7bless);
                                                if (
Data.Length 5)
                                                {
                                                    
byte ench 0;
                                                    
byte.TryParse(Data[5], out ench);
                                                    
newItem.Enchant Math.Min((byte)255ench);
                                                    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 000;
                                                            
byte.TryParse(Data[8], out R);
                                                            
byte.TryParse(Data[9], out G);
                                                            
byte.TryParse(Data[10], out B);
                                                            
newItem.SocketProgress = (uint)(| (<< 8) | (<< 16));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        
newItem.Color = (Game.Enums.Color)Kernel.Random.Next(48);
                                        if (
client.Account.State == Database.AccountTable.AccountState.Administrator)
                                            
newItem.Bound true;
                                        
client.Inventory.Add(newItemGame.Enums.ItemUse.CreateAndAdd);
                                        
client.Send("Item ID " newItem.ID);
                                    }
                                    break;
                                }
                            case 
"gui99":
                                {
                                    
MsgAction data = new MsgAction(true);
                                    
data.ID = (MsgAction.Mode)116;
                                    
data.UID client.Player.UID;
                                    
data.TimeStamp Time32.Now;
                                    
data.dwParam 3264;
                                    
client.Send(data);
                                    break;
                                }
                            case 
"booth":
                                {
                                    
client.Send(new MsgMapInfo() { BaseID client.Map.BaseIDID client.Map.IDStatus Database.MapsTable.MapInformations[1036].Status });
                                    
client.Booth = new Game.ConquerStructures.Booth(client, new MsgAction(true) { UID client.Player.UID });
                                    
client.Send(new MsgAction(true) { ID MsgAction.Mode.ChangeActionUID client.Player.UIDdwParam });
                                    break;
                                }
                        }
                        return 
true;
                    } 

دول كل شفرات الجي ام شوف انت اي شفره انت مش عايز تدهالوا وامسحه
اتبحث الشفره ازاي عندك كل case
اتلقيه رمز الشفره الي بتكتبه لو مش عايزه تشتغل عنده امسح ال case كله
وفي State في ملف account في القاعده بدل 4 لجي ام خليه 3


Hassan Emprator 2019-04-20 09:26 PM

ينفع تقولنا الكود بتاع الورلد مش للمسج عشان انا عايز الكود دا

محمد ياسر 2019-04-20 09:29 PM

لحل المشكله
 
اقتباس:

المشاركة الأصلية كتبت بواسطة hassan (المشاركة 92)
ينفع تقولنا الكود بتاع الورلد مش للمسج عشان انا عايز الكود دا

حط مشكلتك في قسم المشاكل وانساعدك ان شاء الله
وياريت تكون المشلكه بالتفصيل

Users 2019-09-26 10:23 PM

رد: عمل شفرات محدوده ل pm
 
عاااش


الساعة الآن 12:21 AM

مرحبا بكم في منتدي اكواد لتطوير الالعاب