Text3() public method

public Text3 ( ) : string
return string
Example #1
0
 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);
     }
 }
Example #2
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();
        }
Example #3
0
        void Chat()
        {
            /*
             *  We use for each now, to make sure there wont be any issues
             *  Incase the list we send the packet to can have none connected clients.
             *  To prevent bugging of chat we repeat and check each client before sending.
             */
            try
            {
                //Set our list of ranged players
                List<int> Rangedplayers = Character.Spawn;
                //Create new packet reader for reading packet data
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //Chat type byte (for our switch case).
                byte chatType = Reader.Byte();
                //Byte chat index
                byte chatIndex = Reader.Byte();
                //Link count byte
                byte linkCount = Reader.Byte();
                //Create switch to switch on type of chat (normal party etc).
                switch (chatType)
                {
                    //--------------------------------- [Normal chat] ---------------------------------//
                    case 1:
                        //Read written text from packet data
                        string Text = Reader.Text3();
                        //Close packet reader
                        Reader.Close();

                        // .additem 111 12
                        if (Character.Information.GM == 1 && Text[0] == '.')
                        {
                            gmCommands(Text);
                        }

                        //Repeat for each in range player
                        foreach (int member in Rangedplayers)
                        {
                            //Make sure the member is not null
                            if (member != 0)
                            {
                                //Make sure its not sending to our client
                                if (member != Character.Information.UniqueID)
                                {
                                    //Get member detail
                                    Systems memberinfo = GetPlayer(member);
                                    //Send packet to the in range player
                                    memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, null));
                                }
                            }
                        }
                        //Send chatindex packet to ourselfs
                        client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
                        break;
                    //--------------------------------- [Normal chat pink] ---------------------------------//
                    case 3:
                        //Check if our character has gm rights or not
                        if (Character.Information.GM == 1)
                        {
                            //Read packet information (text typed).
                            Text = Reader.Text3();
                            //Close packet reader
                            Reader.Close();
                            //Repeat for each player in our range list
                            foreach (int member in Rangedplayers)
                            {
                                //Check if the member is not null
                                if (member != 0)
                                {
                                    //Make sure its not sending to our own client
                                    if (member != Character.Information.UniqueID)
                                    {
                                        //Get member detail
                                        Systems memberinfo = GetPlayer(member);
                                        //Send packet to the member
                                        memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, null));
                                    }
                                }
                            }
                            //Send chat index to our client
                            client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
                            break;
                        }
                        //If character tried to use pink chat but isnt a gm
                        else
                        {
                            //We ban the player for hacking attempt.
                            Disconnect("ban");
                        }
                        break;
                    //--------------------------------- [Private chat] ---------------------------------//
                    case 2:
                        //Read from packet data who we are sending the message to
                        string Target = Reader.Text();
                        //Get information from the given player we send to
                        Systems Targetplayer = GetPlayerName(Target);
                        //Make sure the player sending to is not null
                        if (Targetplayer != null)
                        {
                            //Make sure the player is ingame (Not teleporting or such).
                            if (Targetplayer.Character.InGame)
                            {
                                //Read the message from the packet data
                                Text = Reader.Text3();
                                //Close the packet reader
                                Reader.Close();
                                //Send packet to our target
                                Targetplayer.client.Send(Packet.ChatPacket(chatType, 0, Text, this.Character.Information.Name));
                                //Send chatindex packet to ourselfs
                                client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
                            }
                        }
                        break;
                    //--------------------------------- [Party chat] ---------------------------------//
                    case 4:
                        //Make sure the player is in a party
                        if (Character.Network.Party != null)
                        {
                            //Read the text the player has typed from packet data
                            Text = Reader.Text3();
                            //Close packet reader
                            Reader.Close();
                            //Repeat for each member in the party member list
                            foreach (int member in Character.Network.Party.Members)
                            {
                                //Make sure the member isnt null (0)
                                if (member != 0)
                                {
                                    //Get detailed info for the player
                                    Systems memberinfo = GetPlayer(member);
                                    //Send packet information to the member for chat
                                    memberinfo.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, this.Character.Information.Name));
                                }
                            }
                            //Finally send chatindex packet to ourselfs
                            client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
                        }

                        break;
                    //--------------------------------- [Guild chat] ---------------------------------//
                    case 5:
                        //Read message beeing send from packet data
                        Text = Reader.Text3();
                        //Close packet reader
                        Reader.Close();
                        //Repeat for each member in the guild member list
                        foreach (int member in Character.Network.Guild.Members)
                        {
                            //Make sure the member is not null (0)
                            if (member != 0)
                            {
                                //Get guild member detailed information
                                Systems Guildmember = GetPlayerMainid(member);
                                //Again check if the guild member is not null
                                if (Guildmember != null)
                                {
                                    //Send chat packet to the member
                                    Guildmember.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, this.Character.Information.Name));
                                }
                            }
                        }
                        //Send chat index packet to our client
                        client.Send(Packet.ChatIndexPacket(chatType, chatIndex));

                        break;
                    //--------------------------------- [Global chat] ---------------------------------//
                    case 6:
                        //Get sender name from packet data
                        string Sender = Reader.Text();
                        //Get message from packet data
                        Text = Reader.Text3();
                        //Send to every client connected and logged in
                        SendAll(Packet.ChatPacket(chatType, Character.Information.UniqueID, " " + Text, Sender));
                        break;
                    //--------------------------------- [Notice chat] ---------------------------------//
                    case 7:
                        //Make sure the character sending is a gm
                        if (Character.Information.GM == 1)
                        {
                            //Get message from packet data
                            Text = Reader.Text3();
                            //Close packet reader
                            Reader.Close();
                            //Send to everyone ingame (using void sendnoticecon).
                            SendAll(sendnoticecon(chatType, Character.Information.UniqueID, Text, null));
                        }
                        //If the character is not a gm
                        else
                        {
                            //Disconnect and ban the player for hack attempt
                            Disconnect("ban");
                        }
                        break;
                    //--------------------------------- [Stall chat] ---------------------------------//
                    case 9:
                        //Read message from packet data
                        Text = Reader.Text3();
                        //Close packet reader
                        Reader.Close();
                        //Repeat for each member in the stall
                        foreach (int stallmember in Character.Network.Stall.Members)
                        {
                            //Make sure the stall member isnt null 0
                            if (stallmember != 0)
                            {
                                //Get stall member details
                                Systems member = GetPlayer(stallmember);
                                //Make sure the member isnt null
                                if (member != null)
                                {
                                    //Send chat packet to the member
                                    member.client.Send(Packet.ChatPacket(chatType, Character.Network.Stall.ownerID, Text, this.Character.Information.Name));
                                }
                            }
                        }
                        //Send chat index to ourselfs
                        client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
                        break;
                    //--------------------------------- [Academy chat] ---------------------------------//
                    case 10:
                        //Todo academy system then chat.
                        break;
                    //--------------------------------- [Union chat] ---------------------------------//
                    case 11:
                        //Read message from packet data
                        Text = Reader.Text3();
                        //Close packet reader
                        Reader.Close();
                        //If the character has no union
                        if (!Character.Network.Guild.UnionActive)
                            //Return
                            return;
                        //Else for each member in the union
                        foreach (int member in Character.Network.Guild.UnionMembers)
                        {
                            //Make sure the union member is not null 0
                            if (member != 0)
                            {
                                //Get member detailed information
                                Systems tomember = GetPlayerMainid(member);
                                //Make sure the member is not null
                                if (tomember != null)
                                {
                                    //Make sure the member isnt ourself
                                    if(tomember.Character.Information.CharacterID != Character.Information.CharacterID)
                                    {
                                        //Send packet to the union member
                                        tomember.client.Send(Packet.ChatPacket(chatType, Character.Information.UniqueID, Text, Character.Information.Name));
                                    }
                                }
                            }
                        }
                        //Repeat for each member in the guild
                        foreach (int member in Character.Network.Guild.Members)
                        {
                            //Make sure the member isnt null 0
                            if (member != 0)
                            {
                                //Get member detailed information
                                Systems tomember = GetPlayerMainid(member);
                                //Make sure the member isnt null
                                if (tomember != null)
                                {
                                    //Make sure the member isnt ourself
                                    if (tomember.Character.Information.CharacterID != Character.Information.CharacterID)
                                    {
                                        //Send packet to the member
                                        tomember.Character.Network.Guild.SingleSend = false;
                                    }
                                }
                            }
                        }
                        //Finally send chat index packet to ourself
                        client.Send(Packet.ChatIndexPacket(chatType, chatIndex));
                        break;
                }
            }
            //If an exception error happens
            catch (Exception errorinformation)
            {
                //Write the information to the console
                Console.WriteLine("Chat error {0}", errorinformation);
                //Write the information to the log system
                Systems.Debugger.Write(errorinformation);
            }
        }
Example #4
0
        void CreateFormedParty()
        {
            try
            {
                //Get packet data
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                //First and second dword are static
                Reader.Int32();
                Reader.Int32();
                //First byte is our party type
                byte PartyType = Reader.Byte();
                //Second byte is purpose information
                byte PartyPurpose = Reader.Byte();
                //3rd byte is minimal level required to join
                byte PartyMinLevelReq = Reader.Byte();
                //4th byte is max level to join
                byte PartyMaxLevelReq = Reader.Byte();
                //5th is short, party name lenght
                //6th is party name
                string PartyName = Reader.Text3();
                //Close our reader
                Reader.Close();

                //Make sure the user isnt in a party yet.
                if (Character.Network.Party != null)
                {
                    //If party is formed allready return
                    if (Character.Network.Party.IsFormed)
                    {
                        return;
                    }
                    //If party is not formed
                    else
                    {
                        //Get current party information
                        party CurrentParty = Character.Network.Party;
                        //Set formed state
                        CurrentParty.IsFormed = true;
                        //Party type
                        CurrentParty.Type = PartyType;
                        //Party purpose
                        CurrentParty.ptpurpose = PartyPurpose;
                        //Party minimal level
                        CurrentParty.minlevel = PartyMinLevelReq;
                        //Party maximum level
                        CurrentParty.maxlevel = PartyMaxLevelReq;
                        //Party name
                        CurrentParty.partyname = PartyName;
                        //Party owner
                        CurrentParty.LeaderID = Character.Information.UniqueID;
                        //Add party eu / ch information by model
                        CurrentParty.Race = Character.Information.Model;
                        //Send packet information to user
                        client.Send(Packet.CreateFormedParty(CurrentParty));
                        //Add party to list
                        Party.Add(CurrentParty);
                    }
                }
                //If a new formed party is created from 0
                else
                {
                    //New party for details
                    party newparty = new party();
                    //Set formed state
                    newparty.IsFormed = true;
                    //Party type
                    newparty.Type = PartyType;
                    //Party purpose
                    newparty.ptpurpose = PartyPurpose;
                    //Party minimal level
                    newparty.minlevel = PartyMinLevelReq;
                    //Party maximum level
                    newparty.maxlevel = PartyMaxLevelReq;
                    //Party name
                    newparty.partyname = PartyName;
                    //Party owner
                    newparty.LeaderID = Character.Information.UniqueID;
                    //Add party eu / ch information by model
                    newparty.Race = Character.Information.Model;
                    //Add our player to the member list
                    newparty.Members.Add(Character.Information.UniqueID);
                    //Add player client to party list information
                    newparty.MembersClient.Add(client);
                    //Party id , is current count of party's + 1
                    newparty.ptid = Party.Count + 1;
                    //Add the new party list
                    Party.Add(newparty);
                    //Set party to player
                    Character.Network.Party = newparty;
                    //bool set player in party
                    Character.Network.Party.InParty = true;
                    //Send packet information to user
                    client.Send(Packet.CreateFormedParty(newparty));
                }

            }
            //Catch bad exception errors
            catch (Exception ex)
            {
                //Write information to the console
                Console.WriteLine("Create formed party error {0}", ex);
                //Write info to the debug log
                Systems.Debugger.Write(ex);
            }
        }
Example #5
0
        void Handle()
        {
            try
            {
                //Read packet information
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                byte iSlot = Reader.Byte();
                //Get global item information
                Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, iSlot, 0);
                //Checks before continuing
                if (uItemID.ID != 0 || !Character.State.Die)
                {
                    //###########################################################################################
                    // Grabpets
                    //###########################################################################################
                    #region Pets (PET OBJECTS)

                    // Grabpets
                    #region Grabpets
                    if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.GRABPET)
                    {
                        //Check if we have pet active allready.
                        if (!Character.Grabpet.Active && Character.Action.MonsterID.Count == 0)
                        {
                            //If not active , add new pet object.
                            HandleGrabPet(iSlot, uItemID.ID);
                            //Need to change this to active effect on slot.
                            HandleUpdateSlotn(iSlot, uItemID, Reader.Int32());
                        }
                    }
                    #endregion
                    // Attackpets
                    #region Attackpets
                    else if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.ATTACKPET)
                    {
                        //Check if we have pet active allready.
                        if (!Character.Attackpet.Active && Character.Action.MonsterID.Count == 0 || !Character.Attackpet.Active && Character.Action.MonsterID == null)
                        {
                            //If not active , add new pet object.
                            if (!Character.Attackpet.Active)
                            {
                                HandleUpdateSlotn(iSlot, uItemID, Reader.Int32());
                                HandleAttackPet(iSlot, uItemID.ID);
                                client.Send(Packet.Update2(iSlot));
                                client.Send(Packet.ChangeStatus(Character.Information.UniqueID, 5, 0));
                            }
                        }
                    }
                    #endregion
                    #endregion
                    // Horses (NOTE: Detail error messages per if statement (if level, summoned etc).
                    #region Horses
                    if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.TRANSPORT)
                    {
                        //Checks before we continue
                        if (!Character.Stall.Stallactive && !Character.Transport.Right && Character.Action.MonsterID.Count == 0 && !Character.State.Sitting && !Character.Information.Scroll)
                        {
                            //Check if level is high enough
                            if (this.Character.Information.Level >= Data.ItemBase[uItemID.ID].Level)
                            {
                                HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                                HandleHorseScroll(uItemID.ID);
                            }
                            //Else
                            else
                            {
                                client.Send(Packet.IngameMessages(SERVER_PLAYER_UPTOHORSE, IngameMessages.UIIT_MSG_COSPETERR_CANT_PETSUM_HIGHLEVEL));
                            }
                        }
                    }
                    #endregion
                    // Special transport
                    #region Special transport
                    else if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.ATTACKPET)
                    {

                    }
                    #endregion
                    // Job Transport
                    #region Job Transport
                    else if (Data.ItemBase[uItemID.ID].Pettype == Global.item_database.PetType.JOBTRANSPORT)
                    {
                        //HandleJobTransport(uItemID.ID);
                    }
                    #endregion
                    //###########################################################################################
                    // Potions
                    //###########################################################################################
                    #region Potions
                    #region HP potion
                    if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.HP_POTION && Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.HPSTATPOTION)
                    {
                        HandlePotion(1, uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    else if (Data.ItemBase[uItemID.ID].Name.Contains("_HP_") && Data.ItemBase[uItemID.ID].Name.Contains("_SUPERSET_"))
                    {
                        HandlePotion(1, uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    #region HP STAT Potions
                    else if (Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.HP_POTION && Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.HPSTATPOTION)
                    {

                    }
                    #endregion
                    #region MP potions
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.MP_POTION && Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.MPSTATPOTION)
                    {
                        HandlePotion(2, uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    else if (Data.ItemBase[uItemID.ID].Name.Contains("_MP_") && Data.ItemBase[uItemID.ID].Name.Contains("_SUPERSET_"))
                    {
                        HandlePotion(1, uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    #region HP STAT Potions
                    else if (Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.HP_POTION && Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.MPSTATPOTION)
                    {

                    }
                    #endregion
                    #region Vigor potions
                    /*
                        else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.VIGOR_POTION)
                        {
                            HandlePotion(5, uItemID.ID);
                            HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                        }
                    */
                    else if (Data.ItemBase[uItemID.ID].Name.Contains("ITEM_ETC_ALL_"))
                    {
                        HandlePotion(5, uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    #region Speed potions
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.SPEED_POTION)
                    {
                        if (Character.Speed.DefaultSpeed == Character.Speed.RunSpeed ||
                            Character.Speed.DefaultSpeed + Character.Speed.Updateded[20] != Character.Speed.RunSpeed && Character.Information.Berserking)
                        {
                            this.SpecialBuff(Data.ItemBase[uItemID.ID].SkillID);
                            HandleUpdateSlot(iSlot, uItemID, Reader.UInt16());
                        }
                    }
                    #endregion
                    #region Berserk Potion
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.BERSERKPOTION)
                    {
                        if (Character.Information.BerserkBar < 5)
                        {
                            if (Character.Information.Berserking == false)
                            {
                                this.Character.Information.BerserkBar = 5;
                                client.Send(Packet.InfoUpdate(4, 0, Character.Information.BerserkBar));
                                HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                            }
                        }
                    }
                    #endregion
                    #endregion
                    //###########################################################################################
                    // Tickets
                    //###########################################################################################
                    #region Tickets
                    //Forgotten world
                    #region Forgotten world
                    else if (Data.ItemBase[uItemID.ID].Ticket == Global.item_database.Tickets.DUNGEON_FORGOTTEN_WORLD)
                    {
                        //Must add check if user location currently is forgotten world.
                        //Must add level check of portal.
                        ForgottenWorld(uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    #endregion
                    //###########################################################################################
                    // Global chat
                    //###########################################################################################
                    #region Global Chat
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GLOBALCHAT)
                    {
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                        byte something = Reader.Byte();
                        string text = Reader.Text3();
                        Reader.Close();
                        SendAll(Packet.ChatPacket(6, 0, text, Character.Information.Name));
                    }
                    #endregion
                    //###########################################################################################
                    // Stall decoration
                    //###########################################################################################
                    #region Stall decoration
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.STALLDECORATION)
                    {
                        StallDeco(uItemID.ID, iSlot);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    //###########################################################################################
                    // Monster masks
                    //###########################################################################################
                    #region Monster masks
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.MONSTERMASK)
                    {
                        //If character monster mask isnt enabled allready.
                        if (!Character.Transformed)
                        {
                            if (Character.Information.Level >= Data.ItemBase[uItemID.ID].Level)
                            {
                                //Load Mask
                                MonsterMasks(uItemID.ID, iSlot);
                                HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                            }
                            else
                            {
                                //Send msg level to low
                            }
                        }
                        else
                        {
                            //Send msg allready in use
                        }
                    }
                    #endregion
                    //###########################################################################################
                    // Return scrolls
                    //###########################################################################################
                    #region Return scrolls
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.RETURNSCROLL && Data.ItemBase[uItemID.ID].Etctype != Global.item_database.EtcType.REVERSESCROLL)
                    {
                        if (Character.Information.Scroll) return;
                        if (Timer.Movement != null)
                        {
                            Timer.Movement.Dispose();
                            Character.Position.Walking = false;
                        }
                        HandleReturnScroll(uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());

                    }
                    #endregion
                    //###########################################################################################
                    // Reverse scrolls
                    //###########################################################################################
                    #region Reverse scrolls
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.REVERSESCROLL)
                    {
                        if (Character.Information.Scroll) return;
                        if (Character.Position.Walking) return;
                        //Read item id
                        int itemid = Reader.Int32();
                        //Our switch byte
                        byte type = Reader.Byte();
                        //locations for reverse
                        int locid = 0;
                        if (type == 7) locid = Reader.Int32();
                        //Start our handle
                        HandleReverse(itemid, type, locid);
                        //Update slot
                        HandleUpdateSlot(iSlot, uItemID, itemid);
                    }
                    #endregion
                    //###########################################################################################
                    // Thief scrolls
                    //###########################################################################################
                    #region Thief scrolls
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.BANDITSCROLL)
                    {
                        if (Character.Information.Scroll) return;
                        HandleThiefScroll(uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    //###########################################################################################
                    // Summon scrolls
                    //###########################################################################################
                    #region Summon scrolls
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.SUMMONSCROLL)
                    {
                        HandleSummon(Character.Information.Level);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    //###########################################################################################
                    // Skin change scrolls
                    //###########################################################################################
                    #region Skin change scrolls
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.CHANGESKIN)
                    {
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                        int skinmodel = Reader.Int32();
                        HandleSkinScroll(skinmodel, uItemID.ID);
                    }
                    #endregion
                    //###########################################################################################
                    // Item change tool
                    //###########################################################################################
                    #region Skin change scrolls
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.ITEMCHANGETOOL)
                    {
                        int itemid = Reader.Int32();
                        byte targetslot = Reader.Byte();
                        //Make sure the item target is not equiped.
                        if (targetslot < 13) return;
                        //Continue
                        HandleUpdateSlot(iSlot, uItemID, itemid);
                        HandleItemChange(uItemID.ID, iSlot, targetslot);
                    }
                    #endregion
                    //###########################################################################################
                    // Dungeon items
                    //###########################################################################################
                    #region Forgotten world
                    else if (Data.ItemBase[uItemID.ID].Ticket == Global.item_database.Tickets.DUNGEON_FORGOTTEN_WORLD)
                    {
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                        ForgottenWorld(uItemID.ID);
                    }
                    #endregion
                    //###########################################################################################
                    // Inventory expansion
                    //###########################################################################################
                    #region Inventory expansion
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.INVENTORYEXPANSION)
                    {
                        HandleInventoryExp(uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    //###########################################################################################
                    // Warehouse expansion
                    //###########################################################################################
                    #region Warehouse expansion
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.WAREHOUSE)
                    {
                        HandleWareHouse(uItemID.ID);
                        HandleUpdateSlot(iSlot, uItemID, Reader.Int32());
                    }
                    #endregion
                    //###########################################################################################
                    // Guild related
                    //###########################################################################################
                    #region Guild Icon
                    else if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GUILD_ICON)
                    {
                        HandleRegisterIcon();
                    }
                    #endregion
                    //###########################################################################################
                    // Non coded types
                    //###########################################################################################
                    else
                    {
                        //Need to make message in progress or such
                        Console.WriteLine("Non Coded Item ID: " + Data.ItemBase[uItemID.ID].ID + " Name: " + Data.ItemBase[uItemID.ID].Name + "");
                    }
                }
                // Close our packet reader
                Reader.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Item usage error {0}", ex);
                Systems.Debugger.Write(ex);
            }
        }
Example #6
0
        public void StallOpen()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);

                if (Character.Stall.Stallactive || Character.State.Sitting || Character.Transport.Spawned || Character.Information.Scroll) return;

                Character.Network.Stall = new stall();

                Character.Network.Stall.ItemList = new List<stall.stallItem>();
                Character.Network.Stall.StallName = Reader.Text3();
                Character.Network.Stall.Members.Add(Character.Information.UniqueID);
                Character.Network.Stall.MembersClient.Add(this.client);
                Character.Network.Stall.ownerID = Character.Information.UniqueID;
                Character.Network.Stall.isOpened = false;

                client.Send(Packet.StallOpen(Character.Network.Stall.StallName, Character.Information.UniqueID, Character.Information.StallModel));
                client.Send(Packet.StallOpened());
                Send(Packet.StallOpenGlobal(Character.Network.Stall.StallName, Character.Information.UniqueID, Character.Information.StallModel));
                Character.Stall.Stallactive = true;
            }
            catch (Exception ex)
            {
                Systems.Debugger.Write(ex);
            }
        }
Example #7
0
        public void StallMain()
        {
            try
            {
                PacketReader Reader = new PacketReader(PacketInformation.buffer);
                byte Type = Reader.Byte();

                //Item edit
                if (Type == 1)
                {
                    if (Character.Network.Stall.isOpened) return;
                    byte stallslot = Reader.Byte();
                    Reader.Skip(2);
                    ulong price = Reader.UInt64();
                    if (price <= 999999999)
                    {
                        int StallItemIndex = Character.Network.Stall.ItemList.FindIndex(i => (i.stallSlot == stallslot));
                        Character.Network.Stall.ItemList[StallItemIndex].price = price;

                        Character.Network.Stall.Send(Packet.StallModifyItem(stallslot, price));
                    }
                    else
                        return;
                }
                //Add an item
                else if (Type == 2)
                {
                    if (Character.Network.Stall.isOpened) return;
                    byte stallslot = Reader.Byte();
                    byte invpos = Reader.Byte();
                    short quantity = Reader.Int16();
                    ulong price = Reader.UInt64();

                    Global.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, invpos, 0);

                    //Disable item mall items in stalls for now.
                    if (Data.ItemBase[uItemID.ID].Etctype == Global.item_database.EtcType.GLOBALCHAT ||
                        Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATAR ||
                        Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATARHAT ||
                        Data.ItemBase[uItemID.ID].Type == Global.item_database.ArmorType.AVATARATTACH
                        ) return;

                    if (quantity <= Data.ItemBase[uItemID.ID].Max_Stack)
                    {
                        stall.stallItem StallItem = new stall.stallItem();
                        LoadBluesid(uItemID.dbID);
                        StallItem.stallSlot = stallslot;
                        StallItem.price = price;
                        StallItem.Item = (GetItem((uint)Character.Information.CharacterID, invpos, 0));

                        if (Character.Network.Stall.ItemList.Exists((get => get.Item.dbID == StallItem.Item.dbID))) return;

                        Character.Network.Stall.ItemList.Add(StallItem);
                        Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList));
                    }
                    else
                        return;
                }
                //Item pulling out
                else if (Type == 3)
                {
                        if (Character.Network.Stall.isOpened) return;
                        byte stallslot = Reader.Byte();

                        //remove stallItem from stall
                        Character.Network.Stall.ItemList.Remove(Character.Network.Stall.ItemList.Find(i => (i.stallSlot == stallslot)));
                        Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList));
                }
                //Stall modify state
                else if (Type == 5)
                {
                    byte State = Reader.Byte();
                    Character.Network.Stall.isOpened = (State == 1) ? true : false;

                    Character.Network.Stall.Send(Packet.StallSetState(State));
                }
                //Set Welcome msg
                else if (Type == 6)
                {
                    if (Character.Network.Stall.isOpened) return;
                    short length = Reader.Int16();
                    Character.Network.Stall.WelcomeMsg = Reader.Text3();
                    //Console.WriteLine("New Welcome msg:" + welcome);
                    Character.Network.Stall.Send(Packet.StallWelcome(Character.Network.Stall.WelcomeMsg));
                }
                //Set StallName
                else if (Type == 7)
                {
                    string stallname = Reader.Text3();
                    Send(Packet.StallNameGlobal(Character.Information.UniqueID, stallname));
                    Character.Network.Stall.Send(Packet.StallName(stallname));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Additem Stall error: {0}", ex);
            }
        }