# ---------=====----++---
  # Using an item on an item
  # ---------=====----++---
  def handle_use_item(msg, client)
    incoming_itemid = msg["message"]["itemid"].as_i64
    on_itemid = msg["message"]["on_itemid"].as_i64
    return unless zone = client.in_zone_obj
    tabid = msg["message"]["tabid"].as_i
    tabid_on = msg["message"]["tabid_on"].as_i

    if (item = client.get_item(incoming_itemid, tabid)) && (on_item = client.get_item(on_itemid, tabid_on))
      main_item = Items[item[1]]
      main_on_item = Items[on_item[1]]
      main_on_item_type = main_on_item["type"]

      raise "Oh lord." if incoming_itemid == on_itemid
      raise "Can't modify equipped items." if on_item[4] >= 1
      raise "This item has no quantity left, it should be deleted.." if item[3] <= 0
      raise "Can't modify an item with items in it" if on_item[15].size > 0 && !{"rune_extractor", "improve_quality", "rune_cleanser", "identify"}.includes? main_item["func"] # the rune extractor and rune_cleanser can!
      raise "Runes, Skills, or Misc items cannot be modified." if {"Skills", "Misc", "Runes"}.includes? main_on_item["type"]
      raise "Unidentified items cannot be modified, unless identifying them." if on_item[6] == 0 && !{"identify"}.includes? main_item["func"] # the scroll of wisdom can modify items
                                                                                 # 3 = q, 5 = sockets
      new_item_quantity = item[3] - 1
      # What mods does the item already have?
      current_item_mods = select_mods_from_item(on_item)

      case main_item["func"]
      # Removes all runes from an item
      when "rune_extractor"
        possible_runes = Array(Int64).new
        temp_hash = colon_comma_to_hash(on_item[15])
        temp_hash.each do |v|
          sock_pos = v[0]
          id_in_socket = v[1]
          if on_item[5][sock_pos]? && on_item[5][sock_pos] == '3'
            possible_runes << id_in_socket
            temp_hash.delete sock_pos
          end
        end

        raise "No runes found in this item." if possible_runes.size == 0

        new_sockets = on_item[5].gsub '3', '0'

        client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 15, colon_comma_to_s(temp_hash))
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 5, new_sockets)

        client.send ({a: 6, q: new_item_quantity, itemid: incoming_itemid}), "ITEMUPDATE"

        removed = create_runeword(client, on_item[5], on_item[15], main_on_item["type"], on_itemid, true) # true = remove runeword mods..
        if !removed
          client.send ({a: 8, on_itemid: on_itemid, new_item_data: client.stash[tabid_on].items[on_itemid]}), "ITEMUPDATE"
        end

        possible_runes.each do |rune_item_id|
          new_rune_item = generate_item_by_id(rune_item_id)
          new_x = (client.x + Random.new.rand(-50..50)).round
          new_y = (client.y + Random.new.rand(-50..50)).round
          zone.drop_item(new_rune_item, new_x, new_y)
        end

        # client.send ({a: 8, new_sockets: new_sockets, new_socket_data: colon_comma_to_s(temp_hash), on_itemid: on_itemid}), "SOCKETUPDATE"
        db.exec "update rpg_user_items set sockets = ?, socket_data = ? where itemid = ?  and user_id = ?", new_sockets, colon_comma_to_s(temp_hash), on_itemid, client.user_id

        # Upgrades a normal item to a magic rarity
      when "transmute_orb"
        raise "Item must be normal rarity." if current_item_mods.size > 0
        mod_rolls = Array(String).new
        query_update = QueryUpdate.new

        if main_on_item["type"] == "Weapons"
          mod_rolls = ModGlobalWeapons.dup
          mod_rolls = mod_rolls.shuffle.first(2)
        elsif main_on_item["type"] == "Capsules"
          new_extra_mods_value = roll_random_map_mods(2, on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else # assume boots/armors
          mod_rolls = ModGlobalArmors.dup
          if main_on_item["type"] == "Gloves"
            mod_rolls << "i_atk_speed"
          end
          mod_rolls = mod_rolls.shuffle.first(2)
        end
        mod_rolls.each do |mod_key|
          roll = rand
          mod_struct = GlobalItemModsMapping[mod_key].select { |v| roll < v.mod_chance }.last
          final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
          query_update[mod_struct.mod_type] = final_roll_value
          tuple_index = GlobalItemTuple.index(mod_struct.mod_type)
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
        end
        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          # Remove 1 quantity of the orb..
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        else
          raise "Item use failed.."
        end
      when "reforge_orb"
        # reforges a magic item with new modifiers
        raise "Can't be used on uniques." if main_on_item["rarity"] == "Unique"
        raise "This item is not magic rarity, it has more than 2 mods." if current_item_mods.size > 2
        raise "This item is not magic rarity, it has zero mods." if current_item_mods.size == 0

        query_update = QueryUpdate.new
        # What to do dependent on the item's type
        if main_on_item["type"] == "Weapons"
          mod_rolls = ModGlobalWeapons.dup
          mod_rolls = mod_rolls - [current_item_mods[0]] if current_item_mods.size == 1

          mod_rolls = mod_rolls.shuffle.first(2)
          mod_rolls = mod_rolls.shuffle.first(1) if current_item_mods.size == 1

          if current_item_mods.size > 1
            current_item_mods.each do |c_mod|
              query_update[c_mod] = 0
              client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], GlobalItemTuple.index(c_mod), 0)
            end
          end

          mod_rolls.each do |mod_key|
            roll = rand
            mod_struct = GlobalItemModsMapping[mod_key].select { |v| roll < v.mod_chance }.last
            final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
            query_update[mod_struct.mod_type] = final_roll_value
            tuple_index = GlobalItemTuple.index(mod_struct.mod_type)
            client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
          end
        elsif main_on_item["type"] == "Capsules"
          new_extra_mods_value = roll_random_map_mods(2, on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else # armors?

          if current_item_mods.size > 1
            current_item_mods.each do |c_mod|
              query_update[c_mod] = 0
              client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], GlobalItemTuple.index(c_mod), 0)
            end
          end

          mod_rolls = ModGlobalArmors.dup
          mod_rolls = mod_rolls - [current_item_mods[0]] if current_item_mods.size == 1

          if main_on_item["type"] == "Gloves"
            mod_rolls << "i_atk_speed"
          end
          mod_rolls = mod_rolls.shuffle.first(2)
          mod_rolls = mod_rolls.shuffle.first(1) if current_item_mods.size == 1

          mod_rolls.each do |mod_key|
            roll = rand
            mod_struct = GlobalItemModsMapping[mod_key].select { |v| roll < v.mod_chance }.last
            final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
            query_update[mod_struct.mod_type] = final_roll_value
            tuple_index = GlobalItemTuple.index(mod_struct.mod_type)
            client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
          end
        end
        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        end
      when "dissolving_orb"
        # Removes one modifier from an item.
        raise "Item must have at least one modifier." if current_item_mods.size <= 0
        query_update = QueryUpdate.new
        mod_type = current_item_mods.shuffle.first
        if main_on_item["type"] == "Capsules"
          new_extra_mods_value, mod_type = remove_random_map_mod(on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else
          query_update[mod_type] = 0
          tuple_index = GlobalItemTuple.index(mod_type)
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, 0)
        end

        if select_mods_from_item(client.stash[tabid_on].items[on_itemid]).size < 3
          # It's not a rare
          query_update["rare_name"] = ""
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 22, "")
        end

        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, remove_data: mod_type, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          # Remove 1 quantity of the orb..
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        else
          raise "Item use failed.."
        end
      when "lucky_orb"
        # Upgrades a normal item to a random rarity.
        raise "Item must be normal rarity." if current_item_mods.size > 0
        mod_rolls = Array(String).new
        query_update = QueryUpdate.new
        # What to do dependent on the item's type
        if main_on_item["type"] == "Weapons"
          # magic rarity
          mod_rolls = ModGlobalWeapons.dup
          if rand < 0.15
            # chance to roll 4 mods
            mod_rolls = mod_rolls.shuffle.first(rand(2..4))
          else
            mod_rolls = mod_rolls.shuffle.first(rand(2..3))
          end
        elsif main_on_item["type"] == "Capsules"
          new_extra_mods_value = roll_random_map_mods(rand(2..4), on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else
          if rand < 0.15
            # chance to roll 4 mods
            mod_rolls = ModGlobalArmors.shuffle.first(rand(2..4))
          else
            mod_rolls = ModGlobalArmors.shuffle.first(rand(2..3))
          end
        end
        mod_rolls.each do |mod_key|
          roll = rand
          mod_struct = GlobalItemModsMapping[mod_key].select { |v| roll < v.mod_chance }.last
          final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
          query_update[mod_struct.mod_type] = final_roll_value
          tuple_index = GlobalItemTuple.index(mod_struct.mod_type)
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
        end

        current_item_mods = select_mods_from_item(client.stash[tabid_on].items[on_itemid])
        if current_item_mods.size > 2
          # It's now a rare
          new_rare_name = generate_rare_name(main_on_item_type)
          query_update["rare_name"] = new_rare_name
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 22, new_rare_name)
        end

        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          # Remove 1 quantity from the orb..
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        else
          raise "Item use failed.."
        end
      when "sun_orb"
        # Upgrades a magic item to rare item.
        raise "Item must have 2 mods (magic)." if current_item_mods.size != 2
        clean_roll = ""

        prefix_key_rolls = Array(String).new
        suffix_key_rolls = Array(String).new
        query_update = QueryUpdate.new
        # What to do dependent on the item's type
        if main_on_item["type"] == "Weapons"
          temp_rolls = ModGlobalWeapons.shuffle
          clean_roll = (temp_rolls - current_item_mods).first # can't have multiple mods of the same type
        elsif main_on_item["type"] == "Capsules"
          new_extra_mods_value = add_random_map_mods(1, on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else
          temp_rolls = ModGlobalArmors.shuffle
          clean_roll = (temp_rolls - current_item_mods).first # can't have multiple mods of the same type
        end

        if main_on_item["type"] != "Capsules"
          raise "No potential mods to roll against. This might be a far bigger issue at hand.." if clean_roll.size == 0
          roll = rand
          mod_struct = GlobalItemModsMapping[clean_roll].select { |v| roll < v.mod_chance }.last
          final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
          query_update[mod_struct.mod_type] = final_roll_value
          tuple_index = GlobalItemTuple.index(mod_struct.mod_type)
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
        end

        # It's now a rare
        new_rare_name = generate_rare_name(main_on_item_type)
        query_update["rare_name"] = new_rare_name
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 22, new_rare_name)

        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          # Remove 1 quantity of the orb..
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        else
          raise "Item use failed.."
        end
      when "atom_orb"
        # Randomizes the values from modifiers on a rare item.
        raise "Item must have at least 3 mods (rare)." if current_item_mods.size < 3

        query_update = QueryUpdate.new

        if main_on_item["type"] == "Capsules"
          new_extra_mods_value = reroll_current_map_mods(on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else
          # What to do dependent on the item's type
          roll = rand
          current_item_mods.each do |mod|
            if (mapping_obj = GlobalItemModsMapping[mod]?) && (tuple_index = GlobalItemTuple.index(mod))
              mod_value = client.stash[tabid_on].items[on_itemid][tuple_index].to_i
              mapping_obj.each do |v|
                if mod_value >= v.min_value && mod_value <= v.max_value
                  mod_struct = v
                  final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
                  query_update[mod_struct.mod_type] = final_roll_value
                  client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
                  break
                end
              end
            end
          end
        end
        # It's being re-rolled, generate a new rare item name
        # new_rare_name = generate_rare_name(main_on_item_type)
        # query_update["rare_name"] = new_rare_name
        # client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 22, new_rare_name)

        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          # Remove 1 quantity of the orb..
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        else
          raise "Item use failed.."
        end
      when "galaxy_orb"
        # Upgrades a normal item to rare
        raise "Item must have no mods." if current_item_mods.size > 0
        raise "Item must be normal rarity." if main_on_item["rarity"] != "Normal"

        prefix_key_rolls = Array(ModStruct).new
        suffix_key_rolls = Array(ModStruct).new

        query_update = QueryUpdate.new
        roll = rand
        # What to do dependent on the item's type
        if main_on_item["type"] == "Weapons"
          prefix_key_rolls << ModPrefixWeapons_i_phys.select { |v| roll < v.mod_chance }.last
          suffix_key_rolls << ModSuffixWeapons_i_atk_speed.select { |v| roll < v.mod_chance }.last
          suffix_key_rolls << ModSuffixWeapons_i_crit_chance.select { |v| roll < v.mod_chance }.last
          suffix_key_rolls << ModSuffixWeapons_crit_multiplier.select { |v| roll < v.mod_chance }.last

          prefix_key_rolls.each do |c_obj|
            final_roll_value = rand(c_obj.min_value..c_obj.max_value)
            query_update[c_obj.mod_type] = final_roll_value
            tuple_index = GlobalItemTuple.index(c_obj.mod_type)
            client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
          end

          suffix_key_rolls.each do |c_obj|
            final_roll_value = rand(c_obj.min_value..c_obj.max_value)
            query_update[c_obj.mod_type] = final_roll_value
            tuple_index = GlobalItemTuple.index(c_obj.mod_type)
            client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
          end
        elsif main_on_item["type"] == "Capsules"
          new_extra_mods_value = roll_random_map_mods(3, on_item[24])
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else # armors?

          mod_rolls = ModGlobalArmors.shuffle.first(3) # galaxy orb = min of 3 mods = rare!
          pp mod_rolls

          mod_rolls.each do |mod_key|
            mod_struct = GlobalItemModsMapping[mod_key].select { |v| roll < v.mod_chance }.last
            final_roll_value = rand(mod_struct.min_value..mod_struct.max_value)
            query_update[mod_struct.mod_type] = final_roll_value
            tuple_index = GlobalItemTuple.index(mod_struct.mod_type)
            client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], tuple_index, final_roll_value)
          end
        end

        # It's a rare
        new_rare_name = generate_rare_name(main_on_item_type)
        query_update["rare_name"] = new_rare_name
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 22, new_rare_name)

        if query_update.size > 0
          db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
          client.send ({a: 4, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
          # Remove 1 quantity of the orb..
          client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        end
      when "furbish_orb"
        # Removes all modifications
        raise "This item must have modifications to be removed." if current_item_mods.size == 0

        query_update = QueryUpdate.new
        query_update["rare_name"] = ""
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 22, "")

        if main_on_item["type"] == "Capsules"
          new_extra_mods_value = ""
          query_update["extra_mods"] = new_extra_mods_value
          client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 24, new_extra_mods_value)
        else
          current_item_mods.each do |mod_type|
            client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], GlobalItemTuple.index(mod_type), 0)
            query_update[mod_type] = 0
          end
        end

        # Remove quantity from the orb
        client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        db.exec "update rpg_user_items set #{hash_to_delimited_query_list(query_update)} where itemid = ?  and user_id = ?", on_itemid, client.user_id
        client.send ({a: 5, new_data: query_update, q: new_item_quantity, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
        # Randomizing sockets
      when "randomize_sockets"
        num_of_sockets_to_roll = main_on_item["slot_size"].to_s[0].to_i8 * main_on_item["slot_size"].to_s[2].to_i8
        at_max_sockets = true
        on_item[5].each_char do |c|
          at_max_sockets = false if c == '0'
        end
        raise "Item is at the maximum amount of sockets. (g)" if at_max_sockets
        raise "Item is at the maximum amount of sockets. (6)" if on_item[5] == "111111" && num_of_sockets_to_roll == 6
        raise "Item is at the maximum amount of sockets. (4)." if on_item[5] == "1111" && num_of_sockets_to_roll == 4
        raise "Item is at the maximum amount of sockets and links. (6)" if on_item[5] == "222222" && num_of_sockets_to_roll == 6
        raise "Item is at the maximum amount of sockets and links. (4)." if on_item[5] == "2222" && num_of_sockets_to_roll == 4

        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(on_item, 5, randomize_sockets(num_of_sockets_to_roll, "1"))
        client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)

        client.send ({a: 1, sockets: client.stash[tabid_on].items[on_itemid][5], q: client.stash[tabid].items[incoming_itemid][3], on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
        db.exec "update rpg_user_items set sockets = ? where itemid = ?  and user_id = ?", client.stash[tabid_on].items[on_itemid][5], on_itemid, client.user_id

        # Randomize the links on an item
      when "randomize_links"
        raise "This item has no open sockets to roll against." if (!on_item[5].includes? '1') && (!on_item[5].includes? '2')
        num_of_sockets_to_roll = main_on_item["slot_size"].to_s[0].to_i8 * main_on_item["slot_size"].to_s[2].to_i8
        raise "Item is at the maximum amount of links. (6)" if on_item[5] == "222222" if num_of_sockets_to_roll == 6
        raise "Item is at the maximum amount of links. (4)." if on_item[5] == "2222" if num_of_sockets_to_roll == 4

        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(on_item, 5, randomize_links(on_item[5]))
        client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)

        client.send ({a: 1, sockets: client.stash[tabid_on].items[on_itemid][5], q: client.stash[tabid].items[incoming_itemid][3], on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
        db.exec "update rpg_user_items set sockets = ? where itemid = ?  and user_id = ?", client.stash[tabid_on].items[on_itemid][5], on_itemid, client.user_id
        # Identify an item
      when "identify"
        raise "This item is already identified." if on_item[6] == 1
        # raise "This item does not have any mods, it's pointless to identify." if current_item_mods.size == 0
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(on_item, 6, 1)
        client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)

        client.send ({a: 9, q: client.stash[tabid].items[incoming_itemid][3], on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
        db.exec "update rpg_user_items set identified = 1 where itemid = ?  and user_id = ?", on_itemid, client.user_id
      when "improve_quality"
        raise "This item is at max quality." if on_item[18] >= MAX_ITEM_QUALITY
        raise "You can only increase the quality of an equippable item." if main_on_item["type"] != "Capsules" && !is_equippable_type(main_on_item["type"])

        query_update = QueryUpdate.new
        new_quality = on_item[18] + 1

        client.stash[tabid].items[incoming_itemid] = modify_item_tuple(item, 3, new_item_quantity)
        client.stash[tabid_on].items[on_itemid] = modify_item_tuple(client.stash[tabid_on].items[on_itemid], 18, new_quality)

        db.exec "update rpg_user_items set quality = ? where itemid = ?  and user_id = ?", new_quality, on_itemid, client.user_id
        client.send ({a: 14, q: new_item_quantity, new_quality: new_quality, on_itemid: on_itemid, itemid: incoming_itemid}), "ITEMUPDATE"
      else
        raise "Invalid item, or its functionality is not coded yet."
      end

      # Last one, so it needs to be removed / deleted from the database
      if new_item_quantity == 0
        db.exec "delete from rpg_user_items   where itemid = ?  and user_id = ?", incoming_itemid, client.user_id
        client.stash[tabid].items.delete incoming_itemid
      else
        db.exec "update rpg_user_items set q=q-1 where itemid = ?  and user_id = ?", incoming_itemid, client.user_id
      end

      # puts item[4]
      # puts on_item[4]
    else
      raise "You do not own this item?"
    end
  rescue e
    client.send e.message, "E"
    # pp e.backtrace
  end