منتدي اكواد

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

محمد ياسر 2019-04-23 03:20 PM

حل مشكله السوكت فى الجناح والاسطفه العاديه
 

الموضوع ده علشان احمد الاسيوطي
ولكل الناس الي عايزه حل لمشكلة السوكت
بوص يا سيدى الحل هتخوش على الباكت هاندر وهتبحث عن الكود ده
كود PHP:

#region Item/Ping (1009) 

هتقفلو من السالب وهتبدلو كولو بلكود ده
كود PHP:

#region Item/Ping (1009) 
                
case 1009
                    { 
                        if (
client.Action != 2
                            return; 
                        
ItemUsage usage = new ItemUsage(false); 
                        
usage.Deserialize(packet); 
                        if (!
client.Entity.Dead || usage.ID == ItemUsage.Ping
                        { 
                            switch (
usage.ID
                            { 
                                case 
56://sash 
                                    

                                        if (
client.SashSlots 200
                                        { 
                                            var 
item Database.ConquerItemTable.LoadItem(usage.UID); 
                                            
uint slots 0
                                            switch (
item.ID
                                            { 
                                                case 
1100003
                                                    
slots 3
                                                    break; 
                                                case 
1100006
                                                    
slots 6
                                                    break; 
                                                case 
1100009
                                                    
slots 12
                                                    break; 
                                            } 
                                            
client.SashSlots += slots
                                            
//if (client.Warehouses.ContainsKey((Conquer_Online_Server.Game.ConquerStructures.Warehouse.WarehouseID)item.UID)) 
                                            //{ 
                                            //    var sash = client.Warehouses[(Conquer_Online_Server.Game.ConquerStructures.Warehouse.WarehouseID)item.UID];                                             
                                            //    if (!client.Warehouses.ContainsKey((Conquer_Online_Server.Game.ConquerStructures.Warehouse.WarehouseID)client.Entity.UID)) 
                                            //        client.Warehouses.Add((Game.ConquerStructures.Warehouse.WarehouseID)client.Entity.UID, new Game.ConquerStructures.Warehouse(client, (Game.ConquerStructures.Warehouse.WarehouseID)client.Entity.UID)); 

                                            //    var invsash = client.Warehouses[(Conquer_Online_Server.Game.ConquerStructures.Warehouse.WarehouseID)client.Entity.UID]; 

                                            //    foreach (var whitem in sash.Objects) 
                                            //    { 
                                            //        whitem.Warehouse = client.Entity.UID; 
                                            //        whitem.Position = 0; 
                                            //    }                                             
                                            //} 
                                            
client.Inventory.Remove(itemEnums.ItemUse.Remove); 
                                        } 
                                        else 
                                        { 
                                            
client.Entity.SendSysMesage("you already opened max number of slots"); 
                                        } 
                                        break; 
                                    } 
                                case 
53
                                    { 
                                        
uint ItemAdd BitConverter.ToUInt32(packet12);// ay offset akbr mn 12 htzwdo 4 
                                        //:))) that npc is maked by me 

                                        
ConquerItem item_new null
                                        if (
client.Inventory.TryGetItem(ItemAddout item_new)) 
                                        { 
                                            
uint obtined_points 0
                                            
Database.ConquerItemInformation iteminfo = new Conquer_Online_Server.Database.ConquerItemInformation(ItemAdd0); 
                                            
Dictionary<uintuintamount = new Dictionary<uintuint>();//packet[20]); 
                                            
for (ushort i 8888 packet[24]; += 4
                                            { 
                                                
uint item_swap BitConverter.ToUInt32(packeti); 
                                                if (
client.Inventory.ContainsUID(item_swap)) 
                                                { 
                                                    
ConquerItem item null
                                                    if (
client.Inventory.TryGetItem(item_swapout item)) 
                                                    { 
                                                        
amount.Add(item_swapi); 
                                                    } 
                                                    switch (
item.ID
                                                    { 
                                                        case 
191505
                                                        case 
191605
                                                        case 
191705
                                                        case 
191805
                                                        case 
191905
                                                        case 
191405
                                                        case 
183325
                                                        case 
183315
                                                        case 
183375
                                                        case 
183305
                                                            { 
                                                                
obtined_points += 300
                                                                break; 
                                                            } 
                                                        default: 
                                                            
obtined_points += 50
                                                            break; 
                                                    } 
                                                } 
                                            } 
                                            if (
iteminfo.BaseInformation.ConquerPointsWorth obtined_points
                                            { 
                                                
uint add_cps 0
                                                
add_cps = (uint)(iteminfo.BaseInformation.ConquerPointsWorth obtined_points); 
                                                if (
add_cps client.Entity.ConquerPoints
                                                { 
                                                    
client.Entity.ConquerPoints -= (uint)add_cps
                                                    foreach (
uint key in amount.Keys
                                                    { 
                                                        if (
client.Inventory.ContainsUID(key)) 
                                                            
client.Inventory.Remove(keyConquer_Online_Server.Game.Enums.ItemUse.Removetrue); 
                                                    } 
                                                    
client.Inventory.Add(ItemAdd01); 

                                                } 
                                            } 
                                            else 
                                            { 
                                                foreach (
uint key in amount.Keys
                                                { 
                                                    if (
client.Inventory.ContainsUID(key)) 
                                                        
client.Inventory.Remove(keyConquer_Online_Server.Game.Enums.ItemUse.Removetrue); 
                                                } 
                                                
client.Inventory.Add(ItemAdd01); 

                                            } 
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.MainEquipment
                                case 
ItemUsage.AlternateEquipment
                                    { 
                                        if (
client.Entity.ContainsFlag3(Update.Flags3.Assassin)) 
                                        { 
                                            
client.Send(new Message("You cannot switch between equipments while being an assasin!"
                                                
Color.RedMessage.Agate)); 
                                            return; 
                                        } 
                                        
SwitchEquipment(clientusage.ID == ItemUsage.AlternateEquipment); 
                                        
client.Send(new ClientEquip(client)); 
                                        break; 
                                    } 
                                case 
52
                                    { 
                                        var 
item Database.ConquerItemTable.LoadItem(usage.UID); 
                                        
Database.ConquerItemTable.HandleInscribing(itemclient); 
                                        
Database.ItemAddingTable.GetAddingsForItem(item); 
                                        
item.Mode Conquer_Online_Server.Game.Enums.ItemMode.ChatItem
                                        
item.Send(client); 
                                        break; 
                                    } 
                                case 
41
                                    { 
                                        
// var item = Database.ConquerItemTable.LoadItem(usage.UID); 

                                        
ConquerItem item = new ConquerItem(true); 
                                        if (
client.Inventory.TryGetItem(usage.UIDout item)) 
                                        { 
                                            var 
infos = new Conquer_Online_Server.Database.ConquerItemInformation(item.ID0); 
                                            
item.UID usage.UID
                                            
item.DayStamp DateTime.Now
                                            
item.Days = (byte)(infos.BaseInformation.Time == : (infos.BaseInformation.Time 24 60)); 
                                            
TimeSpan Remain item.DayStamp.AddDays(item.Days) - DateTime.Now
                                            
item.TimeLeftInMinutes = (uint)Remain.TotalSeconds
                                            
Database.ConquerItemTable.Update_Free(itemclient); 
                                            
usage.dwParam 5
                                            
client.Send(usage); 
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.ArrowReload
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
//   ReloadArrows(client.Equipment.TryGetItem(ConquerItem.LeftWeapon), client); 
                                            
break; 
                                    } 
                                case 
ItemUsage.ShowBoothItems
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
ShowBoothItems(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.AddItemOnBoothForSilvers
                                case 
ItemUsage.AddItemOnBoothForConquerPoints
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
AddItemOnBooth(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.BuyFromBooth
                                    { 
                                        if (
client.Entity.PokerTable 0) break; 
                                        
lock (client.ItemSyncRoot
                                            
BuyFromBooth(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.RemoveItemFromBooth
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
RemoveItemFromBooth(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.EquipItem
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
EquipItem(usageclient); 
                                        
client.Send(WindowStats(client)); 
                                        break; 
                                    } 
                                case 
ItemUsage.UnequipItem
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
UnequipItem(usageclient); 
                                        
client.Equipment.UpdateEntityPacket(); 
                                        
client.Send(WindowStats(client)); 
                                        break; 
                                    } 
                                case 
55
                                case 
ItemUsage.BuyFromNPC
                                    { 
                                        if (
client.Entity.PokerTable 0) break; 
                                        
lock (client.ItemSyncRoot
                                            
HandleBuyFromNPC(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.SellToNPC
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
HandleSellToNPC(usageclient); 
                                        break; 
                                    } 

                                case 
ItemUsage.VIPRepair
                                    { 
                                        
HandleVIPRepair(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.Repair
                                    { 
                                        
lock (client.ItemSyncRoot
                                            
HandleRepair(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.MeteorUpgrade
                                case 
ItemUsage.DragonBallUpgrade
                                    { 
                                        
UpgradeItem(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.Ping
                                    { 
                                        
client.Send(usage); 
                                        break; 
                                    } 
                                case 
ItemUsage.ViewWarehouse
                                    { 
                                        
usage.dwParam client.MoneySave
                                        
client.Send(usage); 
                                        break; 
                                    } 
                                case 
ItemUsage.WarehouseDeposit
                                    { 
                                        if (
client.Entity.Money >= usage.dwParam
                                        { 
                                            
client.Entity.Money -= usage.dwParam
                                            
client.MoneySave += usage.dwParam
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.WarehouseWithdraw
                                    { 
                                        if (
client.MoneySave >= usage.dwParam
                                        { 
                                            
client.Entity.Money += usage.dwParam
                                            
client.MoneySave -= usage.dwParam
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.DropItem
                                    { 
                                        
DropItem(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.DropMoney
                                    { 
                                        
DropMoney(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.Enchant
                                    { 
                                        
EnchantItem(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.SocketTalismanWithItem
                                    { 
                                        for (
int i 0usage.dwExtraInfoi++) 
                                        { 
                                            
usage.dwParam BitConverter.ToUInt32(packet87 i); 
                                            
SocketTalismanWithItem(usageclient); 
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.SocketTalismanWithCPs
                                    { 
                                        
SocketTalismanWithCPs(usageclient); 
                                        break; 
                                    } 
                                case 
ItemUsage.RedeemGear
                                    { 
                                        var 
item client.DeatinedItem[usage.UID]; 
                                        if (
item != null
                                        { 
                                            if (
DateTime.Now item.Date.AddDays(7)) 
                                            { 
                                                
client.Send(new Message("This item is expired!"System.Drawing.Color.RedMessage.TopLeft)); 

                                                return; 
                                            } 
                                            if (
client.Entity.ConquerPoints >= item.ConquerPointsCost && client.Inventory.Count 40
                                            { 
                                                
client.Entity.ConquerPoints -= item.ConquerPointsCost
                                                
Database.EntityTable.UpdateCps(client); 

                                                
usage.dwParam client.Entity.UID
                                                
usage.dwExtraInfo3 item.ConquerPointsCost
                                                
client.Send(usage); 

                                                
client.Inventory.Add(item.ItemConquer_Online_Server.Game.Enums.ItemUse.Add); 

                                                
item.Item.Mode Enums.ItemMode.Update
                                                
item.Item.Send(client); 

                                                
Database.ClaimItemTable.Redeem(itemclient); 
                                                
Database.DetainedItemTable.Claim(itemclient); 
                                                
client.DeatinedItem.Remove(item.UID); 

                                                if (
Kernel.GamePool.ContainsKey(item.GainerUID)) 
                                                { 
                                                    
GameState pClient
                                                    if (
Kernel.GamePool.TryGetValue(item.GainerUIDout pClient)) 
                                                    { 
                                                        if (
pClient.Entity != null && pClient != null && pClient.ClaimableItem != null
                                                        { 
                                                            
pClient.ClaimableItem[item.UID].OwnerUID 500
                                                            
pClient.ClaimableItem[item.UID].MakeItReadyToClaim(); 
                                                            
usage.dwParam pClient.Entity.UID
                                                            
usage.ID ItemUsage.ClaimGear
                                                            
pClient.Send(usage); 
                                                            
pClient.ClaimableItem[item.UID].Send(pClient); 
                                                        } 
                                                    } 
                                                } 

                                                
Message message = new Message(" " client.Entity.Name " has redeemed his Gear and Pay " item.ConquerPointsCost " CPS . Congratulations!"System.Drawing.Color.WheatMessage.Talk); 
                                                
Kernel.SendWorldMessage(messageProgram.Values); 
                                            } 
                                        } 
                                        else 
                                        { 
                                            
client.Send(new Message("The item you want to redeem has already been redeemed."System.Drawing.Color.RedMessage.TopLeft)); 
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.ClaimGear
                                    { 
                                        if (
client.Inventory.Count 40
                                        { 
                                            var 
item client.ClaimableItem[usage.UID]; 
                                            if (
item != null
                                            { 
                                                if (
item.Bound && item.OwnerUID != 500
                                                { 
                                                    if (
DateTime.Now >= item.Date.AddDays(7)) 
                                                    { 
                                                        
Database.ClaimItemTable.Claim(itemclient); 
                                                        
client.ClaimableItem.Remove(item.UID); 

                                                        
usage.dwParam client.Entity.UID
                                                        
usage.dwExtraInfo3 item.ConquerPointsCost
                                                        
client.Send(usage); 
                                                    } 
                                                    
client.Send(new Message("Unnclaimable item!"System.Drawing.Color.RedMessage.TopLeft)); 
                                                    return; 
                                                } 
                                                if (
DateTime.Now item.Date.AddDays(7) && item.OwnerUID != 500
                                                { 
                                                    
client.Send(new Message("This item is not expired. You cannot claim it yet!"System.Drawing.Color.RedMessage.TopLeft)); 
                                                    return; 
                                                } 
                                                if (
item.OwnerUID == 500
                                                    
client.Entity.ConquerPoints += item.ConquerPointsCost
                                                else 
                                                { 
                                                    
client.Inventory.Add(item.ItemConquer_Online_Server.Game.Enums.ItemUse.Move); 
                                                    
Message message = new Message("Thank you for arresting " item.OwnerName " , " item.GainerName ". The arrested one has redeemed his items and you have received a great deal of ConquerPoints as reward. Congratulations!"System.Drawing.Color.WheatMessage.Talk); 
                                                    
Kernel.SendWorldMessage(messageProgram.Values); 
                                                } 
                                                
Database.ClaimItemTable.Claim(itemclient); 
                                                
client.ClaimableItem.Remove(item.UID); 

                                                
usage.dwParam client.Entity.UID
                                                
usage.dwExtraInfo3 item.ConquerPointsCost
                                                
//Database.EntityTable.UpdateCps(client); 
                                                
client.Send(usage); 
                                                
Message message2 = new Message("Thank you for arresting red/black name players " client.Entity.Name " has recived " item.ConquerPointsCost " CPS . Congratulations!"System.Drawing.Color.WheatMessage.Talk); 
                                                
Kernel.SendWorldMessage(message2Program.Values); 
                                            } 
                                            else 
                                            { 
                                                
client.Send(new Message("The item you want to claim has already been claimed."System.Drawing.Color.RedMessage.TopLeft)); 
                                            } 
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.SocketerMan
                                    { 
                                        
SocketItem(usageclient); 
                                        
client.Send(packet); 
                                        break; 
                                    } 
                                case 
40
                                    { 
                                        
uint ItemAdd BitConverter.ToUInt32(packet8); 
                                        
ConquerItem item_new null
                                        if (
client.Inventory.TryGetItem(ItemAddout item_new)) 
                                        { 
                                            var 
itemtype item_new.GetItemType(); 
                                            if (
itemtype == ConquerItem.ItemTypes.GemID) return; 
                                            
ushort pos PacketHandler.ItemPosition(item_new.ID); 
                                            if (
pos == ConquerItem.Bottle || pos == ConquerItem.Wing || pos == ConquerItem.Fan || pos == ConquerItem.Garment || pos == ConquerItem.LeftWeaponAccessory || pos == ConquerItem.RightWeaponAccessory || pos == ConquerItem.Steed || pos == ConquerItem.SteedArmor || pos == ConquerItem.SteedCrop || pos == ConquerItem.Tower
                                            { 
                                                
client.Send(new Message("Sorry can't bless this item !"System.Drawing.Color.RedMessage.Talk)); 
                                                return; 
                                            } 
                                            if (
item_new.Bless >= 7) return; 
                                            
Queue<uintamount = new Queue<uint>(packet[26]); 
                                            for (
ushort i 9191 packet[26]; += 4
                                            { 
                                                
uint uid BitConverter.ToUInt32(packeti); 
                                                if (
client.Inventory.ContainsUID(uid)) 
                                                    
amount.Enqueue(uid); 
                                                else return; 
                                            } 
                                            
byte oldbless item_new.Bless
                                            if (
item_new.Bless == && amount.Count == 5
                                            { 
                                                
item_new.Bless 1
                                                
client.Entity.Update(10"Aegis1"true); 
                                            } 
                                            else if (
item_new.Bless == && amount.Count == 1
                                            { 

                                                
item_new.Bless 3
                                                
client.Entity.Update(10"Aegis2"true); 
                                            } 
                                            else if (
item_new.Bless == && amount.Count == 3
                                            { 
                                                
item_new.Bless 5
                                                
client.Entity.Update(10"Aegis3"true); 
                                            } 
                                            else if (
item_new.Bless == && amount.Count == 5
                                            { 
                                                
item_new.Bless 7
                                                
client.Entity.Update(10"Aegis4"true); 
                                            } 
                                            if (
oldbless == item_new.Bless) return; 
                                            while (
amount.Count != 0
                                                
client.Inventory.Remove(amount.Dequeue(), Game.Enums.ItemUse.Removetrue); 
                                            
item_new.Mode Game.Enums.ItemMode.Update
                                            
item_new.Send(client); 
                                            
usage.dwParam 2
                                            
Database.ConquerItemTable.UpdateBless 
                                            
(item_new); 
                                        } 
                                        
client.Send(packet); 
                                        break; 
                                    } 
                                case 
ItemUsage.GemCompose
                                    { 
                                        
#region GemCompose 
                                        
UInt32 Ident usage.UID
                                        
client.Inventory.Remove(Ident15); 
                                        
client.Inventory.Add(Ident 101); 
                                        
usage.dwParam 1
                                        
client.Send(usage); 
                                        
#endregion 
                                        
break; 
                                    } 
                                case 
ItemUsage.ToristSuper
                                    { 
                                        
#region GemCompose 
                                        
if (client.Entity.Money >= 100000
                                        { 
                                            
client.Inventory.Remove(7000021); 
                                            
client.Inventory.Remove(7000121); 
                                            
client.Inventory.Remove(7000221); 
                                            
client.Inventory.Remove(7000321); 
                                            
client.Inventory.Remove(7000421); 
                                            
client.Inventory.Remove(7000521); 
                                            
client.Inventory.Remove(7000621); 
                                            
client.Entity.Money -= 100000
                                            
client.Inventory.Add(70007201); 
                                            
client.Send(usage); 
                                            
usage.dwParam 1
                                        } 
                                        else 
                                        { 
                                            
client.Send(new Message("Sorry you don`t have 100,000 silver!."System.Drawing.Color.RedMessage.Talk)); 
                                        } 
                                        
#endregion 
                                        
break; 
                                    } 
                                case 
ItemUsage.SplitStack
                                    { 
                                        
ConquerItem mainItem null
                                        
ConquerItem minorItem = new ConquerItem(true); 
                                        
Database.ConquerItemInformation infos null
                                        
minorItem.Color = (Conquer_Online_Server.Game.Enums.Color)Kernel.Random.Next(48); 
                                        if (
client.Inventory.TryGetItem(usage.UIDout mainItem)) 
                                        { 
                                            
infos = new Conquer_Online_Server.Database.ConquerItemInformation(mainItem.ID0); 
                                            if (
mainItem.StackSize && mainItem.StackSize <= infos.BaseInformation.StackSize
                                            { 
                                                if (
client.Inventory.Count 40
                                                { 
                                                    
ushort Amount = (ushort)usage.dwParam

                                                    
mainItem.StackSize -= Amount
                                                    
mainItem.Mode Game.Enums.ItemMode.Update
                                                    
mainItem.Send(client); 
                                                    
mainItem.Mode Game.Enums.ItemMode.Default; 

                                                    
minorItem.ID mainItem.ID
                                                    
minorItem.StackSize += Amount
                                                    
minorItem.Durability mainItem.Durability
                                                    
client.Inventory.Add(minorItemGame.Enums.ItemUse.CreateAndAdd); 
                                                    
Database.ConquerItemTable.UpdateStack(mainItem); 
                                                } 
                                            } 
                                        } 
                                        break; 
                                    } 
                                case 
ItemUsage.MergeStackableItems
                                    { 
                                        
ConquerItem mainItem null
                                        
ConquerItem minorItem = new ConquerItem(true); 
                                        
Database.ConquerItemInformation infos null
                                        
minorItem.Color = (Conquer_Online_Server.Game.Enums.Color)Kernel.Random.Next(48); 
                                        if (
client.Inventory.TryGetItem(usage.UIDout mainItem) && client.Inventory.TryGetItem(usage.dwParamout minorItem)) 
                                        { 
                                            if (
mainItem.ID == minorItem.ID
                                            { 
                                                
infos = new Conquer_Online_Server.Database.ConquerItemInformation(mainItem.ID0); 
                                                if (
mainItem.StackSize 1
                                                    
mainItem.StackSize 1
                                                if (
minorItem.StackSize 1
                                                    
minorItem.StackSize 1

                                                if ((
mainItem.StackSize minorItem.StackSize) <= infos.BaseInformation.StackSize
                                                { 
                                                    
mainItem.StackSize += minorItem.StackSize
                                                    
mainItem.Mode Game.Enums.ItemMode.Update
                                                    
mainItem.Send(client); 
                                                    
mainItem.Mode Game.Enums.ItemMode.Default; 
                                                    
Database.ConquerItemTable.UpdateStack(mainItem); 

                                                    
client.Inventory.Remove(minorItemGame.Enums.ItemUse.Remove); 
                                                } 
                                            } 
                                        } 
                                        break; 
                                    } 
                                case 
34
                                    { 
                                        break; 
                                    } 
                                case 
ItemUsage.LowerEquipment
                                    { 
                                        
ConquerItem item null
                                        if (
client.Inventory.TryGetItem(usage.UIDout item)) 
                                        { 
                                            if (
IsArrow(item.ID)) 
                                                return; 
                                            
ConquerItem upgrade null
                                            if (
client.Inventory.TryGetItem(usage.UIDout upgrade)) 
                                            { 
                                                if (
client.Entity.ConquerPoints 54
                                                { 
                                                    
client.Send(new Message("You don't have 54CPs."Color.RedMessage.TopLeft)); 
                                                    return; 
                                                } 
                                                
client.Entity.ConquerPoints -= 54
                                                
Database.ConquerItemInformation infos = new Conquer_Online_Server.Database.ConquerItemInformation(item.IDitem.Plus); 
                                                if (
infos.BaseInformation.Level <= 15) return; 
                                                
int startwith = (int)(infos.BaseInformation.ID 1000); 
                                                
int endwith = (int)(infos.BaseInformation.ID 10); 
                                                var 
sitem infos.LowestID(ItemMinLevel(ItemPosition(infos.BaseInformation.ID))); 
                                                
//  var sitem = Conquer_Online_Server.Database.ConquerItemInformation.BaseInformations.Values.Where(x => (x.ID % 10) == endwith && (x.ID / 1000) == startwith && x.Level >= 15).OrderBy(y => y.Level).First(); 
                                                
item.ID sitem
                                                
infos = new Conquer_Online_Server.Database.ConquerItemInformation(item.IDitem.Plus); 
                                                
item.Durability item.MaximDurability infos.BaseInformation.Durability
                                                
Database.ConquerItemTable.UpdateItemID(itemclient); 
                                                
Database.ConquerItemTable.UpdateDurabilityItem(item); 
                                                
item.Mode Conquer_Online_Server.Game.Enums.ItemMode.Update
                                                
item.Send(client); 
                                                
item ItemSocket(item2); 
                                            } 
                                        } 
                                        break; 
                                    } 
                                default: 
                                    { 
                                        
//nta mot2ked enk 3amel update lel client m4 3arf :D 

                                        
Console.WriteLine("Unhandled item usage type : " usage.ID); 
                                        break; 
                                    } 
                            } 
                        } 
                        break; 
                    } 
                
#endregion 

هتبحث عن الكود ده
كود PHP:

public class ItemUsage WriterInterfaces.IPacket 

هيوديك على كلاس ItemUsage.cs بس انا قولت اعمل الكود بحث عشان الى مش عارف مكان الكلاس فين

المهم هتمسح كل الى فيه وتحط الاكواد دى
كود PHP:

using System

namespace 
Conquer_Online_Server.Network.GamePackets 

    public class 
ItemUsage WriterInterfaces.IPacket 
    

        public const 
ushort 
            BuyFromNPC 
1
            
SellToNPC 2
            
RemoveInventory 3
            
EquipItem 4
            
UnequipItem 6
            
ArrowReload 8
            
ViewWarehouse 9
            
WarehouseDeposit 10
            
WarehouseWithdraw 11
            
Repair 14
            
VIPRepair 15
            
DragonBallUpgrade 19
            
MeteorUpgrade 20
            
ShowBoothItems 21
            
AddItemOnBoothForSilvers 22
            
RemoveItemFromBooth 23
            
BuyFromBooth 24
            
UpdateDurability 25
            
AddItemOnBoothForConquerPoints 29
            
Ping 27
            
Enchant 28
            
RedeemGear 32
            
ClaimGear 33
            
SocketTalismanWithItem 35
            
SocketTalismanWithCPs 36
            
DropItem 37
            
DropMoney 38
            
GemCompose 39
            
Bless 40
            
Accessories 41
            
MainEquipment 44
            
AlternateEquipment 45
            
LowerEquipment 54
            
ToristSuper 51
            
SocketerMan 43
            
MergeStackableItems 48
            
SplitStack 49

        
byte[] Buffer
        public 
ItemUsage(bool Create
        { 
            if (
Create
            { 
                
Buffer = new byte[95]; 
                
WriteUInt16(870Buffer); 
                
WriteUInt16(10092Buffer); 
                
WriteUInt32((uint)Time32.timeGetTime().GetHashCode(), 4Buffer); 
            } 
        } 
        public 
uint UID 
        

            
get { return BitConverter.ToUInt32(Buffer8); } 
            
set WriteUInt32(value8Buffer); } 
        } 
        public 
uint dwParam 
        

            
get { return BitConverter.ToUInt32(Buffer12); } 
            
set WriteUInt32(value12Buffer); } 
        } 

        public 
ushort ID 
        

            
get { return BitConverter.ToUInt16(Buffer20); } 
            
set WriteUInt16(value20Buffer); } 
        } 

        public 
uint TimeStamp 
        

            
get { return BitConverter.ToUInt32(Buffer24); } 
            
set WriteUInt32(value24Buffer); } 
        } 

        public 
uint dwExtraInfo 
        

            
get { return BitConverter.ToUInt32(Buffer26); } 
            
set WriteUInt32(value26Buffer); } 
        } 
        public 
uint dwExtraInfo2 
        

            
get { return BitConverter.ToUInt32(Buffer88); } 
            
set WriteUInt32(value88Buffer); } 
        } 
        public 
uint dwExtraInfo3 
        

            
get { return BitConverter.ToUInt32(Buffer36); } 
            
set WriteUInt32(value36Buffer); } 
        } 

        public 
uint[] Batch 
        

            
get 
            

                
uint[] items = new uint[dwExtraInfo]; 
                for (
int i 0dwExtraInfoi++) 
                { 
                    
items[i] = BitConverter.ToUInt32(Buffer91 i); 
                } 
                return 
items
            } 
            
set 
            

                if (
value != null
                { 
                    
dwExtraInfo = (uint)value.Length
                    for (
int i 0dwExtraInfoi++) 
                    { 
                        
WriteUInt32(value[i], 91 iBuffer); 
                    } 
                } 
            } 
        } 

        public 
byte[] ToArray() 
        { 
            return 
Buffer
        } 
        public 
void Deserialize(byte[] buffer
        { 
            
Buffer buffer
        } 
        public 
void Send(Client.GameState client
        { 
            
client.Send(Buffer); 
        } 
    } 



etetoo2015 2019-04-23 04:56 PM

بيجيب كذا ايرور


الساعة الآن 05:53 PM

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