Int32() 공개 메소드

public Int32 ( ) : int
리턴 int
예제 #1
0
파일: Friends.cs 프로젝트: CarlosX/DarkEmu
        /////////////////////////////////////////////////////////////////////////////////
        // Friend add response
        /////////////////////////////////////////////////////////////////////////////////
        void FriendAddResponse()
        {
            try
            {
                PacketReader reader = new PacketReader(PacketInformation.buffer);
                int Inviterid = reader.Int32();
                int Myid = reader.Int32();
                byte State = reader.Byte();
                reader.Close();

                Systems sys = GetPlayer(Inviterid);
                if (sys != null)
                {
                    if (State == 0)
                    {
                        //Declined
                        client.Send(Packet.FriendDecline(Character.Information.Name));
                        sys.client.Send(Packet.FriendDecline(Character.Information.Name));
                    }
                    else
                    {
                        //Accepted
                        sys.client.Send(Packet.FriendData(Myid, 2, Character.Information.Name, Character, false));
                        client.Send(Packet.FriendData(Inviterid, 2, sys.Character.Information.Name, sys.Character, false));
                        MsSQL.InsertData("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + Character.Information.CharacterID + "','" + sys.Character.Information.CharacterID + "','" + sys.Character.Information.Model + "')");
                        MsSQL.InsertData("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + sys.Character.Information.CharacterID + "','" + Character.Information.CharacterID + "','" + Character.Information.Model + "')");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Friend Add Response Error {0}", ex);
                Systems.Debugger.Write(ex);
            }
        }
예제 #2
0
        void GuildTransferLeaderShip()
        {
            try
            {
                //Create new packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Read guild id
                int Guildid = Reader.Int32();
                //Read guild member id to transfer to
                int GuildMemberID = Reader.Int32();
                //Close reader
                Reader.Close();

                //Get detailed player information
                Systems NewLeader = GetPlayerid(GuildMemberID);

                //Update database
                MsSQL.InsertData("UPDATE guild_members SET guild_rank='10',guild_perm_join='0',guild_perm_withdraw='0',guild_perm_union='0',guild_perm_storage='0',guild_perm_notice='0' WHERE guild_member_id='" + Character.Information.CharacterID + "'");
                MsSQL.InsertData("UPDATE guild_members SET guild_rank='0',guild_perm_join='1',guild_perm_withdraw='1',guild_perm_union='1',guild_perm_storage='1',guild_perm_notice='1' WHERE guild_member_id='" + GuildMemberID + "'");

                //Repeat for each member in our guild
                foreach (int member in Character.Network.Guild.Members)
                {
                    //Make sure member is not null
                    if (member != 0)
                    {
                        //Get information for the guildmember
                        Systems guildmember = GetPlayerMainid(member);
                        //Make sure the guildmember isnt null
                        if (guildmember != null)
                        {
                            //Send update packet of new leader
                            guildmember.client.Send(Packet.GuildUpdate(Character, 3, GuildMemberID, 0, 0));
                        }
                    }
                }
                //Send message to old owner
                PacketWriter Writer = new PacketWriter();
                //Add opcode
                Writer.Create(Systems.SERVER_GUILD_TRANSFER_MSG);
                //Static byte 1
                Writer.Byte(1);
                //Send bytes to client
                client.Send(Writer.GetBytes());
            }
            //If a bad exception error happens
            catch (Exception ex)
            {
                //Write information to the console
                Console.WriteLine("Guild Transfer Error: {0}", ex);
                //Write information to the debug log
                Systems.Debugger.Write(ex);
            }
        }
예제 #3
0
파일: Renaming.cs 프로젝트: CarlosX/DarkEmu
 void RenameParty()
 {
     try
     {
         //Create new packet reader
         PacketReader reader = new PacketReader(PacketInformation.buffer);
         //First integer is party id
         int partyid = reader.Int32();
         //Second integer is not needed
         int NotNeeded = reader.Int32();
         //Byte party type
         byte ptype = reader.Byte();
         //Byte party purpose
         byte purpose = reader.Byte();
         //Byte minimum level
         byte minlevel = reader.Byte();
         //Byte max level to enter party
         byte maxlevel = reader.Byte();
         //Party name lenght
         short namel = reader.Int16();
         //Party name each character is a word value using text3
         string pname = reader.Text3();
         //Create new packet writer
         PacketWriter Writer = new PacketWriter();
         //Add opcode to server packet
         Writer.Create(Systems.SERVER_PARTY_CHANGENAME);
         //Write static byte 1
         Writer.Byte(1);
         //Write party id
         Writer.DWord(partyid);
         //Write dword 0
         Writer.DWord(0);
         //Write party type
         Writer.Byte(ptype);
         //Write party purpose
         Writer.Byte(purpose);
         //Write party minimum level
         Writer.Byte(minlevel);
         //Write party max level
         Writer.Byte(maxlevel);
         //Write party name
         Writer.Text3(pname);
         //Send bytes to client
         client.Send(Writer.GetBytes());
     }
     //If a error happens
     catch (Exception ex)
     {
         //Write the exception to the log
         Systems.Debugger.Write(ex);
     }
 }
예제 #4
0
파일: Jobs.cs 프로젝트: CarlosX/DarkEmu
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Create Job Alias
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 public void MakeAlias()
 {
     try
     {
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         PacketReader Reader = new PacketReader(PacketInformation.buffer);
         int id = Reader.Int32();
         byte type = Reader.Byte();
         short nLenght = Reader.Int16();
         string name = Reader.String(nLenght);
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         Console.WriteLine(name);
         MsSQL ms = new MsSQL("SELECT * FROM character_jobs WHERE job_alias='" + name + "'");
         int checkjob = ms.Count();
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         client.Send(Packet.MakeAlias(name, type));
         if (checkjob == 0)
         {
             client.Send(Packet.MakeAlias(name, type));
             MsSQL.UpdateData("UPDATE character_jobs SET job_alias='" + name + "' WHERE character_name='" + Character.Information.Name + "'");
         }
         else if (checkjob >= 0)
         {
             client.Send(Packet.MakeAliasError(name, type));
         }
     }
     catch (Exception ex)
     {
         Systems.Debugger.Write(ex);
     }
 }
예제 #5
0
파일: Union.cs 프로젝트: CarlosX/DarkEmu
        /////////////////////////////////////////////////////////////////////////
        // Union Apply
        /////////////////////////////////////////////////////////////////////////
        void unionapply()
        {
            try
            {
                //Open our packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Get target id (Targeted).
                int Target = Reader.Int32();
                //Close reader
                Reader.Close();

                //Get target details
                Systems targetplayer = GetPlayer(Target);
                //Make sure the target is still there
                if (targetplayer != null)
                {
                    //If allready in union
                    if (targetplayer.Character.Network.Guild.UnionActive) return;
                    //Set bools for both players
                    targetplayer.Character.State.UnionApply = true;
                    this.Character.State.UnionApply = true;
                    //Set target player to us
                    targetplayer.Character.Network.TargetID = this.Character.Information.UniqueID;
                    //Send request to targeted player
                    targetplayer.client.Send(Packet.PartyRequest(6, this.Character.Information.UniqueID, 0));
                }
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #6
0
        void HandleRegisterIcon()
        {
            try
            {
                PacketReader reader = new PacketReader(PacketInformation.buffer);
                byte type = reader.Byte();
                int iconlenght = reader.Int32();
                string icon = reader.Text();
                reader.Close();

                string convertedicon = ConvertToHex(icon);
                //Save output to .dat file in hex formatting.
            }
            catch (Exception ex)
            {
                Console.WriteLine("Guild icon register error {0}", ex);
            }
        }
예제 #7
0
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Close Horse Type
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        protected void HandleClosePet()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                int petid = Reader.Int32();

                if (petid == Character.Transport.Horse.UniqueID)
                {
                    Send(Packet.Player_UpToHorse(this.Character.Information.UniqueID, false, petid));
                    client.Send(Packet.PetSpawn(petid, 1, Character.Transport.Horse));
                    Character.Transport.Horse.DeSpawnMe();
                    Character.Transport.Right = false;
                    if (Character.Position.Walking) Timer.Movement.Dispose();
                }
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #8
0
 void GuildTitle()
 {
     //Wrap our function inside a catcher
     try
     {
         //Extra hack check
         if (Character.Network.Guild.Level < 4)
             return;
         //Create new packet reader
         PacketReader Reader = new PacketReader(PacketInformation.buffer);
         //Read integer guild member selected
         int SelectedGuildMember = Reader.Int32();
         //Read short lenght of title for guild member
         short GuildMemberTitleLEN = Reader.Int16();
         //Read string guild member title
         string GuildMemberTitle = Reader.String(GuildMemberTitleLEN);
         //Close packet reader
         Reader.Close();
         //Get selected guild member information
         Systems playerinfo = GetPlayerMainid(SelectedGuildMember);
         //Make sure the character is still there
         if (playerinfo.Character != null)
         {
             //Update database set new title
             MsSQL.InsertData("UPDATE guild_members SET guild_grant='" + GuildMemberTitle + "' WHERE guild_member_id='" + playerinfo.Character.Information.CharacterID + "'");
             //Send new character guild title update to each player in spawn reach
             Send(Packet.GuildSetTitle(Character.Guild.GuildID, playerinfo.Character.Information.Name, GuildMemberTitle));
             //Send Final packet to client
             playerinfo.client.Send(Packet.GuildSetTitle2(Character.Guild.GuildID, SelectedGuildMember, GuildMemberTitle));
         }
     }
     //Catch bad exception errors
     catch (Exception ex)
     {
         //Write information to the console
         Console.WriteLine("Guild Title Error: {0}", ex);
         //Write information to debug log
         Systems.Debugger.Write(ex);
     }
 }
예제 #9
0
파일: GuildWar.cs 프로젝트: CarlosX/DarkEmu
        void GuildWarGold()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                int guildid = Reader.Int32();
                Reader.Close();

                if (Character.Guild.GuildWarGold == 0)
                {
                    //Send Packet Message No War Gold Received
                    client.Send(Packet.GuildWarMsg(2));
                }
                else
                {
                    //Sniff packet for war gold
                }
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #10
0
파일: Stall.cs 프로젝트: CarlosX/DarkEmu
        public void EnterStall()
        {
            try
            {
                if (Character.Information.Scroll) return;
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                Systems staller = GetPlayer(Reader.Int32());

                Character.Network.Stall = staller.Character.Network.Stall;

                staller.Character.Network.Stall.Members.Add(Character.Information.UniqueID);
                staller.Character.Network.Stall.MembersClient.Add(this.client);

                client.Send(Packet.EnterStall(Character.Information.UniqueID, staller.Character.Network.Stall));

                staller.Character.Network.Stall.Send(Packet.StallPlayerUpdate(Character.Information.UniqueID, 2), this.client);
                Character.Stall.Stallactive = true;
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #11
0
파일: Exchange.cs 프로젝트: CarlosX/DarkEmu
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Exchange Request
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void Exchange_Request()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                int targetid = Reader.Int32();
                Reader.Close();

                Systems sys = GetPlayer(targetid);
                Character.Network.TargetID = targetid;

                sys.Character.Network.TargetID = this.Character.Information.UniqueID;
                sys.client.Send(Packet.PartyRequest(1, this.Character.Information.UniqueID, 0));

                Character.State.Exchanging = true;
                sys.Character.State.Exchanging = true;
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #12
0
        void GuildPermissions()
        {
            try
            {
                //Create new packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Skip first
                Reader.Skip(1);
                //Read member id
                int memberid = Reader.Int32();
                //Read permission byte
                byte permissions = (byte)Reader.Int32();
                //Set new char bits 8
                char[] bits = new char[8];
                //Repeat for each 8 bits
                for (int i = 0; i < 8; ++i) bits[i] = (char)0;
                //Convert bits to string / to char array
                bits = Convert.ToString(permissions, 2).ToCharArray();
                //Close reader
                Reader.Close();
                //Set amount to player targetindex
                int targetindex = this.Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == memberid);
                //If character is online
                if (this.Character.Network.Guild.MembersInfo[targetindex].Online)
                {
                    //Get detailed player information
                    Systems member = GetPlayerMainid(memberid);
                    //Set bits
                    member.Character.Network.Guild.joinRight = bits[4] == '1' ? true : false;
                    member.Character.Network.Guild.withdrawRight = bits[3] == '1' ? true : false;
                    member.Character.Network.Guild.unionRight = bits[2] == '1' ? true : false;
                    member.Character.Network.Guild.guildstorageRight = bits[0] == '1' ? true : false;
                    member.Character.Network.Guild.noticeeditRight = bits[1] == '1' ? true : false;
                }
                // set new amount to every guild members guild class
                foreach (int m in Character.Network.Guild.Members)
                {
                    //Set int index (Find member id)
                    int index = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == m);
                    //If the character is online
                    if (Character.Network.Guild.MembersInfo[index].Online)
                    {
                        //Get detailed information of the player
                        Systems sys = Systems.GetPlayerMainid(m);

                        //Set new guild player
                        Global.guild_player mygp = new Global.guild_player();
                        int myindex = 0;
                        //Repeat for each player
                        foreach (Global.guild_player gp in sys.Character.Network.Guild.MembersInfo)
                        {
                            //if the member id equals the player
                            if (gp.MemberID == memberid)
                            {
                                //Set my gp
                                mygp = gp;
                                //Set bits
                                mygp.joinRight = bits[4] == '1' ? true : false;
                                mygp.withdrawRight = bits[3] == '1' ? true : false;
                                mygp.unionRight = bits[2] == '1' ? true : false;
                                mygp.guildstorageRight = bits[0] == '1' ? true : false;
                                mygp.noticeeditRight = bits[1] == '1' ? true : false;
                                break;
                            }
                            //Index ++
                            myindex++;
                        }
                        //Set membersinfo index as mygp
                        sys.Character.Network.Guild.MembersInfo[myindex] = mygp;
                    }
                }
                //Update guild database information rights
                MsSQL.UpdateData("UPDATE guild_members SET guild_perm_join='" + bits[4] + "',guild_perm_withdraw='" + bits[3] + "',guild_perm_union='" + bits[2] + "',guild_perm_storage='" + bits[0] + "',guild_perm_notice='" + bits[1] + "' WHERE guild_member_id='" + memberid + "'");
                //Send to everyone in guild update of permissions
                Character.Network.Guild.Send(Packet.GuildUpdate(Character, 4, 0, permissions, 0));
            }
            //If an error happens
            catch (Exception ex)
            {
                //Write the information to the console
                Console.WriteLine("Guild permission error: {0}", ex);
                //Write information to the debug log
                Systems.Debugger.Write(ex);
            }
        }
예제 #13
0
        void Handle()
        {
            PacketReader Reader = new PacketReader(PacketInformation.buffer);
            byte iSlot = Reader.Byte();
            Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, iSlot, 0);

            if (uItemID.ID == 0 || Character.State.Die) return;
            switch (uItemID.ID)
            {

                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Stall decoration
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 3847:
                case 3848:
                case 3849:
                case 3850:
                case 35482:
                case 35483:
                case 35484:
                    StallDeco(uItemID.ID, iSlot);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;

                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Monster Masks
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 10364:
                    if (Character.Transformed) return;
                    //Load Mask
                    MonsterMasks(uItemID.ID, iSlot);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Forgotten world entrance
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 33235:
                    ForgottenWorld(uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Repair items
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 3784:
                case 24432:
                case 35249:
                    if (!Character.Action.repair)
                    {
                        Character.Action.repair = true;
                        RepairTimer(30000);
                    //Check if there are any items that need repair
                    double durability = Data.ItemBase[uItemID.ID].Defans.Durability;
                    double currentdurability = Data.ItemBase[uItemID.dbID].Defans.Durability;

                        if (currentdurability < durability)
                        {
                            int countrepairs = MsSQL.GetRowsCount("SELECT * FROM char_items WHERE owner='" + Character.Information.CharacterID + "'");
                            if (countrepairs == 0)
                            {
                                //Do nothing client sends message automaticly
                            }
                            else
                            {
                                //Start repairing call handle
                                HandleRepair(iSlot, uItemID.dbID);
                                HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                            }
                        }
                    }
                    break;

                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Thief Return Scrolls
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 2128:
                    if (Character.Information.Scroll) return;
                    HandleThiefScroll(uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Inventory Expansion
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 24456:
                    HandleInventoryExp(uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Monster Summon Scrolls
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 3935:
                case 3936:
                case 3937:
                case 10133:
                case 10145:
                case 30925:
                    HandleSummon(Character.Information.Level);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Reverse return scrolls
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 3795:
                case 24467:
                    if (Character.Information.Scroll) return;
                    HandleReverse(Reader.Int16(),Reader.Byte(), Reader.Int32());
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Premium Tickets
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 7490:
                case 24505:
                    HandlePremiumType(uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Normal Return Scrolls
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 61:
                case 2198:
                case 2199:
                case 3769:
                case 19599:
                case 24684:
                    if (Character.Information.Scroll) return;
                    if (Timer.Movement != null)
                    {
                        Timer.Movement.Dispose();
                        Character.Position.Walking = false;
                    }
                    HandleReturnScroll(uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // HP Potions
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 3817:
                case 3818:
                case 3819:
                case 5912:
                case 3765:
                    byte type = 1;
                    HandlePotion(type, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // MP Potions
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 11:
                case 12:
                case 13:
                case 14:
                case 15:
                case 3820:
                case 3821:
                case 3822:
                case 5913:
                    type = 2;
                    HandlePotion(type, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                case 9:
                    type = 3;
                    HandlePotion(type, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                case 16:
                    type = 4;
                    HandlePotion(type, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Vigor Potions
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 18:
                case 19:
                case 20:
                case 21:
                case 22:
                case 23:
                case 3739:
                case 4013:
                case 5881:
                case 5944:
                case 23316:
                    type = 5;
                    HandlePotion(type, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Special Transport
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 19601:
                case 22770:
                    if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll)
                    {
                        bool r = HandleSpecialTrans(uItemID.ID);
                        if (!r)
                            HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    }
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Normal transports
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 2137:
                case 2138:
                case 2139:
                case 3909:
                case 23330:
                case 22953:
                case 23396:
                case 23395:
                case 22952:
                    if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll)
                    {
                        if (this.Character.Information.Level >= Data.ItemBase[uItemID.ID].Level)
                        {
                            HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                            HandleHorseScroll(uItemID.ID);
                        }
                        else
                        {
                            //client.Send();// needs error

                        }
                    }
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Global Chatting
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 3851:
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    string text = " " + Reader.Text3();
                    Reader.Close();
                    SendAll(Packet.ChatPacket(6, 0, text, Character.Information.Name));
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Buff Items
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 7100:
                    SpecialBuff(3977);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                case 7098:
                    SpecialBuff(3975);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                case 23311:
                    if (Character.Information.Berserking) return;
                    int style = 1;
                    HandleRegenZerk(style, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                case 23938:
                    if (Character.Information.Berserking) return;
                    style = 2;
                    HandleRegenZerk(style, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Grab Pets
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 23313:
                case 35578:
                case 35583:
                    if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0)
                    {
                        bool r = HandleGrabPet(iSlot, uItemID.ID);
                        if (!r)
                            HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16());
                    }
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Attack Pets
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                /*
                case 22778:
                    if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0)
                    {
                        bool r = HandleAttackPet(iSlot, uItemID.ID);
                        if (!r)
                            HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16());
                    }
                    break;
                */
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Gender Switch Tools
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 24479:
                    //HandleGenderSwitch(iSlot, uItemID.ID);
                    //HandleUpdateSlotn(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Balloons
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                case 24342:
                    //HandleBalloon(iSlot, 31157);
                    SpecialBuff(31182);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // Default , Check item ID
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                default:
                    //Console.WriteLine("{0} Tried to use item {1} , The cast type: {2}", Character.Information.Name, Data.ItemBase[uItemID.ID].Name, uItemID.ID);
                    HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                    break;
            }
            Reader.Close();
        }
예제 #14
0
        void GuildPromote()
        {
            try
            {
                //Read client information int32 id
                PacketReader reader = new PacketReader(PacketInformation.buffer);
                int guildid = reader.Int32();
                reader.Close();

                //When a guild has reached its max level
                if (Character.Network.Guild.Level == 5)
                {
                    //Send packet to client and return (Message level up max).
                    client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
                    return;
                }
                //Definition for gold needed
                int GoldRequired;
                //Definition for guild points needed
                int GuildPointRequired;
                //Check if player is allready in process of upgrading
                if (!IsUpgrading)
                {
                    //Set bool to true, so we cant dupe
                    IsUpgrading = true;
                    //Load player guild information before we continue (Check last info).
                    LoadPlayerGuildInfo(false);
                    //Create switch on guildl evel
                    switch (Character.Network.Guild.Level)
                    {
                        case 1:
                            GoldRequired = 3000000;
                            GuildPointRequired = 5400;
                            break;
                        case 2:
                            GoldRequired = 9000000;
                            GuildPointRequired = 50400;
                            break;
                        case 3:
                            GoldRequired = 15000000;
                            GuildPointRequired = 135000;
                            break;
                        case 4:
                            GoldRequired = 21000000;
                            GuildPointRequired = 378000;
                            break;
                        default:
                            return;
                    }
                    //Set new guild level definition + 1
                    int NewLevel = Character.Network.Guild.Level + 1;
                    //Set new guild storage slot  amount
                    int NewStorageSlots = Character.Network.Guild.StorageSlots + 30;
                    //If character's gold is not enough
                    if (Character.Information.Gold < GoldRequired)
                    {
                        //Send message to client
                        client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GOLD_DEFICIT));
                        return;
                    }
                    //Not enough guildpoints
                    if (Character.Network.Guild.PointsTotal < GuildPointRequired)
                    {
                        //Send client message
                        client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_GP_DEFICIT));
                        return;
                    }
                    //Max level
                    if (Character.Network.Guild.Level == 5)
                    {
                        //Send client message
                        client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_ERROR_GUILD_LEVEL_UP_FULL));
                        return;
                    }
                    //If everything else is fine
                    else
                    //Upgrade guild initiate
                    {
                        //If max level return just incase.
                        if (Character.Network.Guild.Level == 5) return;
                        //Reduct guildpoints
                        Character.Network.Guild.PointsTotal -= GuildPointRequired;
                        //If the upgrade is final upgrade set points to 0
                        if (Character.Network.Guild.Level == 4) Character.Network.Guild.PointsTotal = 0;
                        //Reduct gold
                        Character.Information.Gold -= GoldRequired;
                        //Send update information to client
                        client.Send(Packet.InfoUpdate(1, Character.Network.Guild.PointsTotal, 0));
                        //Send success message to client
                        client.Send(Packet.PromoteOrDisband(2));
                        //Update guild in database
                        MsSQL.UpdateData("UPDATE guild SET guild_level='" + NewLevel + "',guild_points='" + Character.Network.Guild.PointsTotal + "',guild_storage_slots='" + NewStorageSlots + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
                        //Repeat for each member in our guild
                        foreach (int member in Character.Network.Guild.Members)
                        {
                            //Check if memeber is not null
                            if (member != 0)
                            {
                                //Get detailed member information
                                Systems memberinfo = GetPlayerMainid(member);
                                //Make sure the member is not null
                                if (memberinfo != null)
                                {
                                    //Reload information for the current guild member
                                    memberinfo.LoadPlayerGuildInfo(false);
                                    //Send guild update packet for current guild member
                                    memberinfo.client.Send(Packet.GuildUpdate(Character, 5, 0, 0, 0));
                                }
                            }
                        }
                        //Save player's gold
                        SaveGold();
                        //Send update gold packet to client
                        client.Send(Packet.UpdateGold(Character.Information.Gold));
                    }
                }
                //Disable the bool so we can upgrade again
                IsUpgrading = false;
            }
            //If any error accures
            catch (Exception ex)
            {
                //Write error to the console
                Console.WriteLine("Guild Promote Error: {0}", ex);
                //Write error to debug log
                Systems.Debugger.Write(ex);
            }
        }
예제 #15
0
파일: Friends.cs 프로젝트: CarlosX/DarkEmu
        /////////////////////////////////////////////////////////////////////////////////
        // Remove Friends
        /////////////////////////////////////////////////////////////////////////////////
        void FriendRemoval()
        {
            try
            {
                //Read client packet data
                PacketReader reader = new PacketReader(PacketInformation.buffer);
                int target = reader.Int32();
                reader.Close();
                //Get player information
                Systems sys = GetPlayerid(target);

                //Remove friend from our list query
                MsSQL.UpdateData("DELETE FROM friends WHERE owner='" + Character.Information.CharacterID + "' AND friend_name='" + target + "'");
                MsSQL.UpdateData("DELETE FROM friends WHERE owner='" + target + "' AND friend_name='" + Character.Information.CharacterID + "'");

                //Remove friend from our list packet
                client.Send(Packet.FriendData(target,3,"",Character,false));
                client.Send(Packet.FriendRemovalTarget(target));
                //Remove friend from friend id packet
                if (sys != null)
                {
                    sys.Send(Packet.FriendData(sys.Character.Information.UniqueID, 3, "", Character, false));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Friend removal error {0}",ex);
                Systems.Debugger.Write(ex);
            }
        }
예제 #16
0
파일: Object.cs 프로젝트: CarlosX/DarkEmu
        void SelectObject()
        {
            try
            {

                if (Character.Information.Scroll) return;
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                int objectid = Reader.Int32();
                if (objectid == 0) return;
                //if (Character.Position.Walking) StopPlayerMovementO(objectid);
                if (objectid == Character.Information.UniqueID && Character.State.Die)
                {
                    Player_Up();
                    return;
                }
                obj o = GetObject(objectid);
                if (o != null)
                {
                    byte[] bb = DarkEmu_GameServer.Packet.SelectObject(objectid, o.ID, o.LocalType, o.HP);
                    if (bb == null) return;
                    client.Send(bb);
                    return;
                }
                Systems sys = GetPlayers(objectid);
                if (o == null && sys != null)
                {
                    client.Send(DarkEmu_GameServer.Packet.SelectObject(objectid, 0, 5, sys.Character.Stat.Hp));
                    return;
                }
                Reader.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Selectobject error: {0}", ex);
            }
        }
예제 #17
0
        /////////////////////////////////////////////////////////////////////////////////
        // Item Switch
        /////////////////////////////////////////////////////////////////////////////////
        void ItemMain()
        {
            #region Item Actions
            try
            {
                if (Character.State.Die || Character.Information.Scroll) return;
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                byte iType = Reader.Byte();

                switch (iType)
                {
                    case 0:
                        if (Character.State.Busy) return;
                        ItemMove(Reader.Byte(), Reader.Byte(), Reader.Int16());
                        break;
                    case 1:
                        ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());
                        break;
                    case 2:
                        Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());
                        break;
                    case 3:
                        Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());
                        break;
                    case 4:
                        ItemMoveToExhangePage(Reader.Byte());
                        break;
                    case 5:
                        ItemMoveExchangeToInv(Reader.Byte());
                        break;
                    case 8:
                        Player_BuyItem(Reader.Byte(), Reader.Byte(), Reader.Int16(), Reader.Int32());
                        break;
                    case 9:
                        Player_SellItem(Reader.Byte(), Reader.Int16(), Reader.UInt16());
                        break;
                    case 7:
                        if (Character.State.Busy) return;
                        Player_DropItem(Reader.Byte());
                        break;
                    case 10:
                        if (Character.State.Busy) return;
                        Player_DropGold(Reader.UInt64());
                        break;
                    case 11:
                        Player_TakeGoldW(iType, Reader.Int64());
                        break;
                    case 12:
                        Player_GiveGoldW(iType, Reader.Int64());
                        break;
                    case 13:
                        ItemExchangeGold(Reader.Int64());
                        break;
                    case 16:
                        MovePetToPet(Reader.Int32(), Reader.Byte(), Reader.Byte(), Reader.Int16());
                        break;
                    case 24:
                        Player_BuyItemFromMall(Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Byte(), Reader.Text());
                        break;
                    case 26:
                        MoveItemFromPet(Reader.Int32(), Reader.Byte(), Reader.Byte());
                        break;
                    case 27:
                        MoveItemToPet(Reader.Int32(), Reader.Byte(), Reader.Byte());
                        break;
                    case 29:
                        ItemMoveInStorage(Reader.Byte(), Reader.Byte(), Reader.Int16());//Move inside guild storage
                        break;
                    case 30:
                        Player_MoveItemToStorage(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move to guild storage
                        break;
                    case 31:
                        Player_MoveStorageItemToInv(Reader.Byte(), Reader.Byte(), Reader.Int32());//Move from guild storage
                        break;
                    case 32:
                        Player_GiveGoldW(iType, Reader.Int64());//Guild storage
                        break;
                    case 33:
                        Player_TakeGoldW(iType, Reader.Int64());//Guild storage
                        break;
                    case 35:
                        ItemAvatarUnEquip(Reader.Byte(), Reader.Byte());
                        break;
                    case 36:
                        ItemAvatarEquip(Reader.Byte(), Reader.Byte());
                        break;
                    default:
                        Print.Format("Unknown Item Function:{0}:{1}", iType, Decode.StringToPack(PacketInformation.buffer));
                        break;
                }
                Reader.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Item Switch Error {0}", ex);
            }
            #endregion
        }
예제 #18
0
 protected void SavePlace()
 {
     //Wrap our function inside a catcher
     try
     {
         //Open our packet reader
         PacketReader reader = new PacketReader(PacketInformation.buffer);
         int ObjectID = reader.Int32();
         //Get object information
         obj o = GetObject(ObjectID);
         //Defaul value for type
         byte type = 0;
         //Switch by object name
         switch (Data.ObjectBase[o.ID].Name)
         {
             case "STORE_CH_GATE":
                 type = 1;
                 break;
             case "STORE_WC_GATE":
                 type = 2;
                 break;
             case "STORE_KT_GATE":
                 type = 5;
                 break;
             case "STORE_EU_GATE":
                 type = 20;
                 break;
             case "STORE_CA_GATE":
                 type = 25;
                 break;
             case "STORE_SD_GATE1":
                 type = 175;
                 break;
             case "STORE_SD_GATE2":
                 type = 176;
                 break;
             case "STORE_EU_TO_JUPITER_FIELD_GATE":
                 type = 207;
                 break;
             case "STORE_JUPITER_FIELD_TO_EU_GATE":
                 type = 208;
                 break;
             case "STORE_JUPITER_FIELD_TO_JUPITER_GATE":
                 type = 209;
                 break;
             case "STORE_JUPITER_A0_START_GATE":
                 type = 220;
                 break;
         }
         //Set new return global information
         Character.Information.Place = type;
         //Update database
         MsSQL.InsertData("update character set savearea='" + Character.Information.Place + "' where id='" + Character.Information.CharacterID + "'");
         //Send confirmation packet
         client.Send(Packet.UpdatePlace());
     }
     catch (Exception ex)
     {
         Console.WriteLine("Save return point error {0}", ex);
         Systems.Debugger.Write(ex);
     }
 }
예제 #19
0
 void GuildCreate()
 {
     try
     {
         //Extra check if user is allready in guild.
         if (Character.Network.Guild.Guildid != 0) return;
         //If player has recently been in a guild
         if (Character.Information.JoinGuildWait)
         {
             //Need to sniff the retail packet (Tmp used guild war error).
             client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDWARERR_GUILD_CREATE_PENALTY));
             return;
         }
         //Create new packet reader for reading information
         PacketReader Reader = new PacketReader(PacketInformation.buffer);
         //None needed integer
         int notneeded = Reader.Int32();
         //Get guild name lenght
         short GuildNameLen = Reader.Int16();
         //Get guild name
         string GuildName = Reader.String(GuildNameLen);
         //Close packet reader
         Reader.Close();
         //Remove bad characters from guildname
         GuildName = Removebadchars(GuildName);
         //Check length lower are 4 return
         if (GuildName.Length < 4)
         {
             //Send incorrect lenght
             client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_INVALID_GUILDNAME_LEN));
             return;
         }
         //Check if guild name is taken or not.
         int guildcheckname = MsSQL.GetRowsCount("SELECT * FROM guild WHERE guild_name='" + GuildName + "'");
         //If name excists
         if (guildcheckname == 1)
         {
             client.Send(Packet.IngameMessages(Systems.SERVER_GUILD_WAIT, IngameMessages.UIIT_MSG_GUILDERR_SAME_GUILDNAME_EXIST));
             return;
         }
         //If character level is to low
         if (Character.Information.Level < 20)
         {
             //Send packet level to low message
             client.Send(Packet.IngameMessages(Systems.SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_TOO_LOW_CREATOR_LEVEL));
             return;
         }
         //Set the gold requirements 500.000 retail info
         int goldrequired = 500000;
         //If gold is lower then price of creating a guild
         if (Character.Information.Gold < goldrequired)
         {
             //Send message not enough gold
             client.Send(Packet.IngameMessages(SERVER_GUILD, IngameMessages.UIIT_MSG_GUILDERR_NOT_ENOUGH_GOLD));
             return;
         }
         //All checks ok, continue creating new guild.
         else
         {
             //Reduct the gold required from player gold
             Character.Information.Gold -= goldrequired;
             //Save player information
             SavePlayerInfo();
             //Insert guild into database
             MsSQL.InsertData("INSERT INTO guild (guild_name, guild_level, guild_points, guild_news_t, guild_news_m, guild_members_t, guild_master_id) VALUES ('" + GuildName + "','1','0','" + "" + "','" + "" + "','1','" + Character.Information.CharacterID + "')");
             //Get guild id
             string guildid = MsSQL.GetData("SELECT id FROM guild WHERE guild_name='" + GuildName + "'", "id");
             int docount = Convert.ToInt32(guildid);
             //Insert member into database
             MsSQL.InsertData("INSERT INTO guild_members (guild_id, guild_member_id, guild_rank, guild_points, guild_fortress, guild_grant, guild_perm_join, guild_perm_withdraw, guild_perm_union, guild_perm_storage, guild_perm_notice) VALUES ('" + docount + "','" + Character.Information.CharacterID + "','0','0','1','','1','1','1','1','1')");
             //Load our new guild
             LoadPlayerGuildInfo(true);
             //Private packet
             client.Send(Packet.Guild_Create(Character.Network.Guild));
             //Public spawn packet
             Send(Packet.SendGuildInfo2(this.Character));
         }
     }
     catch (Exception ex)
     {
         Console.WriteLine("Guild creation error: " + ex);
         Systems.Debugger.Write(ex);
     }
 }
예제 #20
0
파일: Mastery.cs 프로젝트: CarlosX/DarkEmu
        public void Mastery_Up()
        {
            try
            {
                List<byte> Masteries = new List<byte>();
                MsSQL mastery = new MsSQL("SELECT * FROM mastery WHERE owner='"+Character.Information.CharacterID+"'");
                 using (SqlDataReader reader = mastery.Read())
                    {
                        while (reader.Read())
                        {
                            Masteries.Add(reader.GetByte(2));
                        }

                 }
                int totalmastery = 0;
                int masterylimit = 360;
                bool euchar = false;
                if (Character.Information.Model >= 10000 && Character.Information.Model <= 16000)
                {
                    masterylimit = 239;
                    euchar = true;
                }

                for(int i = 0;i < Masteries.Count;i++)
                {
                    totalmastery += Masteries[i];
                }
                if (totalmastery <= masterylimit)
                {
                    if (!Character.Action.upmasterytimer)
                    {
                        Character.Action.upmasterytimer = true;
                        MasteryupTimer(150);

                        PacketReader Reader = new PacketReader(PacketInformation.buffer);
                        int masteryid = Reader.Int32();
                        byte level = Reader.Byte();
                        byte m_index = MasteryGet(masteryid);

                        if (m_index == 0)
                        {
                            return;
                        }

                        if (!(Character.Information.SkillPoint < Data.MasteryBase[Character.Stat.Skill.Mastery_Level[m_index]]))
                        {
                            if (euchar == true)
                            {
                                if (Character.Stat.Skill.Mastery_Level[m_index] < Character.Information.Level)
                                {

                                    Character.Stat.Skill.Mastery_Level[m_index]++;
                                    Character.Information.SkillPoint -= Data.MasteryBase[Character.Stat.Skill.Mastery_Level[m_index]];

                                    client.Send(Packet.InfoUpdate(2, Character.Information.SkillPoint, 0));
                                    client.Send(Packet.MasteryUpPacket(masteryid, Character.Stat.Skill.Mastery_Level[m_index]));

                                    SaveMaster();

                                }
                            }
                            else
                            {
                                if (Character.Stat.Skill.Mastery_Level[m_index] < Character.Information.Level)
                                {
                                    if (!(Character.Stat.Skill.Mastery_Level[m_index] == 120))
                                    {
                                        Character.Stat.Skill.Mastery_Level[m_index]++;
                                        Character.Information.SkillPoint -= Data.MasteryBase[Character.Stat.Skill.Mastery_Level[m_index]];

                                        client.Send(Packet.InfoUpdate(2, Character.Information.SkillPoint, 0));
                                        client.Send(Packet.MasteryUpPacket(masteryid, Character.Stat.Skill.Mastery_Level[m_index]));

                                        SaveMaster();
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    //client.Send(Packet.IngameMessages(SERVER_ACTIONSTATE, IngameMessages.UIIT_STT_SKILL_LEARN_MASTERY_TOTAL_LIMIT));
                    return;
                }
            }

            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
예제 #21
0
파일: Mastery.cs 프로젝트: CarlosX/DarkEmu
        void Mastery_Skill_Up()
        {
            try
            {
                if (!Character.Action.upskilltimer)
                {
                    Character.Action.upskilltimer = true;
                    SkillUpTimer(250);

                    PacketReader Reader = new PacketReader(PacketInformation.buffer);
                    int skillid = Reader.Int32();
                    if (!(Character.Information.SkillPoint < Data.SkillBase[skillid].SkillPoint))
                    {
                        Character.Information.SkillPoint -= Data.SkillBase[skillid].SkillPoint;
                        client.Send(Packet.InfoUpdate(2, Character.Information.SkillPoint, 0));
                        client.Send(Packet.SkillUpdate(skillid));
                        client.Send(Packet.PlayerStat(Character));

                        SaveSkill(skillid);

                        MsSQL ms = new MsSQL("SELECT * FROM saved_skills WHERE owner='" + Character.Information.CharacterID + "'");
                        using (SqlDataReader reader = ms.Read())
                            Character.Stat.Skill.AmountSkill = ms.Count();
                        int i = 1;
                        using (SqlDataReader reader = ms.Read())
                        {
                            while (reader.Read())
                            {
                                Character.Stat.Skill.Skill[i] = reader.GetInt32(2);
                                i++;
                            }
                        }
                        ms.Close();

                        SkillGetOpened(skillid);

                    }
                }
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #22
0
 public static void PlayerQuickBar(PacketReader Reader, PacketWriter Writer)
 {
     byte amm = 0;
     int[] skillid = new int[51];
     byte[] slotn = new byte[51];
     for (byte i = 0; i <= 50; i++)
     {
         slotn[i] = Reader.Byte();
         if (slotn[i] != 0)
         {
             skillid[i] = Reader.Int32();
             amm++;
         }
         else Reader.Skip(4);
     }
     Writer.Byte(amm);
     for (byte i = 0; i <= 50; i++)
     {
         if (slotn[i] != 0)
         {
             Writer.Byte(i);
             Writer.Byte(slotn[i]);
             Writer.DWord(skillid[i]);
         }
     }
     Reader.Close();
 }
예제 #23
0
파일: Movement.cs 프로젝트: CarlosX/DarkEmu
        /////////////////////////////////////////////////////////////////////////////////
        // Pet movement
        /////////////////////////////////////////////////////////////////////////////////
        void MovementPet()
        {
            try
            {
                //Open our packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //This one happens to all pets.
                int petid = Reader.Int32();
                //We switch on type (2 = attack pet, 1 = horse).
                byte type = Reader.Byte();

                switch (type)
                {
                    //Horse pet movement
                    case 1:
                        byte movetype = Reader.Byte();

                        //Normal movement type
                        if (movetype == 1)
                        {
                            //Read xsector information
                            byte xsec = Reader.Byte();
                            //Read ysector information
                            byte ysec = Reader.Byte();
                            //Read x
                            float x = Reader.Int16();
                            //Read z
                            float z = Reader.Int16();
                            //Read y
                            float y = Reader.Int16();
                            Reader.Close();
                            //Make sure attack timer is gone
                            StopAttackTimer();
                            //Set pickup to false
                            Character.Action.PickUping = false;
                            //Set movement active
                            Character.Position.Walking = true;
                            //Calculate distance
                            double distance = Formule.gamedistance(Character.Position.x,
                                Character.Position.y,
                                Formule.gamex(x, xsec),
                                Formule.gamey(y, ysec));
                            //Set character position
                            Character.Position.xSec = xsec;
                            Character.Position.ySec = ysec;
                            Character.Position.wX = Formule.gamex(x, xsec) - Character.Position.x;
                            Character.Position.wZ = z;
                            Character.Position.wY = Formule.gamey(y, ysec) - Character.Position.y;

                            Character.Position.packetxSec = xsec;
                            Character.Position.packetySec = ysec;
                            Character.Position.packetX = (ushort)x;
                            Character.Position.packetZ = (ushort)z;
                            Character.Position.packetY = (ushort)y;

                            Send(Packet.Movement(new Global.vektor(petid, x, z, y, xsec, ysec)));
                            Character.Position.Time = (distance / (95.0 * 0.0768)) * 1000.0;
                            Character.Position.RecordedTime = Character.Position.Time;

                            StartMovementTimer((int)(Character.Position.Time * 0.1));
                        }
                        break;
                    //Attack pet movement
                    case 2:
                        //Set pet info
                        Character.Attackpet.Details.x = Character.Position.x;
                        Character.Attackpet.Details.y = Character.Position.y;
                        Character.Attackpet.Details.z = Character.Position.z;
                        Character.Attackpet.Details.xSec = Character.Position.xSec;
                        Character.Attackpet.Details.ySec = Character.Position.ySec;
                        //Target id information
                        int targetid = Reader.Int32();
                        Reader.Close();
                        //Set pet speed information
                        Send(Packet.SetSpeed(petid, 50, 100));//Need to make correct speed info later
                        //Check distances / target detailed.

                        //Send attack packet (new void pet attack to be created).
                        break;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("movement pet error {0}", ex);
                Systems.Debugger.Write(ex);
            }
        }
예제 #24
0
파일: Skills.cs 프로젝트: CarlosX/DarkEmu
        void MovementSkill(PacketReader Reader)
        {
            try
            {
                if (!Character.Action.movementskill)
                {
                    Character.Action.movementskill = true;
                    MovementSkillTimer(Data.SkillBase[Character.Action.UsingSkillID].Properties1["tele"] + 500);
                    if (Character.Action.sAttack || Character.Action.sCasting) return;

                    if (Character.Stat.SecondMP < Data.SkillBase[Character.Action.UsingSkillID].Mana) { client.Send(Packet.ActionPacket(2, 4)); return; }
                    else
                    {
                        Character.Stat.SecondMP -= Data.SkillBase[Character.Action.UsingSkillID].Mana;
                        UpdateMp();
                        if (Timer.Movement != null) { Timer.Movement.Dispose(); Character.Position.Walking = false; }

                        byte xSec = Reader.Byte(), ySec = Reader.Byte();
                        int x = Reader.Int32(), z = Reader.Int32(), y = Reader.Int32();
                        Reader.Close();

                        float gamex = DarkEmu_GameServer.Formule.gamex((float)x, xSec);
                        float gamey = DarkEmu_GameServer.Formule.gamey((float)y, ySec);

                        float farkx = gamex - Character.Position.x;
                        float farky = gamey - Character.Position.y;

                        float hesapy = 0, hesapx = 0;

                        while (hesapx + hesapy < Data.SkillBase[Character.Action.UsingSkillID].Properties2["tele"] / 10)
                        {
                            Character.Position.x += (farkx / 30);
                            Character.Position.y += (farky / 30);
                            hesapx += Math.Abs((farkx / 30));
                            hesapy += Math.Abs((farky / 30));
                        }

                        PacketWriter Writer = new PacketWriter();

                        Writer.Create(SERVER_ACTION_DATA);
                        Writer.Byte(1);
                        Writer.Byte(2);
                        Writer.Byte(0x30);
                        int overid = Character.Ids.GetCastingID();
                        Writer.DWord(Character.Action.UsingSkillID);//skillid
                        Writer.DWord(Character.Information.UniqueID); //charid
                        Writer.DWord(overid);//overid
                        Writer.DWord(0);
                        Writer.Byte(8);
                        Writer.Byte(xSec);
                        Writer.Byte(ySec);
                        Writer.DWord(Formule.packetx(Character.Position.x, xSec));
                        Writer.DWord(0);
                        Writer.DWord(Formule.packety(Character.Position.y, ySec));

                        Send(Writer.GetBytes());

                        client.Send(Packet.ActionState(2, 0));

                        ObjectSpawnCheck();
                    }
                }
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #25
0
 void DonateGP()
 {
     //First we write our function inside a catcher
     try
     {
         //Max level of guild wont allow new gp donations.
         if (Character.Network.Guild.Level == 5)
         {
             //Send error message to client
             client.Send(Packet.IngameMessages(SERVER_GUILD_PROMOTE_MSG, IngameMessages.UIIT_MSG_GUILD_LACK_GP));
             return;
         }
         //Open our packet reader
         PacketReader reader = new PacketReader(PacketInformation.buffer);
         //Read donated gp amount (int).
         int donatedgp = reader.Int32();
         //Close packet reader
         reader.Close();
         //Anti hack checking (If donated gp higher is then the player skillpoints.
         if (donatedgp > Character.Information.SkillPoint)
             return;
         //Calculate total
         int totalgp = Character.Network.Guild.PointsTotal + donatedgp;
         //Set guild points total
         Character.Network.Guild.PointsTotal += donatedgp;
         //Set skill points minus donated amount
         Character.Information.SkillPoint -= donatedgp;
         //Set donated gp + donated skill points
         Character.Network.Guild.DonateGP += donatedgp;
         //Save our information (Skill points).
         SavePlayerInfo();
         //Update database total guild points
         MsSQL.UpdateData("UPDATE guild SET guild_points='" + totalgp + "' WHERE guild_name='" + Character.Network.Guild.Name + "'");
         //Update database donated player guild points amount
         MsSQL.UpdateData("UPDATE guild_members SET guild_points='" + Character.Network.Guild.DonateGP + "' WHERE guild_member_id='"+ Character.Information.CharacterID +"'");
         //Send packets to donator.
         client.Send(Packet.InfoUpdate(1, totalgp, 0));
         //Send donated gp info
         PacketWriter writer = new PacketWriter();
         //Add opcode
         writer.Create(Systems.SERVER_GUILD_DONATE_GP);
         //Write static byte 1
         writer.Byte(1);
         //Write dword int value donated gp amount.
         writer.DWord(donatedgp);
         //Send bytes to client
         client.Send(writer.GetBytes());
         //Repeat for each member in our guild
         foreach (int member in Character.Network.Guild.Members)
         {
             //Make sure that the member isnt null
             if (member != 0)
             {
                 //Now we get the detailed information for each member
                 Systems guildmember = GetPlayerMainid(member);
                 //Make sure the guildmember is still there
                 if (guildmember != null)
                 {
                     //Send guild update packets to each member (Donated gp information and % bar update).
                     guildmember.client.Send(Packet.GuildUpdate(Character, 13, 0, 0, totalgp));
                     guildmember.client.Send(Packet.GuildUpdate(Character, 9, 0, 0, totalgp));
                 }
             }
         }
     }
     //Catch any bad exception error
     catch (Exception ex)
     {
         //Write information to the console
         Console.WriteLine("Donate GP Error {0}", ex);
         //Write information to the debug log.
         Systems.Debugger.Write(ex);
     }
 }
예제 #26
0
파일: Skills.cs 프로젝트: CarlosX/DarkEmu
        void SkillMain(byte type, PacketReader Reader)
        {
            try
            {
                if (!SkillGetOpened(Character.Action.UsingSkillID)) return;
                client.Send(Packet.ActionState(1, 1));
                //Console.WriteLine("Skill id: {0}", Data.SkillBase[Character.Action.UsingSkillID].Series); // Dev Mode
                switch (type)
                {
                    case 1:
                        if (Character.Action.sAttack) return;
                        if (Character.Action.sCasting) return;
                        if (Character.Action.nAttack) StopAttackTimer();

                        if (!Base.Skill.CheckWeapon(Character.Information.Item.wID, Character.Action.UsingSkillID))
                        {
                            client.Send(Packet.IngameMessages(SERVER_ACTION_DATA, IngameMessages.UIIT_SKILL_USE_FAIL_WRONGWEAPON));
                            client.Send(Packet.IngameMessages2(SERVER_ACTIONSTATE, IngameMessages.UIIT_SKILL_USE_FAIL_WRONGWEAPON));
                            return;
                        }

                        Character.Action.Target = Reader.Int32();
                        Character.Action.Skill.MainSkill = Character.Action.UsingSkillID;
                        Character.Action.UsingSkillID = 0;
                        Character.Action.Object = GetObjects(Character.Action.Target);

                        if (Data.SkillBase[Character.Action.Skill.MainSkill].isAttackSkill)
                        {
                            Character.Action.Skill = Base.Skill.Info(Character.Action.Skill.MainSkill, Character);
                            if (!Character.Action.Skill.canUse || Character.Action.Target == Character.Information.UniqueID) return;

                            obj o = null;
                            if (Character.Action.Object != null && Character.Action.Object.GetType().ToString() == "DarkEmu_GameServer.obj")
                            {
                                o = Character.Action.Object as obj;
                                if (o.Agro == null) o.Agro = new List<_agro>();
                                if (Character.Action.Skill.OzelEffect == 5 && o.State != 4) return;
                                if (o.State == 4 && Character.Action.Skill.OzelEffect != 5) return;
                            }

                            if (o == null && Character.Action.Object != null && Character.Action.Object.GetType().ToString() == "DarkEmu_GameServer.Systems")
                            {
                                if (!Character.Information.PvP || Character.State.Die) return;
                                Systems sys = Character.Action.Object as Systems;
                                if (Character.Action.Skill.OzelEffect == 5 && sys.Character.State.LastState != 5) return;
                                if (sys.Character.State.LastState == 4 && Character.Action.Skill.OzelEffect != 5) return;
                            }

                            Character.Action.sAttack = true;
                            ActionSkillAttack();

                            Reader.Close();
                        }
                        else
                        {
                            Character.Action.sAttack = true;
                            ActionSkill();
                        }
                        break;
                    case 0:
                        SkillBuff();
                        break;
                    case 2:
                        MovementSkill(Reader);
                        break;
                    default:
                        Console.WriteLine("Skillmain type: {0}", type);
                        break;
                }
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #27
0
        void ActionMain()
        {
            try
            {
                if (Character.State.Die || Character.Information.Scroll || Character.Action.Cast)
                    return;

                //Create new packet reader
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Read main action type
                byte type = Reader.Byte();
                //If attack action byte is not equal to 2
                if (type != 2)
                {
                    //Read player action byte
                    byte PlayerAction = Reader.Byte();
                    //Create switch on player actions
                    switch (PlayerAction)
                    {
                        //Normal attacking
                        case 1:
                            //If character is allready using normal attack
                            if (Character.Action.nAttack)
                            {
                                //Return
                                return;
                            }
                            //If the character is riding a horse
                            if (Character.Transport.Right)
                            {
                                //Return, because character cannot attack while riding a horse.
                                return;
                            }
                            //If the character is picking up a item
                            if (Character.Action.PickUping)
                            {
                                //Stop pick up timer
                                StopPickUpTimer();
                            }
                            //Skip non needed byte
                            Reader.Skip(1);
                            //Read integer target id (DWORD).
                            int TargetID = Reader.Int32();
                            //Close packet reader
                            Reader.Close();
                            //Set target id for usage later in attacking.
                            Character.Action.Object = GetObjects(TargetID);
                            //Set bool normal attack to true
                            Character.Action.nAttack = true;
                            //Set character target id
                            Character.Action.Target = TargetID;
                            //Start attacking
                            StartAttackTimer(1425);
                            break;
                        case 2://pickup
                            if (Character.Action.nAttack) return;
                            if (Character.Action.sAttack) return;
                            if (Character.Action.sCasting) return;
                            if (Character.Action.PickUping) return;

                            Reader.Byte();
                            int id2 = Reader.Int32();
                            Reader.Close();

                            Character.Action.Target = id2;
                            Character.Action.PickUping = true;
                            StartPickupTimer(600);
                            break;
                        case 3://trace
                            if (Character.Action.sAttack) return;
                            if (Character.Action.sCasting) return;
                            if (Character.State.Sitting) return;
                            if (Character.Stall.Stallactive) return;

                            Reader.Byte();
                            int id3 = Reader.Int32();
                            Character.Action.Target = id3;
                            Reader.Close();
                            client.Send(Packet.ActionState(1, 1));
                            Character.Action.PickUping = false;
                            Player_Trace(id3);
                            break;
                        case 4://use skill
                            Character.Action.UsingSkillID = Reader.Int32();
                            SkillMain(Reader.Byte(), Reader);
                            break;
                        case 5:
                            int id4 = Reader.Int32();
                            byte b_index = SkillGetBuffIndex(id4);
                            SkillBuffEnd(b_index);
                            break;
                        default:
                            Console.WriteLine("ActionMain case: " + Reader.Byte());
                            break;
                    }
                }

                else
                    StopAttackTimer();
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
예제 #28
0
파일: Friends.cs 프로젝트: CarlosX/DarkEmu
 /////////////////////////////////////////////////////////////////////////////////
 // Friend groups
 /////////////////////////////////////////////////////////////////////////////////
 void FriendGroup(string type)
 {
     try
     {
         //We use string type for switch statement.
         switch (type)
         {
             //Add new group
             case "ADD":
                 //First check if the user has friends
                 int friendcount = MsSQL.GetRowsCount("SELECT * FROM FRIENDS WHERE owner='" + Character.Information.CharacterID + "'");
                 //If the user has no friends return
                 if (friendcount == 0) return;
                 //Create our packet reader
                 PacketReader reader = new PacketReader(PacketInformation.buffer);
                 //Start reading information
                 string groupname = reader.Text();
                 //Close the reader
                 reader.Close();
                 //Update database information
                 MsSQL.InsertData("INSERT INTO friends_groups (playerid,groupname) VALUES ('" + Character.Information.CharacterID + "','" + groupname + "')");
                 //Get group id from count
                 short groupid = GetGroupId(Character.Information.CharacterID);
                 //Send packet to client
                 client.Send(Packet.FriendGroupManage("ADD", groupname, groupid, 0));
                 break;
             //Remove group
             case "REMOVE":
                 //Create our packet reader
                 reader = new PacketReader(PacketInformation.buffer);
                 //Start reading information
                 groupid = reader.Int16();
                 //Close the reader
                 reader.Close();
                 //Get group name
                 string groupnameinfo = GetGroupName(Character.Information.CharacterID, groupid);
                 //Update database information
                 MsSQL.InsertData("DELETE FROM friends_groups WHERE groupname='" + groupnameinfo + "'");
                 //Send packet to client
                 client.Send(Packet.FriendGroupManage("REMOVE", groupnameinfo, groupid, 0));
                 break;
             //Move to group
             case "MOVE":
                 //Create our packet reader
                 reader = new PacketReader(PacketInformation.buffer);
                 //Start reading information
                 int targetid = reader.Int32();
                 groupid = reader.Int16();
                 //Close the reader
                 reader.Close();
                 //Get groupname
                 groupnameinfo = GetGroupName(Character.Information.CharacterID, groupid);
                 //Update database information
                 MsSQL.UpdateData("UPDATE friends SET group_name='" + groupnameinfo + "' WHERE owner='" + Character.Information.CharacterID + "' AND friend_name='" + targetid + "'");
                 //Send packet to client
                 client.Send(Packet.FriendGroupManage("MOVE", groupnameinfo, groupid, targetid));
                 break;
         }
     }
     catch (Exception ex)
     {
         Systems.Debugger.Write(ex);
     }
 }
예제 #29
0
파일: Ranks.cs 프로젝트: CarlosX/DarkEmu
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Job Ranks
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void RankList()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                /////////////////////////////////////////////////////////////////////////////////////
                int Notneeded = Reader.Int32();
                byte Type = Reader.Byte();
                byte Choice = Reader.Byte();
                /////////////////////////////////////////////////////////////////////////////////////

                /////////////////////////////////////////////////////////////////////////////////////
                // Rank Trader
                /////////////////////////////////////////////////////////////////////////////////////
                if (Type == 1)
                {
                    /////////////////////////////////////////////////////////////////////////////////////
                    // Rank Trader Merchant Activity
                    /////////////////////////////////////////////////////////////////////////////////////
                    if (Choice == 0)
                    {
                        try
                        {
                            MsSQL readsql = new MsSQL("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='1'");
                            int begin = 0;
                            int count = readsql.Count();
                            using (SqlDataReader readinfo = readsql.Read())
                            {
                                while (readinfo.Read())
                                {
                                    for (begin = 0; begin < count; )
                                    {
                                        begin++;
                                        if (begin.Equals(count))
                                        {
                                            client.Send(Packet.RankListsActivityTrader());
                                            return;
                                        }
                                    }
                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Rank Trader Merchant Activity error: " + ex);
                        }
                    }
                    /////////////////////////////////////////////////////////////////////////////////////
                    // Rank Trader Weekly Donation
                    /////////////////////////////////////////////////////////////////////////////////////
                    else if (Choice == 1)
                    {
                        try
                        {
                            MsSQL readsql = new MsSQL("SELECT TOP 50 * FROM rank_job_donate WHERE job_type='1'");
                            int begin = 0;
                            int count = readsql.Count();
                            using (SqlDataReader readinfo = readsql.Read())
                            {
                                while (readinfo.Read())
                                {
                                    for (begin = 0; begin < count; )
                                    {
                                        begin++;
                                        if (begin.Equals(count))
                                        {
                                            client.Send(Packet.RankListsDonateTrader());
                                            return;
                                        }
                                    }
                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Rank Trader Weekly Donation: " + ex);
                        }
                    }
                }
                /////////////////////////////////////////////////////////////////////////////////////
                // Rank List Thief
                /////////////////////////////////////////////////////////////////////////////////////
                else if (Type == 3)
                {
                    /////////////////////////////////////////////////////////////////////////////////////
                    // Rank List Thief Activity
                    /////////////////////////////////////////////////////////////////////////////////////
                    if (Choice == 0)
                    {
                        try
                        {
                            MsSQL readsql = new MsSQL("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='3'");
                            int begin = 0;
                            int count = readsql.Count();
                            using (SqlDataReader readinfo = readsql.Read())
                            {
                                while (readinfo.Read())
                                {
                                    for (begin = 0; begin < count; )
                                    {
                                        begin++;
                                        if (begin.Equals(count))
                                        {
                                            client.Send(Packet.RankListsActivityThief());
                                            return;
                                        }
                                    }
                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Thief rank activity error: " + ex);
                        }
                    }
                    /////////////////////////////////////////////////////////////////////////////////////
                    // Rank List Thief Weekly Donation
                    /////////////////////////////////////////////////////////////////////////////////////
                    else if (Choice == 1)
                    {
                        try
                        {
                            MsSQL readsql = new MsSQL("SELECT TOP 50 * FROM rank_job_donate WHERE job_type='2'");
                            int begin = 0;
                            int count = readsql.Count();
                            using (SqlDataReader readinfo = readsql.Read())
                            {
                                while (readinfo.Read())
                                {
                                    for (begin = 0; begin < count; )
                                    {
                                        begin++;
                                        if (begin.Equals(count))
                                        {
                                            client.Send(Packet.RankListsDonateThief());
                                            return;
                                        }
                                    }
                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Rank List Thief Weekly Donation: " + ex);
                        }
                    }
                }
                /////////////////////////////////////////////////////////////////////////////////////
                // Rank List Hunter
                /////////////////////////////////////////////////////////////////////////////////////
                else if (Type == 2) //Type 2 = Hunter
                {
                    /////////////////////////////////////////////////////////////////////////////////////
                    // Rank List Hunter Activity
                    /////////////////////////////////////////////////////////////////////////////////////
                    if (Choice == 0)
                    {
                        try
                        {
                            MsSQL readsql = new MsSQL("SELECT TOP 50 * FROM rank_job_activity WHERE job_type='2'");
                            int begin = 0;
                            int count = readsql.Count();
                            using (SqlDataReader readinfo = readsql.Read())
                            {
                                while (readinfo.Read())
                                {
                                    for (begin = 0; begin < count; )
                                    {
                                        begin++;
                                        if (begin.Equals(count))
                                        {
                                            client.Send(Packet.RankListsActivityHunter());
                                            return;
                                        }
                                    }
                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Hunter rank activity error: " + ex);
                        }
                    }
                    /////////////////////////////////////////////////////////////////////////////////////
                    // Rank List Hunter Weekly Contribution
                    /////////////////////////////////////////////////////////////////////////////////////
                    else if (Choice == 1)
                    {
                        try
                        {
                            MsSQL readsql = new MsSQL("SELECT TOP 50 * FROM rank_job_donate WHERE job_type='3'");
                            int begin = 0;
                            int count = readsql.Count();
                            using (SqlDataReader readinfo = readsql.Read())
                            {
                                while (readinfo.Read())
                                {
                                    for (begin = 0; begin < count; )
                                    {
                                        begin++;
                                        if (begin.Equals(count))
                                        {
                                            client.Send(Packet.RankListsDonateHunter());
                                            return;
                                        }
                                    }
                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Hunter Weekly Contribution error: " + ex);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Job rank loading error : " + ex);
            }
        }
예제 #30
0
        //###########################################################################################
        // Start teleporting
        //###########################################################################################
        void Teleport_Start()
        {
            try
            {
                lock (this)
                {
                    //Checks before we continue
                    if (Character.Action.PickUping) return;
                    //Timer checks
                    StopTimers();
                    //Open the packet reader
                    PacketReader Reader = new PacketReader(PacketInformation.buffer);
                    //Teleport id
                    int teleportidinfo = Reader.Int32();
                    //Number
                    byte number = Reader.Byte();
                    //Teleport selected
                    int teleportselect = Reader.Int32();
                    Reader.Close();
                    //Find price information
                    int price = Data.TeleportPrice.Find(pc => (pc.ID == number)).price;
                    //If the user has less gold then it costs
                    if (this.Character.Information.Gold < price)
                    {
                        //Send error message
                        this.client.Send(Packet.IngameMessages(SERVER_TELEPORTSTART, IngameMessages.UIIT_MSG_INTERACTION_FAIL_NOT_ENOUGH_MONEY));
                        return;
                    }
                    //If the user level is lower then the required level
                    if (Data.TeleportPrice.Find(dd => (dd.ID == teleportselect)).level > 0 && Character.Information.Level < Data.TeleportPrice.Find(dd => (dd.ID == teleportselect)).level)
                    {
                        client.Send(Packet.IngameMessages(SERVER_TELEPORTSTART, IngameMessages.UIIT_MSG_INTERACTION_FAIL_OUT_OF_REQUIRED_LEVEL_FOR_TELEPORT));
                        return;
                    }
                    //If the user is currently with job transport (TODO).

                    //Update players gold
                    this.Character.Information.Gold -= price;
                    //Update players gold in database
                    SaveGold();
                    //Close buffs
                    BuffAllClose();
                    //Send teleport packet #1
                    this.client.Send(Packet.TeleportStart());
                    //Set state
                    this.Character.InGame = false;
                    //Update location
                    Teleport_UpdateXYZ(Convert.ToByte(teleportselect));
                    //Despawn objects
                    ObjectDeSpawnCheck();
                    //Despawn player to other players
                    DeSpawnMe();
                    //Required
                    client.Send(Packet.TeleportStart2());
                    //Send loading screen image
                    this.client.Send(Packet.TeleportImage(Data.PointBase[Convert.ToByte(teleportselect)].xSec, Data.PointBase[Convert.ToByte(teleportselect)].ySec));
                    //Set bool
                    this.Character.Teleport = true;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Teleport select error {0}", ex);
                Systems.Debugger.Write(ex);
            }
        }