예제 #1
0
 private static byte GetNumberOfAttacks(tmpSkill_ tmp)
 {
     for (byte i = 0; i < 10; i++)
     {
         if (tmp.NextId != 0)
         {
             tmp = Silkroad.GetTmpSkillById(tmp.NextId);
         }
         else
         {
             return((byte)(i + 1));
         }
     }
     return(1);
 }
예제 #2
0
파일: Items.cs 프로젝트: Pascal1000/server1
        public static void CreateItem(PacketReader reader_, int Index_)
        {
            int[] CharacterItemIndex = DatabaseCore.Item.GetIndexByName(Player.General[Index_].CharacterName);

            byte freeslot = FreeSlot(CharacterItemIndex);

            uint itemid   = reader_.ReadDword();
            byte itemplus = reader_.ReadByte();

            Silkroad.Item_ DestinationItem_ = Silkroad.GetItemById(itemid);

            if (DestinationItem_.ITEM_TYPE_NAME.Contains("ITEM_ETC_GOLD_"))
            {
                freeslot = 254;
            }

            PacketWriter writer = new PacketWriter();

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
            writer.AppendWord(0x601);
            writer.AppendByte(freeslot);
            if (freeslot != 254)
            {
                writer.AppendDword(itemid);
            }
            if (DestinationItem_.ITEM_TYPE_NAME.Contains("CH") || DestinationItem_.ITEM_TYPE_NAME.Contains("EU"))
            {
                writer.AppendByte(itemplus);
                writer.AppendLword(0);
                writer.AppendDword((uint)DestinationItem_.MIN_DURA);
                writer.AppendByte(0);

                DatabaseCore.WriteQuery("UPDATE items SET itemid='{0}',plusvalue='{1}',type='0',durability='{2}' WHERE itemnumber='item{3}' AND owner ='{4}'", itemid, itemplus, DestinationItem_.MIN_DURA, freeslot, Player.General[Index_].CharacterName);
                AddItemToDatabase(CharacterItemIndex[freeslot], itemid, 0, 0, (byte)DestinationItem_.MIN_DURA, itemplus, 0);
            }
            else if (DestinationItem_.ITEM_TYPE_NAME.Contains("ETC"))
            {
                if (freeslot != 254)
                {
                    writer.AppendWord(itemplus);
                    DatabaseCore.WriteQuery("UPDATE items SET itemid='{0}',plusvalue='0',type='1',durability='{1}',quantity='{2}' WHERE itemnumber='item{3}' AND owner ='{4}'", itemid, DestinationItem_.MIN_DURA, itemplus, freeslot, Player.General[Index_].CharacterName);
                    AddItemToDatabase(CharacterItemIndex[freeslot], itemid, 1, itemplus, (byte)DestinationItem_.MIN_DURA, 0, 0);
                }
            }

            ServerSocket.Send(writer.getWorkspace(), Index_);
        }
예제 #3
0
파일: Items.cs 프로젝트: Pascal1000/server1
        public static byte[] CreateSpawnPacket(Item._General general, _Position pos)
        {
            PacketWriter writer = new PacketWriter();

            Silkroad.Item_ tmpItem = Silkroad.GetItemById(general.Pk2ID);
            if (tmpItem.ITEM_TYPE_NAME.Contains("CH") || tmpItem.ITEM_TYPE_NAME.Contains("EU"))
            {
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);
                writer.AppendDword(general.Pk2ID);
                writer.AppendByte(general.Plus);
                writer.AppendDword(general.UniqueID);
                writer.AppendByte(pos.XSector);
                writer.AppendByte(pos.YSector);
                writer.AppendFloat(pos.X);
                writer.AppendFloat(pos.X);
                writer.AppendFloat(pos.Y);
                writer.AppendWord(0xAAA6);
                writer.AppendByte(0);
                writer.AppendByte(0);
                writer.AppendByte(6);
                writer.AppendDword(general.DroppedByUniqueId);
            }
            else if (tmpItem.ITEM_TYPE_NAME.Contains("ETC"))
            {
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);
                writer.AppendDword(general.Pk2ID);
                if (general.Pk2ID == 1 || general.Pk2ID == 2 || general.Pk2ID == 3)
                {
                    writer.AppendDword(general.Quantity);
                }
                writer.AppendDword(general.UniqueID);
                writer.AppendByte(pos.XSector);
                writer.AppendByte(pos.YSector);
                writer.AppendFloat(pos.X);
                writer.AppendFloat(pos.X);
                writer.AppendFloat(pos.Y);
                writer.AppendWord(0xAAA6);
                writer.AppendByte(0);
                writer.AppendByte(0);
                writer.AppendByte(6);
                writer.AppendDword(general.DroppedByUniqueId);
            }
            return(writer.getWorkspace());
        }
예제 #4
0
파일: Items.cs 프로젝트: Pascal1000/server1
        private static byte UnEnquipShield(int Index_, int[] CharacterItemIndex, int CharacterShieldIndex)
        {
            Silkroad.Item_ SourceItem = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterShieldIndex]);

            if (SourceItem.CLASS_C != 2 && SourceItem.CLASS_C != 3)
            {
                if (Player.Stats[Index_].PhyDef < SourceItem.MAX_PHYSDEF)
                {
                    Player.Stats[Index_].PhyDef = 1;
                }
                else if (Player.Stats[Index_].MagDef < SourceItem.MAGDEF_MAX)
                {
                    Player.Stats[Index_].MagDef = 1;
                }
                else
                {
                    Player.Stats[Index_].PhyDef -= (ushort)SourceItem.MAX_PHYSDEF;
                    Player.Stats[Index_].MagDef -= (ushort)SourceItem.MAGDEF_MAX;
                }

                byte freeslot = FreeSlot(CharacterItemIndex);

                PacketWriter writer = new PacketWriter();
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_UNEQUIP);
                writer.AppendDword(Player.General[Index_].UniqueID);
                writer.AppendByte(7);
                writer.AppendDword(DatabaseCore.Item.ItemId[CharacterShieldIndex]);

                ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                writer.AppendByte(1);
                writer.AppendByte(0);
                writer.AppendByte(7);
                writer.AppendByte(freeslot);
                writer.AppendWord(1);
                writer.AppendByte(0);
                ServerSocket.Send(writer.getWorkspace(), Index_);

                return(freeslot);
            }
            return(255);
        }
예제 #5
0
        public static void BeginSkill(int Index_)
        {
            Player.Objects[Index_].UsingSkill = true;

            Silkroad.Skill_ tmpSkill = Silkroad.GetSkillById(Player.Objects[Index_].AttackingSkillID);

            Player.Stats[Index_].CMP -= tmpSkill.RequiredMp;
            Stats.MPUpdate(Index_, true);

            Player.Objects[Index_].AttackingCastingID = (uint)random.Next(500, 50000);

            PacketWriter writer = new PacketWriter();

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SKILL_ATTACK);
            writer.AppendByte(1);
            writer.AppendByte(1);
            ServerSocket.Send(writer.getWorkspace(), Index_);

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ATTACK);
            writer.AppendWord(0x201);
            writer.AppendDword(Player.Objects[Index_].AttackingSkillID);
            writer.AppendDword(Player.General[Index_].UniqueID);
            writer.AppendDword(Player.Objects[Index_].AttackingCastingID);
            writer.AppendDword(Player.Objects[Index_].AttackingObjectId);
            writer.AppendByte(0);

            ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

            if (tmpSkill.CastTime <= 0)
            {
                EndSkill(Index_);
            }

            else
            {
                Timers.CastAttackTimer[Index_].Interval = tmpSkill.CastTime * 1000;
                Timers.CastAttackTimer[Index_].Start();
            }
        }
예제 #6
0
파일: Items.cs 프로젝트: Pascal1000/server1
        private static void UnEquipItem(int Index_, int CharacterItemSourceIndex, int CharacterItemDestinationIndex)
        {
            PacketWriter writer = new PacketWriter();

            Silkroad.Item_ SourceItem = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemSourceIndex]);

            if (DatabaseCore.Item.Slot[CharacterItemSourceIndex] <= 5)
            {
                Player.Stats[Index_].PhyDef -= (ushort)SourceItem.MAX_PHYSDEF;
                Player.Stats[Index_].MagDef -= (ushort)SourceItem.MAGDEF_MAX;
                Player.Stats[Index_].Parry  -= (ushort)SourceItem.MIN_PARRY;
            }
            else if (DatabaseCore.Item.Slot[CharacterItemSourceIndex] == 6)
            {
                Player.Stats[Index_].MinPhy      -= (ushort)SourceItem.MIN_LPHYATK;
                Player.Stats[Index_].MaxPhy      -= (ushort)SourceItem.MIN_HPHYATK;
                Player.Stats[Index_].MinMag      -= (ushort)SourceItem.MIN_LMAGATK;
                Player.Stats[Index_].MaxMag      -= (ushort)SourceItem.MIN_HMAGATK;
                Player.General[Index_].WeaponType = 0;
            }
            else if (DatabaseCore.Item.Slot[CharacterItemSourceIndex] == 7)
            {
                Player.Stats[Index_].PhyDef -= (ushort)SourceItem.MAX_PHYSDEF;
                Player.Stats[Index_].MagDef -= (ushort)SourceItem.MAGDEF_MAX;
            }

            else if (DatabaseCore.Item.Slot[CharacterItemSourceIndex] >= 9 && DatabaseCore.Item.Slot[CharacterItemSourceIndex] <= 12)
            {
                Player.Stats[Index_].TotalAccessoriesAbsorption -= SourceItem.ABSORB_INC;
            }

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_UNEQUIP);
            writer.AppendDword(Player.General[Index_].UniqueID);
            writer.AppendByte(DatabaseCore.Item.Slot[CharacterItemSourceIndex]);
            writer.AppendDword(DatabaseCore.Item.ItemId[CharacterItemSourceIndex]);

            ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);
        }
예제 #7
0
파일: Items.cs 프로젝트: Pascal1000/server1
        private static byte UnEnquipWeapon(int Index_, int[] CharacterItemIndex, int CharacterItemSourceIndex)
        {
            Silkroad.Item_ SourceItem = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemSourceIndex]);

            if (DatabaseCore.Item.ItemId[CharacterItemSourceIndex] != 0 && SourceItem.CLASS_C != 2 && SourceItem.CLASS_C != 3)
            {
                Player.Stats[Index_].MinPhy      -= (ushort)SourceItem.MIN_LPHYATK;
                Player.Stats[Index_].MaxPhy      -= (ushort)SourceItem.MIN_HPHYATK;
                Player.Stats[Index_].MinMag      -= (ushort)SourceItem.MIN_LMAGATK;
                Player.Stats[Index_].MaxMag      -= (ushort)SourceItem.MIN_HMAGATK;
                Player.General[Index_].WeaponType = 0;

                byte freeslot = FreeSlot(CharacterItemIndex);

                PacketWriter writer = new PacketWriter();

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_UNEQUIP);
                writer.AppendDword(Player.General[Index_].UniqueID);
                writer.AppendByte(6);
                writer.AppendDword(DatabaseCore.Item.ItemId[CharacterItemSourceIndex]);

                ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                writer.AppendByte(1);
                writer.AppendByte(0);
                writer.AppendByte(6);
                writer.AppendByte(freeslot);
                writer.AppendWord(1);
                writer.AppendByte(0);
                ServerSocket.Send(writer.getWorkspace(), Index_);

                return(freeslot);
            }
            return(255);
        }
예제 #8
0
        private static void PrepareBuff(int Index_)
        {
            PacketWriter writer = new PacketWriter();

            Player.Objects[Index_].UsingSkill = true;

            uint CastingId = (uint)random.Next(65536, 1048575);

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ATTACK);
            writer.AppendByte(1);
            writer.AppendByte(0);
            writer.AppendDword(Player.Objects[Index_].UsingSkillID);
            writer.AppendDword(Player.General[Index_].UniqueID);
            writer.AppendDword(CastingId);
            writer.AppendByte(0);
            writer.AppendDword(0);

            ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

            Silkroad.Skill_ tmpSkill = Silkroad.GetSkillById(Player.Objects[Index_].UsingSkillID);
            Player.Objects[Index_].BuffCastingID  = CastingId;
            Timers.CastBuffTimer[Index_].Interval = tmpSkill.CastTime * 1000;
            Timers.CastBuffTimer[Index_].Start();
        }
예제 #9
0
파일: Stats.cs 프로젝트: Pascal1000/server1
        public static void GetXP(int Index_, int ObjectIndex)
        {
            int xprate = 2, sprate = 2, goldrate = 2;

            Silkroad.Gold_ tmpGold = Silkroad.GetGoldDataByLevel(Monsters.General[ObjectIndex].Level);
            ulong          sp      = (ulong)random.Next(tmpGold.Skillpoints, tmpGold.Skillpoints + 25);
            ulong          exp     = Monsters.General[ObjectIndex].Exp;

            if (Player.Stats[Index_].Level < Monsters.General[ObjectIndex].Level)
            {
                exp = ((ulong)(Monsters.General[ObjectIndex].Level - Player.Stats[Index_].Level) * Monsters.General[ObjectIndex].Exp) * (ulong)xprate;
            }
            if (Player.Stats[Index_].Level > Monsters.General[ObjectIndex].Level)
            {
                exp = ((ulong)(Player.Stats[Index_].Level - Monsters.General[ObjectIndex].Level) / Monsters.General[ObjectIndex].Exp) * (ulong)xprate;
                if (exp == 0)
                {
                    exp = 1;
                }
            }
            if (Player.Stats[Index_].Level == Monsters.General[ObjectIndex].Level)
            {
                exp = (Monsters.General[ObjectIndex].Exp * (ulong)xprate);
            }

            sp *= (ulong)sprate;

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_EXP);
            writer.AppendDword(Monsters.General[ObjectIndex].UniqueID);
            writer.AppendLword(exp);
            writer.AppendLword(sp);
            writer.AppendByte(0);
            if (CheckIfNewLevel(Index_, exp))
            {
                writer.AppendWord(Player.Stats[Index_].Attributes);
                ServerSocket.Send(writer.getWorkspace(), Index_);

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ANIMATION_LEVEL_UP);
                writer.AppendDword(Player.General[Index_].UniqueID);

                ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                Formula.CalculateHP(Index_);
                Formula.CalculateMP(Index_);
                STRUpdate(Index_);
                INTUpdate(Index_);
            }
            else
            {
                ServerSocket.Send(writer.getWorkspace(), Index_);
            }

            CheckIfNewSp(Index_, sp);

            HPUpdate(Index_, false);
            MPUpdate(Index_, false);
            OnStatPacket(Index_);

            DatabaseCore.WriteQuery("UPDATE characters SET experience='{0}',level = '{1}',sp = '{2}',skillpointbar = '{3}' WHERE name='{4}'", Player.Stats[Index_].Experience, Player.Stats[Index_].Level, Player.Stats[Index_].Skillpoints, Player.Stats[Index_].SkillpointBar, Player.General[Index_].CharacterName);
            uint goldamount = (uint)(tmpGold.Gold * goldrate);

            int ItemIndex = Item.ItemAmount;

            if (goldamount < 10000)
            {
                Item.General[ItemIndex].Pk2ID = 1;
            }
            else if (goldamount >= 10000 && goldamount <= 500000)
            {
                Item.General[ItemIndex].Pk2ID = 2;
            }
            else if (goldamount >= 500001)
            {
                Item.General[ItemIndex].Pk2ID = 3;
            }

            Item.General[ItemIndex].UniqueID   = (uint)random.Next(76000000, 79999999);
            Item.General[ItemIndex].Plus       = 0;
            Item.General[ItemIndex].Durability = 0;
            Item.General[ItemIndex].Pickable   = true;
            Item.General[ItemIndex].Quantity   = goldamount;
            Item.Position[ItemIndex].XSector   = Monsters.Position[ObjectIndex].XSector;
            Item.Position[ItemIndex].YSector   = Monsters.Position[ObjectIndex].YSector;
            byte randomplace = (byte)random.Next(1, 7);

            Item.Position[ItemIndex].X = Monsters.Position[ObjectIndex].X + randomplace;
            Item.Position[ItemIndex].Z = Monsters.Position[ObjectIndex].Z;
            Item.Position[ItemIndex].Y = Monsters.Position[ObjectIndex].Y + randomplace;
            Item.General[ItemIndex].DroppedByUniqueId = Monsters.General[ObjectIndex].UniqueID;
            Item.ItemAmount++;

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);
            if (goldamount < 10000)
            {
                writer.AppendDword(1);
            }
            else if (goldamount >= 10000 && goldamount <= 500000)
            {
                writer.AppendDword(2);
            }
            else if (goldamount >= 500001)
            {
                writer.AppendDword(3);
            }
            writer.AppendDword(goldamount);
            writer.AppendDword(Item.General[ItemIndex].UniqueID);
            writer.AppendByte(Item.Position[ItemIndex].XSector);
            writer.AppendByte(Item.Position[ItemIndex].YSector);
            writer.AppendFloat(Item.Position[ItemIndex].X);
            writer.AppendFloat(Item.Position[ItemIndex].X);
            writer.AppendFloat(Item.Position[ItemIndex].Y);
            writer.AppendWord(0xDC72);
            writer.AppendByte(0);
            writer.AppendByte(0);
            writer.AppendByte(5);
            writer.AppendDword(0);
            byte[] tmpBuffer = writer.getWorkspace();

            for (int i = 0; i < Player.PlayersOnline; i++)
            {
                if (Player.General[i].CharacterID != 0)
                {
                    if (Formula.CalculateDistance(Item.Position[ItemIndex], Player.Position[i]) <= 800)
                    {
                        ServerSocket.Send(tmpBuffer, i);
                        Player.Objects[i].SpawnedItemsIndex.Add(ItemIndex);
                    }
                }
            }
        }
예제 #10
0
파일: Items.cs 프로젝트: CarlosX/DarkEmu
 private static bool CheckItemLevel(Silkroad.Item_ tmpItem, int Index_)
 {
     return tmpItem.LV_REQ <= Player.Stats[Index_].Level;
 }
예제 #11
0
파일: Items.cs 프로젝트: CarlosX/DarkEmu
        private static bool CheckItemGender(Silkroad.Item_ tmpItem, int Index_)
        {
            int Gender = 0;

            if ((Player.Stats[Index_].Model >= 1907 && Player.Stats[Index_].Model <= 1919) || (Player.Stats[Index_].Model >= 14717 && Player.Stats[Index_].Model <= 14729))
                Gender = 1;
            if ((Player.Stats[Index_].Model >= 1920 && Player.Stats[Index_].Model <= 1932) || (Player.Stats[Index_].Model >= 14730 && Player.Stats[Index_].Model <= 14742))
                Gender = 0;

            if (Gender == tmpItem.GENDER || tmpItem.GENDER == 2)
                return true;
            else
                return false;
        }
예제 #12
0
        private static void PickUpItem(int Index_, int ObjectIndex)
        {
            int[] CharacterItemIndex = DatabaseCore.Item.GetIndexByName(Player.General[Index_].CharacterName);

            PacketWriter writer = new PacketWriter();

            for (int i = 0; i < Player.PlayersOnline; i++)
            {
                if (Player.General[i].UniqueID != 0)
                {
                    double Distance = Formula.CalculateDistance(Item.Position[ObjectIndex], Player.Position[i]);
                    if (Distance <= 800)
                    {
                        if (Player.Objects[i].SpawnedItemsIndex.Contains(ObjectIndex))
                        {
                            ServerSocket.Send(Players.CreateDeSpawnPacket(Item.General[ObjectIndex].UniqueID), i);
                            Player.Objects[i].SpawnedItemsIndex.Remove(ObjectIndex);
                        }
                    }
                }
            }

            Silkroad.Item_ tmpItem = Silkroad.GetItemById(Item.General[ObjectIndex].Pk2ID);

            byte freeslot = 0;

            if (Item.General[ObjectIndex].Pk2ID == 1 || Item.General[ObjectIndex].Pk2ID == 2 || Item.General[ObjectIndex].Pk2ID == 3)
            {
                freeslot = 254;
            }
            else
            {
                freeslot = Items.FreeSlot(CharacterItemIndex);
            }

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
            writer.AppendWord(0x601);
            writer.AppendByte(freeslot);
            if (freeslot != 254)
            {
                writer.AppendDword(Item.General[ObjectIndex].Pk2ID);
            }
            if (tmpItem.ITEM_TYPE_NAME.Contains("CH") || tmpItem.ITEM_TYPE_NAME.Contains("EU"))
            {
                writer.AppendByte(Item.General[ObjectIndex].Plus);
                writer.AppendLword(0);
                writer.AppendDword((uint)tmpItem.MIN_DURA);
                writer.AppendByte(0);

                DatabaseCore.WriteQuery("UPDATE items SET itemid='{0}',plusvalue='{1}',type='0',durability='{2}' WHERE itemnumber='item{3}' AND owner ='{4}'", Item.General[ObjectIndex].Pk2ID, Item.General[ObjectIndex].Plus, Item.General[ObjectIndex].Durability, freeslot, Player.General[Index_].CharacterName);
                Items.AddItemToDatabase(CharacterItemIndex[freeslot], Item.General[ObjectIndex].Pk2ID, 0, 0, (byte)Item.General[ObjectIndex].Durability, Item.General[ObjectIndex].Plus, 0);
            }
            else if (tmpItem.ITEM_TYPE_NAME.Contains("ETC"))
            {
                if (freeslot == 254)
                {
                    writer.AppendDword(Item.General[ObjectIndex].Quantity);
                    Player.Stats[Index_].Gold += Item.General[ObjectIndex].Quantity;
                    DatabaseCore.WriteQuery("UPDATE characters SET gold='{0}' WHERE name='{1}'", Player.Stats[Index_].Gold, Player.General[Index_].CharacterName);
                }
                else
                {
                    writer.AppendWord((ushort)Item.General[ObjectIndex].Quantity);
                    DatabaseCore.WriteQuery("UPDATE items SET itemid='{0}',plusvalue='0',type='1',durability='{1}',quantity='{2}' WHERE itemnumber='item{3}' AND owner ='{4}'", Item.General[ObjectIndex].Pk2ID, Item.General[ObjectIndex].Durability, Item.General[ObjectIndex].Quantity, freeslot, Player.General[Index_].CharacterName);
                    Items.AddItemToDatabase(CharacterItemIndex[freeslot], Item.General[ObjectIndex].Pk2ID, 1, (byte)Item.General[ObjectIndex].Quantity, (byte)Item.General[ObjectIndex].Durability, 0, 0);
                }
            }

            ServerSocket.Send(writer.getWorkspace(), Index_);

            Item.General[ObjectIndex]  = new Item._General();
            Item.Position[ObjectIndex] = new _Position();

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_NEW_GOLD_AMOUNT);
            writer.AppendByte(1);
            writer.AppendLword(Player.Stats[Index_].Gold);
            writer.AppendByte(0);
            ServerSocket.Send(writer.getWorkspace(), Index_);

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ANIMATION_ITEM_PICKUP);
            writer.AppendDword(Player.General[Index_].UniqueID);
            writer.AppendByte(141);
            ServerSocket.Send(writer.getWorkspace(), Index_);

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SKILL_ATTACK);
            writer.AppendByte(2);
            writer.AppendByte(0);
            ServerSocket.Send(writer.getWorkspace(), Index_);
        }
예제 #13
0
        private static void SkillAttackType(int Index_)
        {
            PacketWriter writer = new PacketWriter();

            Silkroad.Skill_ tmpSkill = Silkroad.GetSkillById(Player.Objects[Index_].AttackingSkillID);

            byte weapontype = 0;

            if (Player.General[Index_].WeaponType == 6)
            {
                weapontype = Silkroad.TypeTable.Bow;
            }
            if ((Player.General[Index_].WeaponType == 2) || (Player.General[Index_].WeaponType == 3))
            {
                weapontype = Silkroad.TypeTable.Bicheon;
            }
            if ((Player.General[Index_].WeaponType == 4) || (Player.General[Index_].WeaponType == 5))
            {
                weapontype = Silkroad.TypeTable.Heuksal;
            }

            byte skilltype = tmpSkill.Type2;

            if (!(weapontype == skilltype) && !(skilltype == Silkroad.TypeTable.All))
            {
                Player.Objects[Index_].UsingSkill = false;
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ATTACK);
                writer.AppendWord(0xD02);
                ServerSocket.Send(writer.getWorkspace(), Index_);

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SKILL_ATTACK);
                writer.AppendWord(3);
                writer.AppendByte(4);
                ServerSocket.Send(writer.getWorkspace(), Index_);
            }
            else
            {
                int ObjectIndex = Players.GetObjectIndexAndType(Index_, Player.Objects[Index_].AttackingObjectId);
                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    Timers.MonsterMovement[ObjectIndex].Stop();
                }

                bool attack = false;

                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    attack = Movement.MoveToObject(Index_, ref Player.Position[Index_], Monsters.Position[ObjectIndex], Player.General[Index_].UniqueID, Player.General[Index_].CharacterID, tmpSkill.Distance * 10, weapontype, false);
                }

                else
                {
                    attack = Movement.MoveToObject(Index_, ref Player.Position[Index_], Player.Position[ObjectIndex], Player.General[Index_].UniqueID, Player.General[Index_].CharacterID, tmpSkill.Distance * 10, weapontype, false);
                }

                if (attack)
                {
                    Attack.BeginSkill(Index_);
                }
            }
        }
예제 #14
0
        public static void OnSpawn(PacketReader reader_, int Index_)
        {
            int  MonsterIndex = Monsters.MonsterAmount;
            uint monsterid    = reader_.ReadDword();
            byte monstertype  = reader_.ReadByte();


            uint uniqueid = (uint)Monsters.MonsterAmount + 1000;

            if (monstertype == 1)
            {
                monstertype = 0;
            }

            Silkroad.Object_ tmpMonster = Silkroad.GetObjectById(monsterid);

            PacketWriter writer = new PacketWriter();

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);

            writer.AppendDword(monsterid);
            writer.AppendDword(uniqueid);

            writer.AppendByte(Player.Position[Index_].XSector);
            writer.AppendByte(Player.Position[Index_].YSector);
            writer.AppendFloat(Player.Position[Index_].X);
            writer.AppendFloat(Player.Position[Index_].Z);
            writer.AppendFloat(Player.Position[Index_].Y);

            writer.AppendWord(0);
            writer.AppendByte(0);
            writer.AppendByte(1);
            writer.AppendByte(0);
            writer.AppendWord(0);
            writer.AppendWord(1);
            writer.AppendByte(0);

            writer.AppendFloat(tmpMonster.Speed);
            writer.AppendFloat(tmpMonster.Speed);
            writer.AppendFloat(tmpMonster.Speed);

            writer.AppendByte(0);
            writer.AppendByte(0);

            writer.AppendByte(monstertype);
            writer.AppendByte(1);
            byte[] tmpBuffer = writer.getWorkspace();
            //   ServerSocket.SendPacketInRange(writer.getWorkspace(),Index_);


            int   monsterhp = (int)tmpMonster.Hp;
            ulong exp       = tmpMonster.Exp;

            switch (monstertype)
            {
            case 2:
                monsterhp *= 2;
                exp       *= 2;
                break;

            case 3:
                exp *= 7;
                break;

            case 4:
                monsterhp *= 20;
                exp       *= 3;
                break;

            case 6:
                monsterhp *= 4;
                exp       *= 4;
                break;

            case 16:
                monsterhp *= 10;
                exp       *= 5;
                break;

            case 17:
                monsterhp *= 20;
                exp       *= 6;

                break;

            case 20:
                monsterhp *= 200;
                exp       *= 8;
                break;
            }

            Monsters.General[MonsterIndex].ID       = monsterid;
            Monsters.General[MonsterIndex].UniqueID = uniqueid;
            Monsters.General[MonsterIndex].Type     = monstertype;
            Monsters.General[MonsterIndex].HP       = monsterhp;
            Monsters.Position[MonsterIndex].XSector = Player.Position[Index_].XSector;
            Monsters.Position[MonsterIndex].YSector = Player.Position[Index_].YSector;
            Monsters.Position[MonsterIndex].X       = Player.Position[Index_].X;
            Monsters.Position[MonsterIndex].Z       = Player.Position[Index_].Z;
            Monsters.Position[MonsterIndex].Y       = Player.Position[Index_].Y;
            Monsters.General[MonsterIndex].Exp      = exp;
            Monsters.General[MonsterIndex].Level    = tmpMonster.Level;
            Monsters.General[MonsterIndex].Skills   = new ArrayList();
            Monsters.General[MonsterIndex].Dead     = false;

            for (int i = 0; i < Player.PlayersOnline; i++)
            {
                if (Player.General[i].CharacterID != 0)
                {
                    if (Formula.CalculateDistance(Monsters.Position[MonsterIndex], Player.Position[i]) <= 800)
                    {
                        ServerSocket.Send(tmpBuffer, i);
                        Player.Objects[i].SpawnedMonsterIndex.Add(MonsterIndex);
                    }
                }
            }


            uint[] skill = new uint[9];
            skill[0] = tmpMonster.Skill1;
            skill[1] = tmpMonster.Skill2;
            skill[2] = tmpMonster.Skill3;
            skill[3] = tmpMonster.Skill4;
            skill[4] = tmpMonster.Skill5;
            skill[5] = tmpMonster.Skill6;
            skill[6] = tmpMonster.Skill7;
            skill[7] = tmpMonster.Skill8;
            skill[8] = tmpMonster.Skill9;

            for (int i = 0; i <= 8; i++)
            {
                if (skill[i] != 0 && skill[i] <= 3000)
                {
                    Monsters.General[MonsterIndex].Skills.Add(skill[i]);
                }
            }

            Monsters.MonsterAmount++;

            if (monstertype == 3)
            {
                Unique.OnUnique(monsterid, false, null);
            }


            Timers.MonsterMovement[MonsterIndex].Interval = 5000;
            Timers.MonsterMovement[MonsterIndex].Start();
        }
예제 #15
0
        unsafe public static void ProcessData(byte[] buffer, int Index)
        {
            reader = new PacketReader(buffer, buffer.Length);
            reader.ModifyIndex(6);

            TPacket *tmpPacket = Silkroad.ToTPacket(buffer);

            if (debug)
            {
                Console.WriteLine("[ProcessData][{0:X}][{1} bytes][Index {2}]\n{3}\n", tmpPacket->opcode, tmpPacket->size, Index, BitConverter.ToString(buffer, 6, tmpPacket->size).Replace('-', ' '));
            }

            //Console.WriteLine("{0}", tmpPacket->opcode);

            switch (tmpPacket->opcode)
            {
            case CLIENT_OPCODES.GAME_CLIENT_KEEP_ALIVE:
            case CLIENT_OPCODES.GAME_CLIENT_ACCEPT_HANDSHAKE:
                /*if(debug)
                 *  Debugx.DumpBuffer(buffer, 1, tmpPacket->opcode, tmpPacket->size);*/
                //hansh(Index);
                Auth.SendServerInfo(Index);      //force cliente acept xD
                break;

            case CLIENT_OPCODES.GAME_CLIENT_INFO:
                Auth.SendServerInfo(Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_PATCH_REQUEST:
                Auth.SendPatchInfo(Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_AUTH:
                Auth.OnAuth(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_CHARACTER:
                Character.OnCharacter(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_INGAME_REQUEST:
                Character.OnIngameRequest(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_INGAME_NOTIFY:
                Players.OnIngameNotify(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_CHARACTER_STATE:
                Character.OnState(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_MOVEMENT:
                Movement.OnMovement(tmpPacket->data, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_CLOSE:
                OnGameQuit(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_EMOTION:
                PlayerAction.OnEmotion(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_ITEM_MOVE:
                Items.MoveItem(tmpPacket->data, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_CHAT:
                Chat.OnChat(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_TARGET:
                Players.OnTarget(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_MASTERYUPDATE:
                Mastery.OnMasteryUpdate(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_SKILLUPDATE:
                Mastery.OnSkillUpdate(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_STR_UPDATE:
                Stats.STRUpdate(Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_INT_UPDATE:
                Stats.INTUpdate(Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_PLAYER_ACTION:
                PlayerAction.Action(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_RESPAWN:
                Character.ReSpawnMe(Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_GM:
                GameMaster.OnGM(reader, Index);
                break;

            case CLIENT_OPCODES.GAME_CLIENT_ITEM_USE:
                Items.OnUseItem(reader, Index);
                break;

            default:
                Console.WriteLine("Default Opcode:{0}", tmpPacket->opcode);
                break;
            }
        }
예제 #16
0
파일: Items.cs 프로젝트: Pascal1000/server1
        public static void OnUseItem(PacketReader reader, int Index_)
        {
            int[] CharacterItemIndex = DatabaseCore.Item.GetIndexByName(Player.General[Index_].CharacterName);
            byte  slot = reader.ReadByte();

            Silkroad.Item_ item = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemIndex[slot]]);

            if (DatabaseCore.Item.ItemId[CharacterItemIndex[slot]] >= 4 && DatabaseCore.Item.ItemId[CharacterItemIndex[slot]] <= 23)
            {
                if ((DatabaseCore.Item.Quantity[CharacterItemIndex[slot]] - 1) > 0)
                {
                    DatabaseCore.Item.Quantity[CharacterItemIndex[slot]]--;
                }
                else
                {
                    DeleteFromDatabase(CharacterItemIndex[slot]);
                    DatabaseCore.WriteQuery("DELETE FROM items WHERE itemnumber='item{0}' AND owner='{1}'", slot, Player.General[Index_].CharacterName);
                }

                PacketWriter writer = new PacketWriter();
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_USE);
                writer.AppendByte(1);
                writer.AppendByte(slot);
                writer.AppendWord(DatabaseCore.Item.Quantity[CharacterItemIndex[slot]]);
                writer.AppendWord(reader.ReadWord());
                ServerSocket.Send(writer.getWorkspace(), Index_);

                writer = new PacketWriter();
                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ANIMATION_POTION);
                writer.AppendDword(Player.General[Index_].UniqueID);
                if (item.ITEM_TYPE_NAME.Contains("HP") && !item.ITEM_TYPE_NAME.Contains("SPOTION"))
                {
                    writer.AppendDword(0x04);
                    ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                    Player.Stats[Index_].CHP += item.USE_TIME;
                    Stats.HPUpdate(Index_, false);
                }
                else if (item.ITEM_TYPE_NAME.Contains("HP") && item.ITEM_TYPE_NAME.Contains("SPOTION"))
                {
                    writer.AppendDword(0x04);
                    ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                    Player.Stats[Index_].CHP += ((int)Player.Stats[Index_].HP * item.USE_TIME2 / 100);
                    Stats.HPUpdate(Index_, false);
                }
                else if (item.ITEM_TYPE_NAME.Contains("MP") && !item.ITEM_TYPE_NAME.Contains("SPOTION"))
                {
                    writer.AppendDword(0x0E);
                    ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                    Player.Stats[Index_].CMP += item.USE_TIME3;
                    Stats.MPUpdate(Index_, false);
                }
                else if (item.ITEM_TYPE_NAME.Contains("MP") && item.ITEM_TYPE_NAME.Contains("SPOTION"))
                {
                    writer.AppendDword(0x0E);
                    ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                    Player.Stats[Index_].CMP += ((int)Player.Stats[Index_].MP * item.USE_TIME4 / 100);
                    Stats.MPUpdate(Index_, false);
                }
                else if (item.ITEM_TYPE_NAME.Contains("ALL") && !item.ITEM_TYPE_NAME.Contains("SPOTION"))
                {
                    writer.AppendDword(0x17);
                    ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                    Player.Stats[Index_].CHP += item.USE_TIME;
                    Player.Stats[Index_].CMP += item.USE_TIME3;
                    Stats.HPMPUpdate(Index_);
                }
                else if (item.ITEM_TYPE_NAME.Contains("ALL") && item.ITEM_TYPE_NAME.Contains("SPOTION"))
                {
                    writer.AppendDword(0x17);
                    ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

                    Player.Stats[Index_].CHP += ((int)Player.Stats[Index_].HP * item.USE_TIME2 / 100);
                    Player.Stats[Index_].CMP += ((int)Player.Stats[Index_].MP * item.USE_TIME4 / 100);
                    Stats.HPMPUpdate(Index_);
                }
            }
        }
예제 #17
0
        public static void NormalAttack(int Index_)
        {
            uint SkillId      = 0;
            byte AttackAmount = GetAmountAndSkillIdByWeaponType(Index_, ref SkillId);

            bool AttackingPlayer = false;

            for (int i = 0; i <= Player.PlayersOnline; i++)
            {
                if (Player.Objects[Index_].AttackingObjectId == Player.General[i].UniqueID)
                {
                    AttackingPlayer = true;
                }
            }

            int ObjectIndex = Players.GetObjectIndexAndType(Index_, Player.Objects[Index_].AttackingObjectId);

            Silkroad.Skill_ tmpAttackSkill = Silkroad.GetSkillById(SkillId);

            uint BasicAttackPower = 0;

            if (tmpAttackSkill.Type == Silkroad.TypeTable.Phy)
            {
                BasicAttackPower = (uint)random.Next(Player.Stats[Index_].MinPhy, Player.Stats[Index_].MaxPhy);
            }
            else if (tmpAttackSkill.Type == Silkroad.TypeTable.Mag)
            {
                BasicAttackPower = (uint)random.Next(Player.Stats[Index_].MinMag, Player.Stats[Index_].MaxMag);
            }

            double SkillAttackPower  = 1; //cause its normal attack
            double SkillIncreaseRate = 0; // needs to be calculated from passive skills/active buffs

            double EnemyAbsorbation = 0;

            if (AttackingPlayer)
            {
                EnemyAbsorbation = Player.Stats[ObjectIndex].TotalAccessoriesAbsorption / (double)100;
            }

            double EnemyDefence = 0;

            if (AttackingPlayer)
            {
                if (tmpAttackSkill.Type == Silkroad.TypeTable.Phy)
                {
                    EnemyDefence = Player.Stats[ObjectIndex].PhyDef;
                }
                else if (tmpAttackSkill.Type == Silkroad.TypeTable.Mag)
                {
                    EnemyDefence = Player.Stats[ObjectIndex].MagDef;
                }
            }
            else
            {
                if (tmpAttackSkill.Type == Silkroad.TypeTable.Phy)
                {
                    EnemyDefence = Silkroad.GetObjectById(Monsters.General[ObjectIndex].ID).PhyDef;
                }
                else if (tmpAttackSkill.Type == Silkroad.TypeTable.Mag)
                {
                    EnemyDefence = Silkroad.GetObjectById(Monsters.General[ObjectIndex].ID).MagDef;
                }
            }

            double TotalDamageIncreaseRate = 0;//needs to be calculated from the players equipment

            double Damage = Formula.CalculateDmg(
                BasicAttackPower,
                SkillAttackPower,
                SkillIncreaseRate,
                EnemyAbsorbation,
                EnemyDefence,
                Player.Stats[Index_].Level,
                Player.Stats[Index_].Strength,
                Player.Stats[Index_].Intelligence,
                TotalDamageIncreaseRate,
                tmpAttackSkill.PwrPercent / (double)100);

            byte Critical = 0;

            Player.Objects[Index_].NormalAttack = true;

            if (Player.Objects[Index_].SelectedObjectType == 2)
            {
                Timers.MonsterMovement[ObjectIndex].Stop();
            }

            PacketWriter writer = new PacketWriter();

            writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ATTACK);
            writer.AppendByte(1);
            writer.AppendByte(2);
            writer.AppendDword(SkillId);
            writer.AppendDword(Player.General[Index_].UniqueID);
            writer.AppendDword((uint)(random.Next(1000, 10000) + Player.General[Index_].UniqueID));
            writer.AppendDword(Player.Objects[Index_].AttackingObjectId);
            writer.AppendByte(1);
            writer.AppendByte(AttackAmount);
            writer.AppendByte(1);
            writer.AppendDword(Player.Objects[Index_].AttackingObjectId);

            byte afterstate = 0;

            for (int i = 1; i <= AttackAmount; i++)
            {
                if (tmpAttackSkill.Type == Silkroad.TypeTable.Phy)
                {
                    if (random.Next(1, 10) >= 7)
                    {
                        Damage  *= 2;
                        Critical = 2;
                    }
                }
                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    Monsters.General[ObjectIndex].HP -= (int)Damage;
                    if (Monsters.General[ObjectIndex].HP < 0)
                    {
                        afterstate = 0x80;
                        Monsters.General[ObjectIndex].HP = 0;
                    }
                }
                else if (Player.Objects[Index_].SelectedObjectType == 1)
                {
                    int tmpHp = (int)(Player.Stats[ObjectIndex].CHP - Damage);
                    if (tmpHp < 0)
                    {
                        afterstate = 0x80;
                        Player.Stats[ObjectIndex].CHP = 0;
                    }
                    else
                    {
                        Player.Stats[ObjectIndex].CHP -= (int)Damage;
                    }
                }

                writer.AppendByte(afterstate);
                writer.AppendByte(Critical);
                writer.AppendDword((uint)Damage);
                writer.AppendByte(0);
                writer.AppendWord(0);
            }

            ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);

            Player.General[Index_].Busy          = true;
            Player.Objects[Index_].NormalAttack  = true;
            Timers.PlayerAttack[Index_].Interval = 1350.0;
            Timers.PlayerAttack[Index_].Start();


            if (afterstate == 0x80)
            {
                Player.Objects[Index_].AttackingObjectDeadID = Player.Objects[Index_].AttackingObjectId;

                Player.General[Index_].Busy = false;
                Timers.PlayerAttack[Index_].Stop();
                Player.Objects[Index_].NormalAttack = false;
                if (Player.Objects[Index_].SelectedObjectType == 1)
                {
                    Player.General[ObjectIndex].State        = 10;
                    Player.Objects[ObjectIndex].NormalAttack = false;
                    Player.General[ObjectIndex].Busy         = false;
                    Timers.PlayerAttack[ObjectIndex].Stop();

                    Character.Die(ObjectIndex);
                    Character.Die2(ObjectIndex);
                    Player.Flags[ObjectIndex].Dead = true;
                }
                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    Stats.GetBerserk(Index_, ObjectIndex);
                    Stats.GetXP(Index_, ObjectIndex);

                    if (Monsters.General[ObjectIndex].Type == 3)
                    {
                        Unique.OnUnique((uint)Monsters.General[ObjectIndex].ID, true, Player.General[Index_].CharacterName);
                    }

                    Monsters.General[ObjectIndex].Dead = true;

                    Timers.MonsterAttack[ObjectIndex].Stop();
                    Timers.MonsterDeath[Index_].Interval = 3000.0;
                    Timers.MonsterDeath[Index_].Start();
                }
            }
            else
            {
                if (Player.Objects[Index_].SelectedObjectType == 2)
                {
                    if (!Timers.MonsterAttack[ObjectIndex].Enabled)
                    {
                        Monsters.General[ObjectIndex].AttackingObjectIndex = Index_;
                        Timers.MonsterAttack[ObjectIndex].Interval         = 2350;
                        Timers.MonsterAttack[ObjectIndex].Start();
                    }
                }
            }
        }
예제 #18
0
파일: Items.cs 프로젝트: Pascal1000/server1
        unsafe public static void MoveItem(byte *ptr, int Index_)
        {
            Silkroad.C_S.MOVE_ITEM *tmpPtr = (Silkroad.C_S.MOVE_ITEM *)ptr;

            PacketWriter writer = new PacketWriter();

            switch (tmpPtr->Type)
            {
            case 0:

                int[]          CharacterItemIndex = DatabaseCore.Item.GetIndexByName(Player.General[Index_].CharacterName);
                Silkroad.Item_ SourceItem_        = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemIndex[tmpPtr->Source]]);
                Silkroad.Item_ DestinationItem_   = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemIndex[tmpPtr->Destination]]);

                if (SourceItem_.ITEM_TYPE_NAME.Contains("FRPVP_VOUCHER"))
                {
                    if (Player.Stats[Index_].Level >= 10 && CheckItemGender(SourceItem_, Index_))
                    {
                        writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ANIMATION_CAPE);
                        writer.AppendDword(Player.General[Index_].UniqueID);
                        writer.AppendWord(0x102);
                        writer.AppendByte(0xA);

                        ServerSocket.SendPacketIfPlayerIsSpawned(writer.getWorkspace(), Index_);
                        Timers.UsingItemTimer[Index_].Interval      = 10000;
                        Player.Objects[Index_].SourceItemIndex      = CharacterItemIndex[tmpPtr->Source];
                        Player.Objects[Index_].DestinationItemIndex = CharacterItemIndex[tmpPtr->Destination];
                        Timers.UsingItemTimer[Index_].Start();
                    }
                    else
                    {
                        writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                        writer.AppendWord(0x1002);
                        ServerSocket.Send(writer.getWorkspace(), Index_);
                    }
                }
                else
                {
                    if (tmpPtr->Destination < 13)
                    {
                        if (!SourceItem_.ITEM_TYPE_NAME.Contains("ETC"))
                        {
                            if (!CheckItemGender(SourceItem_, Index_))
                            {
                                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                                writer.AppendWord(0x1602);
                                ServerSocket.Send(writer.getWorkspace(), Index_);
                                return;
                            }
                            else if (!CheckItemLevel(SourceItem_, Index_))
                            {
                                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                                writer.AppendWord(0x1002);
                                ServerSocket.Send(writer.getWorkspace(), Index_);
                                return;
                            }

                            if (tmpPtr->Destination == 6)
                            {
                                Player.General[Index_].WeaponType = SourceItem_.CLASS_C;
                            }

                            Silkroad.Item_ WeaponItem = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemIndex[6]]);

                            Console.WriteLine(WeaponItem.CLASS_C);
                            if (tmpPtr->Destination == 6 && DatabaseCore.Item.ItemId[CharacterItemIndex[7]] != 0 && (Player.General[Index_].WeaponType != 2 && Player.General[Index_].WeaponType != 3 && Player.General[Index_].WeaponType != 7 && Player.General[Index_].WeaponType != 10 && Player.General[Index_].WeaponType != 15))
                            {
                                byte unequipped = UnEnquipShield(Index_, CharacterItemIndex, CharacterItemIndex[7]);
                                if (unequipped != 255)
                                {
                                    MoveItemToDatabase(CharacterItemIndex[7], unequipped, Player.General[Index_].CharacterName);
                                }
                            }

                            if (tmpPtr->Destination == 7 && DatabaseCore.Item.ItemId[CharacterItemIndex[6]] != 0 && (WeaponItem.CLASS_C != 2 && WeaponItem.CLASS_C != 3 && WeaponItem.CLASS_C != 7 && WeaponItem.CLASS_C != 10 && WeaponItem.CLASS_C != 15))
                            {
                                byte unequipped = UnEnquipWeapon(Index_, CharacterItemIndex, CharacterItemIndex[6]);
                                if (unequipped != 255)
                                {
                                    MoveItemToDatabase(CharacterItemIndex[6], unequipped, Player.General[Index_].CharacterName);
                                }
                            }

                            EquipItem(Index_, CharacterItemIndex[tmpPtr->Source], CharacterItemIndex[tmpPtr->Destination]);
                        }
                        else
                        {
                            if (!(tmpPtr->Destination == 7 && (Player.General[Index_].WeaponType == 6 || Player.General[Index_].WeaponType == 12) && DatabaseCore.Item.ItemId[CharacterItemIndex[7]] != 0))
                            {
                                return;
                            }
                        }
                    }
                    if (tmpPtr->Source < 13)
                    {
                        UnEquipItem(Index_, CharacterItemIndex[tmpPtr->Source], CharacterItemIndex[tmpPtr->Destination]);
                    }

                    writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                    writer.AppendByte(1);
                    writer.AppendByte(tmpPtr->Type);
                    writer.AppendByte(tmpPtr->Source);
                    writer.AppendByte(tmpPtr->Destination);
                    writer.AppendWord(tmpPtr->Amount);
                    writer.AppendByte(0);
                    ServerSocket.Send(writer.getWorkspace(), Index_);

                    MoveItemToDatabase(CharacterItemIndex[tmpPtr->Source], CharacterItemIndex[tmpPtr->Destination], Player.General[Index_].CharacterName);
                }
                Stats.OnStatPacket(Index_);
                break;

            case 7:
                CharacterItemIndex = DatabaseCore.Item.GetIndexByName(Player.General[Index_].CharacterName);

                int ItemIndex = Item.ItemAmount;
                Item.General[ItemIndex].Pk2ID      = DatabaseCore.Item.ItemId[CharacterItemIndex[tmpPtr->Source]];
                Item.General[ItemIndex].UniqueID   = (uint)random.Next(76000000, 79999999);
                Item.General[ItemIndex].Plus       = DatabaseCore.Item.PlusValue[CharacterItemIndex[tmpPtr->Source]];
                Item.General[ItemIndex].Durability = DatabaseCore.Item.Durability[CharacterItemIndex[tmpPtr->Source]];
                Item.General[ItemIndex].Pickable   = true;
                Item.General[ItemIndex].Quantity   = DatabaseCore.Item.Quantity[CharacterItemIndex[tmpPtr->Source]];
                Item.Position[ItemIndex].XSector   = Player.Position[Index_].XSector;
                Item.Position[ItemIndex].YSector   = Player.Position[Index_].YSector;
                byte randomplace = (byte)random.Next(1, 7);
                Item.Position[ItemIndex].X = Player.Position[Index_].X + randomplace;
                Item.Position[ItemIndex].Z = Player.Position[Index_].Z;
                Item.Position[ItemIndex].Y = Player.Position[Index_].Y + randomplace;
                Item.General[ItemIndex].DroppedByUniqueId = Player.General[Index_].UniqueID;
                Item.ItemAmount++;

                writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                writer.AppendByte(1);
                writer.AppendByte(tmpPtr->Type);
                writer.AppendByte(tmpPtr->Source);
                ServerSocket.Send(writer.getWorkspace(), Index_);

                Silkroad.Item_ tmpItem = Silkroad.GetItemById(DatabaseCore.Item.ItemId[CharacterItemIndex[tmpPtr->Source]]);

                byte[] tmpBuffer = new byte[0];
                if (tmpItem.ITEM_TYPE_NAME.Contains("CH") || tmpItem.ITEM_TYPE_NAME.Contains("EU"))
                {
                    writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);
                    writer.AppendDword(DatabaseCore.Item.ItemId[CharacterItemIndex[tmpPtr->Source]]);
                    writer.AppendByte(DatabaseCore.Item.PlusValue[CharacterItemIndex[tmpPtr->Source]]);
                    writer.AppendDword(Item.General[ItemIndex].UniqueID);
                    writer.AppendByte(Item.Position[ItemIndex].XSector);
                    writer.AppendByte(Item.Position[ItemIndex].YSector);
                    writer.AppendFloat(Item.Position[ItemIndex].X);
                    writer.AppendFloat(Item.Position[ItemIndex].X);
                    writer.AppendFloat(Item.Position[ItemIndex].Y);
                    writer.AppendWord(0xAAA6);
                    writer.AppendByte(0);
                    writer.AppendByte(0);
                    writer.AppendByte(6);
                    writer.AppendDword(Item.General[ItemIndex].DroppedByUniqueId);
                    tmpBuffer = writer.getWorkspace();
                }
                else if (tmpItem.ITEM_TYPE_NAME.Contains("ETC"))
                {
                    writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);
                    writer.AppendDword(DatabaseCore.Item.ItemId[CharacterItemIndex[tmpPtr->Source]]);
                    writer.AppendDword(Item.General[ItemIndex].UniqueID);
                    writer.AppendByte(Item.Position[ItemIndex].XSector);
                    writer.AppendByte(Item.Position[ItemIndex].YSector);
                    writer.AppendFloat(Item.Position[ItemIndex].X);
                    writer.AppendFloat(Item.Position[ItemIndex].X);
                    writer.AppendFloat(Item.Position[ItemIndex].Y);
                    writer.AppendWord(0xAAA6);
                    writer.AppendByte(0);
                    writer.AppendByte(0);
                    writer.AppendByte(6);
                    writer.AppendDword(Item.General[ItemIndex].DroppedByUniqueId);
                    tmpBuffer = writer.getWorkspace();
                }

                for (int i = 0; i < Player.PlayersOnline; i++)
                {
                    if (Player.General[i].CharacterID != 0)
                    {
                        if (Formula.CalculateDistance(Item.Position[ItemIndex], Player.Position[i]) <= 800)
                        {
                            ServerSocket.Send(tmpBuffer, i);
                            Player.Objects[i].SpawnedItemsIndex.Add(ItemIndex);
                        }
                    }
                }

                DatabaseCore.WriteQuery("UPDATE items SET itemid='0',plusvalue='0' ,durability='30' WHERE itemnumber='item{0}' AND owner='{1}'", tmpPtr->Source, Player.General[Index_].CharacterName);
                Stats.OnStatPacket(Index_);

                DeleteFromDatabase(CharacterItemIndex[tmpPtr->Source]);

                break;

            case 10:
                if (Player.Stats[Index_].Gold != 0)
                {
                    PacketReader reader = new PacketReader(ptr, 5);
                    reader.ModifyIndex(1);
                    uint goldamount = reader.ReadDword();


                    ItemIndex = Item.ItemAmount;
                    if (goldamount < 10000)
                    {
                        Item.General[ItemIndex].Pk2ID = 1;
                    }
                    else if (goldamount >= 10000 && goldamount <= 500000)
                    {
                        Item.General[ItemIndex].Pk2ID = 2;
                    }
                    else if (goldamount >= 500001)
                    {
                        Item.General[ItemIndex].Pk2ID = 3;
                    }

                    Item.General[ItemIndex].UniqueID   = (uint)random.Next(76000000, 79999999);
                    Item.General[ItemIndex].Plus       = 0;
                    Item.General[ItemIndex].Durability = 0;
                    Item.General[ItemIndex].Pickable   = true;
                    Item.General[ItemIndex].Quantity   = goldamount;
                    Item.Position[ItemIndex].XSector   = Player.Position[Index_].XSector;
                    Item.Position[ItemIndex].YSector   = Player.Position[Index_].YSector;
                    randomplace = (byte)random.Next(1, 7);
                    Item.Position[ItemIndex].X = Player.Position[Index_].X + randomplace;
                    Item.Position[ItemIndex].Z = Player.Position[Index_].Z;
                    Item.Position[ItemIndex].Y = Player.Position[Index_].Y + randomplace;
                    Item.General[ItemIndex].DroppedByUniqueId = Player.General[Index_].UniqueID;
                    Item.ItemAmount++;

                    writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_SPAWN);
                    if (goldamount < 10000)
                    {
                        writer.AppendDword(1);
                    }
                    else if (goldamount >= 10000 && goldamount <= 500000)
                    {
                        writer.AppendDword(2);
                    }
                    else if (goldamount >= 500001)
                    {
                        writer.AppendDword(3);
                    }
                    writer.AppendDword(goldamount);
                    writer.AppendDword(Item.General[ItemIndex].UniqueID);
                    writer.AppendByte(Item.Position[ItemIndex].XSector);
                    writer.AppendByte(Item.Position[ItemIndex].YSector);
                    writer.AppendFloat(Item.Position[ItemIndex].X);
                    writer.AppendFloat(Item.Position[ItemIndex].X);
                    writer.AppendFloat(Item.Position[ItemIndex].Y);
                    writer.AppendWord(0xDC72);
                    writer.AppendByte(0);
                    writer.AppendByte(0);
                    writer.AppendByte(6);
                    writer.AppendDword(0);

                    tmpBuffer = writer.getWorkspace();

                    for (int i = 0; i < Player.PlayersOnline; i++)
                    {
                        if (Player.General[i].CharacterID != 0)
                        {
                            if (Formula.CalculateDistance(Item.Position[ItemIndex], Player.Position[i]) <= 800)
                            {
                                ServerSocket.Send(tmpBuffer, i);
                                Player.Objects[i].SpawnedItemsIndex.Add(ItemIndex);
                            }
                        }
                    }

                    Player.Stats[Index_].Gold -= goldamount;
                    writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_NEW_GOLD_AMOUNT);
                    writer.AppendByte(1);
                    writer.AppendLword(Player.Stats[Index_].Gold);
                    writer.AppendByte(0);
                    ServerSocket.Send(writer.getWorkspace(), Index_);


                    writer.SetOpcode(SERVER_OPCODES.GAME_SERVER_ITEM_MOVEMENT);
                    writer.AppendByte(1);
                    writer.AppendByte(10);
                    writer.AppendDword(goldamount);
                    ServerSocket.Send(writer.getWorkspace(), Index_);

                    DatabaseCore.WriteQuery("UPDATE characters SET gold='{0}' WHERE name='{1}'", Player.Stats[Index_].Gold, Player.General[Index_].CharacterName);
                }
                break;
            }
        }