عرض مشاركة واحدة
احصائياتى

الردود
11

المشاهدات
6040
 
محمودمحمدسالم

محمودمحمدسالم is on a distinguished road

    غير متواجد

المشاركات
425

+التقييم
0.20

تاريخ التسجيل
Apr 2019

الاقامة

نظام التشغيل

رقم العضوية
63
2019-08-09, 07:02 PM
المشاركة 1 
#1  
افتراضي سستم الرونز سورس اليكس بورتو
صاحب الشغل عبدالرحمن

كود:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 
Project_Terror_v2.Game.MsgServer
{
    public 
unsafe struct MsgRuns
    
{
        public 
enum RuneType byte
        
{
            
Equip 57,
            
UnEquip 58,
            
InventoryRune 61,
            
UpgradeRune 63
        
}
        static 
ushort[] YellowRunePoints = new ushort[10] { 150010003000800015000200002500032000};
        private static 
ushort[] BlueRunePoints = new ushort[26] { 140080012001800270037004500530060007500830090001050012000135001500022500225002250022500225003000030000300000, };
        public static 
bool IsRune(uint ID)
        {
            return 
ID >= 4010101 && ID <= 4031309 || ID >= 4010001 && ID <= 4010901;
        }
        public static 
bool IsRuneEssence(uint ID)
        {
            return (
ID == 4040001) || (ID == 4050001) || (ID == 4060001);
        }
        public static 
void Runs(Client.GameClient clientServerSockets.Packet _stream)
        {
            var 
packet = new byte[_stream.Size];
            
System.Runtime.InteropServices.Marshal.Copy(new IntPtr(_stream.Memory), packet0_stream.Size);
            switch ((
RuneType)packet[20])
            {
                case 
RuneType.UpgradeRune:
                    {
                        
MsgGameItem Item;
                        if (
client.Warehouse.TryGetItem((uint)Game.MsgNpc.NpcID.WHRune, (uint)BitConverter.ToUInt32(packet8), out Item) || client.Warehouse.TryGetItem((uint)Game.MsgNpc.NpcID.MainRune, (uint)BitConverter.ToUInt32(packet8), out Item))
                        {
                            if (
IsRune(Item.ITEM_ID))
                            {
                                
Queue<MsgGameItemItemsPlus = new Queue<MsgGameItem>();
                                for (
int i 0packet[26]; i++)
                                {
                                    var 
uid BitConverter.ToUInt32(packet91 i);
                                    
MsgGameItem itemuse;
                                    if (
client.Warehouse.TryGetItem((uint)Game.MsgNpc.NpcID.WHRuneuidout itemuse))
                                        
ItemsPlus.Enqueue(itemuse);
                                    else if (
client.Inventory.TryGetItem(uidout itemuse))
                                        
ItemsPlus.Enqueue(itemuse);
                                }
                                while (
ItemsPlus.Count 0)
                                {
                                    var 
Stone ItemsPlus.Dequeue();
                                    if (
IsRune(Stone.ITEM_ID))
                                    {
                                        
Item.PlusProgress += GetRuneComposePoints(Item.ITEM_ID, (byte)(Item.ITEM_ID 100));
                                        
Item.PlusProgress += Stone.PlusProgress;

                                    }
                                    else if (!
IsRuneEssence(Stone.ITEM_ID))
                                    {
                                        
Item.PlusProgress += Database.ItemType.StonePlusPoints(Stone.Plus);
                                        
Item.PlusProgress += Stone.PlusProgress;
                                    }
                                    else
                                    {
                                        
Item.PlusProgress += (uint)Math.Max(1, (int)Stone.StackSize) * 10;
                                    }
                                    while (
Item.PlusProgress >= GetRuneComposePoints(Item.ITEM_ID, (byte)(Item.ITEM_ID 100)) && IsRuneMax(Item.ITEM_ID, (byte)(Item.ITEM_ID 100)))
                                    {
                                        
Item.PlusProgress -= GetRuneComposePoints(Item.ITEM_ID, (byte)(Item.ITEM_ID 100));
                                        
Item.ITEM_ID++;
                                        if (!
IsRuneMax(Item.ITEM_ID, (byte)(Item.ITEM_ID 100)))
                                            
Item.PlusProgress 0;
                                    }
                                    if (
Stone.WH_ID != 0)
                                    {
                                        
client.Warehouse.DeleteItem((uint)Game.MsgNpc.NpcID.WHRuneStone.UID);
                                        
client.Send(_stream.ItemUsageCreate(MsgItemUsuagePacket.ItemUsuageID.RemoveInventoryStone.UID00000));
                                    }
                                    else
                                        
client.Inventory.Update(StoneRole.Instance.AddMode.REMOVE_stream);

                                    
Item.Mode Role.Flags.ItemMode.Update;
                                    
Item.Send(client_stream);
                                }
                            }
                        }
                        break;
                    }
                case 
RuneType.InventoryRune:
                    {
                        switch (
packet[12])
                        {
                            case 
0:
                                {
                                    
MsgGameItem items;
                                    if (
client.Inventory.TryGetItem((uint)BitConverter.ToUInt32(packet8), out items))
                                    {

                                        if (
IsRune(items.ITEM_ID) == false)
                                            return;
                                        if (
client.Warehouse.AddItem(items, (uint)Game.MsgNpc.NpcID.WHRune))
                                        {
                                            if (
client.Inventory.ClientItems.TryRemove(items.UIDout items))
                                            {
                                                
items.Position = (byte)Role.Flags.ConquerItem.Rune;
                                                if (
Database.ItemType.IsRuneEssence(items.ITEM_ID))
                                                {
                                                    
client.Send(_stream.ItemUsageCreate(MsgItemUsuagePacket.ItemUsuageID.RemoveInventoryitems.UID00000));
                                                    if (
client.Warehouse.TryGetItem((uint)Game.MsgNpc.NpcID.WHRuneitems.UIDout items))
                                                    {
                                                        
items.Mode Role.Flags.ItemMode.AddItem;
                                                        
items.Send(client_stream);
                                                    }
                                                }
                                                
client.Send(_stream.ItemUsageCreate((MsgItemUsuagePacket.ItemUsuageID)packet[20], BitConverter.ToUInt32(packet8), BitConverter.ToUInt32(packet12), BitConverter.ToUInt32(packet22), 000));
                                            }
                                        }
                                    }
                                    break;
                                }

                            case 
1:
                                {
                                    if (
client.Warehouse.RemoveItem(BitConverter.ToUInt32(packet8), (uint)Game.MsgNpc.NpcID.WHRunenull))
                                        
client.Send(_stream.ItemUsageCreate((MsgItemUsuagePacket.ItemUsuageID)packet[20], BitConverter.ToUInt32(packet8), BitConverter.ToUInt32(packet12), BitConverter.ToUInt32(packet22), 000));
                                    break;
                                }
                        }
                        break;
                    }
                case 
RuneType.Equip:
                    {
                        
MsgGameItem DataItem;
                        if (
client.Warehouse.TryGetItem((uint)Game.MsgNpc.NpcID.WHRune, (uint)BitConverter.ToUInt32(packet8), out DataItem))
                        {

                            if (
IsRune(DataItem.ITEM_ID) == false)
                                return;
                            var 
DBItem Database.ItemType.GetItemRecord(DataItem.ITEM_ID);
                            if (
DBItem != null)
                            {
                                if (
client.Warehouse.CanEquipRune((ushort)packet[12]))
                                {
                                    if (
client.Warehouse.DeleteItem((uint)Game.MsgNpc.NpcID.WHRune, (uint)BitConverter.ToUInt32(packet8)))
                                    {
                                        
client.Warehouse.AddItem(DataItem, (uint)Game.MsgNpc.NpcID.MainRune);
                                        
DataItem.Mode Role.Flags.ItemMode.Update;
                                        
DataItem.Position = (byte)packet[12];
                                        
DataItem.Send(client_stream);
                                        
client.Equipment.QueryEquipment(client.Equipment.Alternantefalse);
                                        
client.Send(_stream.ItemUsageCreate((MsgItemUsuagePacket.ItemUsuageID)packet[20], BitConverter.ToUInt32(packet8), BitConverter.ToUInt32(packet12), BitConverter.ToUInt32(packet22), 000));

                                        var 
spell Database.MagicType.GetSpellRecord(DBItem.SpellIDDBItem.SpellLevel);

                                        if (
spell != null)
                                        {
                                            if (!
client.MySpells.ClientSpells.ContainsKey((ushort)spell.ID))
                                                
client.MySpells.Add(_stream, (ushort)spell.ID);
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    }
                case 
RuneType.UnEquip:
                    {
                        
MsgGameItem DataItem;
                        if (
client.Warehouse.TryGetItem((uint)Game.MsgNpc.NpcID.MainRune, (uint)BitConverter.ToUInt32(packet8), out DataItem))
                        {

                            if (
IsRune(DataItem.ITEM_ID) == false)
                                return;

                            if (
client.Warehouse.AddItem(DataItem, (uint)Game.MsgNpc.NpcID.WHRune))
                            {
                                if (
client.Warehouse.DeleteItem((uint)Game.MsgNpc.NpcID.MainRune, (uint)BitConverter.ToUInt32(packet8)))
                                {
                                    
DataItem.Mode Role.Flags.ItemMode.Update;
                                    
DataItem.Position = (byte)Role.Flags.ConquerItem.Rune;
                                    
DataItem.Send(client_stream);

                                    
client.Equipment.QueryEquipment(client.Equipment.Alternantefalse);
                                    
client.Send(_stream.ItemUsageCreate((MsgItemUsuagePacket.ItemUsuageID)packet[20], BitConverter.ToUInt32(packet8), BitConverter.ToUInt32(packet12), BitConverter.ToUInt32(packet22), 000));

                                    var 
DBItem Database.ItemType.GetItemRecord(DataItem.ITEM_ID);
                                    if (
DBItem != null)
                                    {
                                        var 
spell Database.MagicType.GetSpellRecord(DBItem.SpellIDDBItem.SpellLevel);

                                        if (
spell != null)
                                        {
                                            if (
client.MySpells.ClientSpells.ContainsKey((ushort)spell.ID))
                                                
client.MySpells.Remove((ushort)spell.ID_stream);
                                        }
                                    }
                                }
                            }
                            else
                                
client.SendSysMesage("Sorry, your container is full.");
                        }
                        break;
                    }
            }
        }
        public static 
uint GetRuneComposePoints(uint IDbyte plus)
        {
            if ((
ID >= 4030101 && ID <= 4031309))
                return 
YellowRunePoints[Math.Min((int)plus9)];
            return 
BlueRunePoints[Math.Min((int)plus27)];
        }

        public static 
bool IsRuneMax(uint IDbyte plus)
        {
            if ((
ID >= 4030101 && ID <= 4031309))
            {
                if (
plus 9)
                    return 
true;
            }
            else
                if (
plus 27)
                    return 
true;
            return 
false;
        }
    }


بتوفيق للجميع