common-items.lic

# quiet
=begin
  Documentation: https://elanthipedia.play.net/Lich_script_development#common-items
=end

# This module should be 'bottom-level' and only depend on common.
# Any modules that deal with items and <something> should be somewhere else
custom_require.call(%w[common])

module DRCI
  module_function

  @@trash_storage = %w[basket bin gloop barrel bucket urn log arms stump tree statue chamberpot birdbath turtle]

  @@drop_trash_success_patterns = [
    /^You drop/,
    /^You put/,
    /^You spread .* on the ground/,
    /smashing it to bits/,
    # The next message is when item crumbles when leaves your hand, like a moonblade.
    /^As you open your hand to release the/
  ]

  @@drop_trash_failure_patterns = [
    /^What were you referring to/,
    /^I could not find/,
    /^But you aren't holding that/,
    /^You're kidding, right/,
    /^You can't do that/,
    /^No littering/,
    /^Where do you want to put that/,
    /^You really shouldn't be loitering/,
    /^You don't seem to be able to move/,
    # You may get the next message if you've been cursed and unable to let go of items.
    # Find a Cleric to uncurse you.
    /^Oddly, when you attempt to stash it away safely/,
    /^You need something in your right hand/,
    /^You can't put that there/
  ]

  # Messages that when trying to drop an item you're warned.
  # To continue you must retry the command.
  @@drop_trash_retry_patterns = [
    # You may get the next message if the item would be damaged upon dropping.
    /^If you still wish to drop it/,
    /would damage it/,
    # You may get the next messages when an outdated item is updated upon use.
    # "Something appears different about the <item>, perhaps try doing that again."
    # Example: https://elanthipedia.play.net/Item:Leather_lotion
    /^Something appears different about/,
    /perhaps try doing that again/
  ]

  @@worn_trashcan_verb_patterns = [
    /^You drum your fingers/,
    /^You pull a lever/,
    /^You poke your finger around/
  ]

  @@get_item_success_patterns = [
    /^You get/,
    /^You pick/,
    /^You pluck/,
    /^You slip/,
    /^You deftly remove/,
    /^You are already holding/,
    /^You fade in for a moment as you/
  ]

  @@get_item_failure_patterns = [
    /^You need a free hand/,
    /^You can't pick that up with your hand that damaged/,
    /^Your (left|right) hand is too injured/,
    /^You just can't/,
    /^You stop as you realize the .* is not yours/,
    /^You can't reach that from here/, # on a mount like a flying carpet
    /^You don't seem to be able to move/,
    /^Get what/,
    /^I could not/,
    /^What were you/,
    /already in your inventory/, # wearing it
    /needs to be tended to be removed/, # ammo lodged in you
    /push you over the item limit/, # you're at item capacity
    /rapidly decays away/, # item disappears when try to get it
    /cracks and rots away/ # item disappears when try to get it
  ]

  @@wear_item_success_patterns = [
    /^You put/,
    /^You pull/,
    /^You sling/,
    /^You attach/,
    /^You strap/,
    /^You slide/,
    /^You spin/,
    /^You slip/,
    /^You place/,
    /^You hang/,
    /^You tug/,
    /^You struggle/,
    /^You squeeze/,
    /^You manage/,
    /^You gently place/,
    /^You toss one strap/,
    /^You carefully loop/,
    /^You work your way into/,
    /^You are already wearing/,
    /^Gritting your teeth, you grip/,
    /slide effortlessly onto your/,
    /^You carefully arrange/
  ]

  @@wear_item_failure_patterns = [
    /^You can't wear/,
    /^You (need to|should) unload/,
    /close the fan/,
    /^You don't seem to be able to move/,
    /^Wear what/,
    /^I could not/,
    /^What were you/
  ]

  @@tie_item_success_patterns = [
    /^You .* tie/,
    /^You attach/
  ]

  @@tie_item_failure_patterns = [
    /^You don't seem to be able to move/,
    /^There's no more free ties/,
    /^You must be holding/,
    /^Tie what/
  ]

  @@untie_item_success_patterns = [
    /you untie/
  ]

  @@untie_item_failure_patterns = [
    /^You don't seem to be able to move/,
    /^You fumble with the ties/,
    /^Untie what/
  ]

  @@remove_item_success_patterns = [
    /^Dropping your shoulder/,
    /^The .* slide/,
    /^Without any effort/,
    /^You .* slide/,
    /^You detach/,
    /^You loosen/,
    /^You pull/,
    /^You.*remove/,
    /^You slide/,
    /^You sling/,
    /^You slip/,
    /^You struggle/,
    /^You take/,
    /you tug/i,
    /^You untie/,
    /as you remove/,
    /slide themselves off of your/,
    /you manage to loosen/,
    /you unlace/
  ]

  @@remove_item_failure_patterns = [
    /^You need a free hand/,
    /^You aren't wearing/,
    /^You don't seem to be able to move/,
    /^Remove what/,
    /^I could not/,
    /^What were you/
  ]

  @@put_away_item_success_patterns = [
    /^You put your .* in/,
    /^You hold out/,
    /^You tuck/,
    /^You open your pouch and put/,
    # The next message is when item crumbles when stowed, like a moonblade.
    /^As you open your hand to release the/,
    # You're a thief and you binned a stolen item.
    /nods toward you as your .* falls into the .* bin/,
    /^You add/,
    /^You rearrange/,
    /^You combine the stacks/,
    # The following are success messages for putting an item in a container OFF your person.
    /^You drop/i,
    /^You set/i,
    /^You put/i
  ]

  @@put_away_item_failure_patterns = [
    /^Stow what/,
    /^Please rephrase that command/,
    /^What were you referring to/,
    /^I could not find what you were referring to/,
    /^There isn't any more room in/,
    /^There's no room/,
    /^(The|That).* too heavy to go in there/,
    /^You (need to|should) unload/,
    /^You can't do that/,
    /^You just can't get/,
    /^You can't put items/,
    /^You can only take items out/,
    /^You don't seem to be able to move/,
    /^Perhaps you should be holding that first/,
    /^Containers can't be placed in/,
    /^The .* is not designed to carry anything/,
    /^You can't put that.*there/,
    /even after stuffing it/,
    /is too .* to (fit|hold)/,
    /no matter how you arrange it/,
    /close the fan/,
    /to fit in the/,
    # You may get the next message if you've been cursed and unable to let go of items.
    # Find a Cleric to uncurse you.
    /Oddly, when you attempt to stash it away safely/,
    /completely full/,
    /That doesn't belong in there!/,
    /exerts a steady force preventing/
  ]

  # Messages that when trying to put away an item you're warned.
  # To continue you must retry the command.
  @@put_away_item_retry_patterns = [
    # You may get the next messages when an outdated item is updated upon use.
    # "Something appears different about the <item>, perhaps try doing that again."
    # Example: https://elanthipedia.play.net/Item:Leather_lotion
    /Something appears different about/,
    /perhaps try doing that again/
  ]

  @@stow_item_success_patterns = [
    *@@get_item_success_patterns,
    *@@put_away_item_success_patterns
  ]

  @@stow_item_failure_patterns = [
    *@@get_item_failure_patterns,
    *@@put_away_item_failure_patterns,
  ]

  @@stow_item_retry_patterns = [
    *@@put_away_item_retry_patterns
  ]

  @@rummage_success_patterns = [
    /^You rummage through .* and see (.*)\./,
    /^In the .* you see (.*)\./,
    /there is nothing/i
  ]

  @@rummage_failure_patterns = [
    /^You don't seem to be able to move/,
    /^I could not find/,
    /^I don't know what you are referring to/,
    /^What were you referring to/
  ]

  @@tap_success_patterns = [
    /^You tap\s(?!into).*/, # The `.*` is needed to capture entire phrase. Methods parse it to know if an item is worn, stowed, etc.
    /^You (thump|drum) your finger/, # You tapped an item with fancy verbiage, ohh la la!
    /^The orb is delicate/, # You tapped a favor orb
    /^You .* on the shoulder/ # You tapped someone
  ]

  @@tap_failure_patterns = [
    /^You don't seem to be able to move/,
    /^I could not find/,
    /^I don't know what you are referring to/,
    /^What were you referring to/
  ]

  @@open_container_success_patterns = [
    /^You open/,
    /^You slowly open/,
    /^The .* opens/,
    /^You unbutton/,
    /is already open/,
    /^You spread your arms, carefully holding your bag well away from your body/
  ]

  @@open_container_failure_patterns = [
    /^Please rephrase that command/,
    /^What were you referring to/,
    /^I could not find what you were referring to/,
    /^You don't want to ruin your spell just for that do you/,
    /^It would be a shame to disturb the silence of this place for that/,
    /^This is probably not the time nor place for that/,
    /^You don't seem to be able to move/,
    /^There is no way to do that/,
    /^You can't do that/,
    /^Open what/
  ]

  @@close_container_success_patterns = [
    /^You close/,
    /^You quickly close/,
    /^You pull/,
    /is already closed/
  ]

  @@close_container_failure_patterns = [
    /^Please rephrase that command/,
    /^What were you referring to/,
    /^I could not find what you were referring to/,
    /^You don't want to ruin your spell just for that do you/,
    /^It would be a shame to disturb the silence of this place for that/,
    /^This is probably not the time nor place for that/,
    /^You don't seem to be able to move/,
    /^There is no way to do that/,
    /^You can't do that/
  ]

  @@container_is_closed_patterns = [
    /^But that's closed/,
    /^That is closed/,
    /^While it's closed/
  ]

  @@lower_success_patterns = [
    /^You lower/,
    # The next message is when item crumbles when leaves your hand, like a moonblade.
    /^As you open your hand to release the/
  ]

  @@lower_failure_patterns = [
    /^You don't seem to be able to move/,
    /^But you aren't holding anything/,
    /^Please rephrase that command/,
    /^What were you referring to/,
    /^I could not find what you were referring to/
  ]

  #########################################
  # TRASH ITEM
  #########################################

  def dispose_trash(item, worn_trashcan = nil, worn_trashcan_verb = nil)
    return if item.nil?

    if worn_trashcan
      case DRC.bput("put my #{item} in my #{worn_trashcan}", @@drop_trash_retry_patterns, @@drop_trash_success_patterns, @@drop_trash_failure_patterns)
      when *@@drop_trash_retry_patterns
        return true if dispose_trash(item, worn_trashcan, worn_trashcan_verb)
      when *@@drop_trash_success_patterns
        if worn_trashcan_verb
          DRC.bput("#{worn_trashcan_verb} my #{worn_trashcan}", *@@worn_trashcan_verb_patterns)
          DRC.bput("#{worn_trashcan_verb} my #{worn_trashcan}", *@@worn_trashcan_verb_patterns)
        end
        return true
      end
    end

    trashcans = DRRoom.room_objs
                      .reject { |obj| obj =~ /azure \w+ tree/ }
                      .map { |long_name| DRC.get_noun(long_name) }
                      .select { |obj| @@trash_storage.include?(obj) }

    trashcans.each do |trashcan|
      if trashcan == 'gloop'
        trashcan = 'bucket' if DRRoom.room_objs.include?('bucket of viscous gloop')
        trashcan = 'cauldron' if DRRoom.room_objs.include?('small bubbling cauldron of viscous gloop')
      elsif trashcan == 'bucket'
        trashcan = 'sturdy bucket' if DRRoom.room_objs.include?('sturdy bucket')
      elsif trashcan == 'basket'
        trashcan = 'waste basket' if DRRoom.room_objs.include?('waste basket')
      elsif trashcan == 'bin'
        trashcan = 'waste bin' if DRRoom.room_objs.include?('waste bin')
      elsif trashcan == 'arms'
        trashcan = 'statue'
      elsif trashcan == 'birdbath'
        trashcan = 'alabaster birdbath'
      elsif trashcan == 'turtle'
        trashcan = 'stone turtle'
      elsif trashcan == 'tree'
        trashcan = 'hollow' if DRRoom.room_objs.include?('dead tree with a darkened hollow near its base')
      elsif XMLData.room_title == '[[A Junk Yard]]'
        trashcan = 'bin'
      end

      case DRC.bput("put my #{item} in #{trashcan}", @@drop_trash_success_patterns, @@drop_trash_failure_patterns, @@drop_trash_retry_patterns)
      when *@@drop_trash_retry_patterns
        # If still didn't dispose of trash after retry
        # then don't return yet, will try to drop it later.
        return true if dispose_trash(item)
      when *@@drop_trash_success_patterns
        return true
      end
    end

    # No trash bins or not able to put item in a bin, just drop it.
    case DRC.bput("drop my #{item}", @@drop_trash_success_patterns, @@drop_trash_failure_patterns, @@drop_trash_retry_patterns)
    when *@@drop_trash_retry_patterns
      return dispose_trash(item)
    when *@@drop_trash_success_patterns
      return true
    else
      return false
    end
  end

  #########################################
  # SEARCH FOR ITEM
  #########################################

  def search?(item)
    /Your .* is in/ =~ DRC.bput("inv search #{item}", /^You can't seem to find anything/, /Your .* is in/)
  end

  # Taps items to check if you're wearing it.
  def wearing?(item)
    tap(item) =~ /wearing/
  end

  # Taps item to determine if it's in the given container.
  def inside?(item, container = nil)
    tap(item, container) =~ /inside/
  end

  # Taps an item to confirm it exists.
  def exists?(item, container = nil)
    case tap(item, container)
    when *@@tap_success_patterns
      true
    else
      false
    end
  end

  # Taps an item and returns the match string.
  # If no container specified then generically taps whatever's in your immediate inventory.
  def tap(item, container = nil)
    return nil unless item
    from = container
    from = "from #{container}" if container && !(container =~ /^(in|on|under|behind|from) /i)
    DRC.bput("tap my #{item} #{from}", *@@tap_success_patterns, *@@tap_failure_patterns)
  end

  def in_hands?(item)
    in_hand?(item, 'either')
  end

  def in_left_hand?(item)
    in_hand?(item, 'left')
  end

  def in_right_hand?(item)
    in_hand?(item, 'right')
  end

  # Checks if the item is in one or more hands.
  # Hand options are: left, right, either, both.
  def in_hand?(item, which_hand = 'either')
    return false unless item
    item = DRC::Item.from_text(item) if item.is_a?(String)
    case which_hand.downcase
    when 'left'
      DRC.left_hand =~ item.short_regex
    when 'right'
      DRC.right_hand =~ item.short_regex
    when 'either'
      in_left_hand?(item) || in_right_hand?(item)
    when 'both'
      in_left_hand?(item) && in_right_hand?(item)
    else
      DRC.message("Unknown hand: #{which_hand}. Valid options are: left, right, either, both")
      false
    end
  end

  def have_item_by_look?(item, container)
    return false unless item

    item = item.delete_prefix('my ')
    preposition = 'in my' if container && !(container =~ /^((in|on|under|behind|from) )?my /i)

    case DRC.bput("look at my #{item} #{preposition} #{container}", item, /^You see nothing unusual/, /^I could not find/, /^What were you referring to/)
    when /You see nothing unusual/, item
      true
    else
      false
    end
  end

  #########################################
  # COUNT ITEMS
  #########################################

  def count_item_parts(item)
    match_messages = [
      /and see there (?:is|are) (.+) left\./,
      /There (?:is|are) (?:only )?(.+) parts? left/,
      /There's (?:only )?(.+) parts? left/,
      /There are enough left to create (.+) more/
    ]
    count = 0
    $ORDINALS.each do |ordinal|
      case DRC.bput("count my #{ordinal} #{item}",
                    'I could not find what you were referring to.',
                    'tell you much of anything.',
                    *match_messages)
      when 'I could not find what you were referring to.'
        break
      when 'tell you much of anything.'
        echo "ERROR: count_item_parts called on non-stackable item: #{item}"
        count = count_items(item)
        break
      when *match_messages
        count += DRC.text2num(Regexp.last_match(1).tr('-', ' '))
      end
      waitrt?
    end
    count
  end

  # Counts items in a container that is inferred by first tapping the item.
  # If you want to count items in a specific container, use `count_items_in_container(item, container)`
  def count_items(item)
    /inside your (.*)/ =~ tap(item)
    container = Regexp.last_match(1)
    return 0 if container.nil?
    count_items_in_container(item, container)
  end

  # Counts items in a container.
  # If you don't know which container the items are in, use `count_items(item)` to infer it.
  def count_items_in_container(item, container)
    contents = DRC.bput("rummage /C #{item.split.last} in my #{container}", /^You rummage .*/, /That would accomplish nothing/)
    # This regexp avoids counting the quoted item name in the message, as
    # well as avoiding finding the item as a substring of other items.
    contents.scan(/ #{item}\W/).size
  end

  # Identifies how many more lockpicks that the container can hold.
  # Designed to work on lockpick stackers.
  # https://elanthipedia.play.net/Lockpick_rings
  def count_lockpick_container(container)
    count = DRC.bput("appraise my #{container} quick", /it appears to be full/, /it might hold an additional \d+/, /\d+ lockpicks would probably fit/).scan(/\d+/).first.to_i
    waitrt?
    count
  end

  def get_box_list_in_container(container)
    DRC.rummage('B', container)
  end

  def count_all_boxes(settings)
    current_box_count = 0

    containers = [
      settings.picking_box_source,
      settings.pick['picking_box_sources'],
      settings.pick['blacklist_container'],
      settings.pick['too_hard_container']
    ].flatten.uniq.reject { |container|
      container.to_s.empty?
    }.each { |container|
      current_box_count += get_box_list_in_container(container).size
    }

    current_box_count
  end

  #########################################
  # STOW ITEM
  #########################################

  def stow_hands
    (!DRC.left_hand  || stow_hand('left')) &&
    (!DRC.right_hand || stow_hand('right'))
  end

  def stow_hand(hand)
    braid_regex = /The braided (.+) is too long/
    case DRC.bput("stow #{hand}", braid_regex, @@container_is_closed_patterns, @@stow_item_success_patterns, @@stow_item_failure_patterns, @@stow_item_retry_patterns)
    when braid_regex
      dispose_trash(DRC.get_noun(Regexp.last_match(1)))
    when *@@stow_item_retry_patterns
      stow_hand(hand)
    when *@@stow_item_success_patterns
      true
    else
      false
    end
  end

  #########################################
  # GET ITEM
  #########################################

  # Gets an item unless you are already hold it.
  # Use this method to avoid having two of an item
  # in your hands when you only want one.
  #
  # Returns true if the item is in your hand
  # or we were able to get it to your hand.
  def get_item_if_not_held?(item, container = nil)
    return false unless item
    return true if in_hands?(item)
    return get_item(item, container)
  end

  # Provide a predicate-named method to follow convention.
  def get_item?(item, container = nil)
    get_item(item, container)
  end

  # Gets an item, optionally from a specific container.
  # If no container specified then generically grabs from the room/your person.
  # Can provide an array of containers to try, too, in case some might be empty.
  def get_item(item, container = nil)
    if container.is_a?(Array)
      container.each do |c|
        return true if get_item_safe(item, c)
      end
      return false
    end
    get_item_safe(item, container)
  end

  # Same as 'get_item_unsafe' but ensures that
  # the container argument is prefixed with 'my' qualifier.
  def get_item_safe?(item, container = nil)
    item = "my #{item}" if item && !(item =~ /^my /i)
    container = "my #{container}" if container && !(container =~ /^((in|on|under|behind|from) )?my /i)
    get_item_unsafe(item, container)
  end

  def get_item_safe(item, container = nil)
    get_item_safe?(item, container)
  end

  # Gets an item, optionally from a specific container.
  # If no container specified then generically grabs from the room/your person.
  def get_item_unsafe(item, container = nil)
    from = container
    from = "from #{container}" if container && !(container =~ /^(in|on|under|behind|from) /i)
    case DRC.bput("get #{item} #{from}", @@get_item_success_patterns, @@get_item_failure_patterns)
    when *@@get_item_success_patterns
      return true
    else
      if container =~ /\bportal\b/i
        return get_item_from_eddy_portal?(item, container)
      else
        return false
      end
    end
  end

  # Workaround to game changes where you must periodically look in
  # the portal for the contents to be available.
  # http://forums.play.net/forums/DragonRealms/Discussions%20with%20DragonRealms%20Staff%20and%20Players/Game%20Master%20and%20Official%20Announcements/view/1899
  def get_item_from_eddy_portal?(item, container)
    # Ensure the eddy is open then look in it to force the contents to be loaded.
    return false unless DRCI.open_container?('my eddy') && DRCI.look_in_container(container)
    from = container
    from = "from #{container}" if container && !(container =~ /^(in|on|under|behind|from) /i)
    case DRC.bput("get #{item} #{from}", @@get_item_success_patterns, @@get_item_failure_patterns)
    when *@@get_item_success_patterns
      return true
    else
      return false
    end
  end

  #########################################
  # TIE/UNTIE ITEM
  #########################################

  def tie_item?(item, container)
    case DRC.bput("tie my #{item} to my #{container}", @@tie_item_success_patterns, @@tie_item_failure_patterns)
    when *@@tie_item_success_patterns
      return true
    else
      return false
    end
  end

  def untie_item?(item, container)
    case DRC.bput("untie my #{item} from my #{container}", @@untie_item_success_patterns, @@untie_item_failure_patterns)
    when *@@untie_item_success_patterns
      return true
    else
      return false
    end
  end

  #########################################
  # WEAR ITEM
  #########################################

  # Wears an item from your hands.
  def wear_item?(item)
    wear_item_safe?(item)
  end

  # Same as 'wear_item_unsafe?' but ensures that
  # the item name is prefixed with 'my' qualifier.
  def wear_item_safe?(item)
    item = "my #{item}" if item && !(item =~ /^my /i)
    wear_item_unsafe?(item)
  end

  # Wears an item from your hands.
  def wear_item_unsafe?(item)
    case DRC.bput("wear #{item}", @@wear_item_success_patterns, @@wear_item_failure_patterns)
    when *@@wear_item_success_patterns
      return true
    else
      return false
    end
  end

  #########################################
  # REMOVE ITEM
  #########################################

  # Removes an item you're wearing.
  def remove_item?(item)
    remove_item_safe?(item)
  end

  # Same as 'remove_item_unsafe?' but ensures that
  # the item name is prefixed with 'my' qualifier.
  def remove_item_safe?(item)
    item = "my #{item}" if item && !(item =~ /^my /i)
    remove_item_unsafe?(item)
  end

  # Removes an item you're wearing.
  def remove_item_unsafe?(item)
    case DRC.bput("remove #{item}", @@remove_item_success_patterns, @@remove_item_failure_patterns)
    when *@@remove_item_success_patterns
      return true
    else
      return false
    end
  end

  #########################################
  # STOW ITEM
  #########################################

  # Stows an item into its default container. See STORE HELP for details.
  # Same as 'stow_item_safe?'.
  def stow_item?(item)
    stow_item_safe?(item)
  end

  # Stows an item into its default container. See STORE HELP for details.
  # Same as 'stow_item_unsafe?' but ensures that
  # the item argument is prefixed with 'my '.
  def stow_item_safe?(item)
    item = "my #{item}" if item && !(item =~ /^my /i)
    stow_item_unsafe?(item)
  end

  # Stows an item into its default container. See STORE HELP for details.
  # Unless you include the 'my ' prefix in the item then this may
  # try to stow an item on the ground rather than something in your inventory.
  def stow_item_unsafe?(item)
    case DRC.bput("stow #{item}", @@container_is_closed_patterns, @@stow_item_success_patterns, @@stow_item_failure_patterns, @@stow_item_retry_patterns)
    when *@@stow_item_retry_patterns
      return stow_item_unsafe?(item)
    when *@@stow_item_success_patterns
      return true
    else
      return false
    end
  end

  #########################################
  # LOWER ITEM
  #########################################

  # Lowers the item to the ground.
  # Determines which hand is holding the item then lowers it to your feet slot.
  def lower_item?(item)
    return false unless in_hands?(item)
    item_regex = /\b#{item}\b/
    hand = (DRC.left_hand =~ item_regex) ? 'left' : 'right'
    case DRC.bput("lower ground #{hand}", *@@lower_success_patterns, *@@lower_failure_patterns)
    when *@@lower_success_patterns
      true
    else
      false
    end
  end

  #########################################
  # CHECK CONTAINER CONTENTS
  #########################################

  # Checks if the container is empty.
  # Returns true if certain the container is empty.
  # Returns false if certain the container is not empty.
  # Returns nil if unable to determine either way (e.g. can't open container or look in it).
  def container_is_empty?(container)
    look_in_container(container).empty?
  end

  # Returns a list of item descriptions from the `INVENTORY <type|slot>` verb output.
  # Where <type> can be armor, weapon, fluff, container, or combat.
  # Where <slot> can be any phrase from INV SLOTS LIST command.
  def get_inventory_by_type(type = 'combat', line_count = 40)
    case DRC.bput("inventory #{type}", /Use INVENTORY HELP for more options/, /The INVENTORY command is the best way/, /You can't do that/)
    when /The INVENTORY command is the best way/, /You can't do that/
      DRC.message("Unrecognized inventory type: #{type}. Valid options are ARMOR, WEAPON, FLUFF, CONTAINER, COMBAT, or any slot from INVENTORY SLOTS LIST.")
      return []
    end
    # Multiple lines may have been printed to the game window,
    # grab the last several lines for analysis.
    snapshot = reget(line_count)
    # Unless you're looking for items at your feet, this is noise.
    items_at_feet = snapshot.grep(/(^Lying at your feet)/).any?
    # If the snapshot found all the inventory then begin processing.
    if snapshot.grep(/^All of your (#{type}|items)|^You aren't wearing anything like that|Both of your hands are empty/).any? && snapshot.grep(/Use INVENTORY HELP/).any?
      snapshot
      .map(&:strip)
      .reverse
      .take_while { |line| [/^All of your (#{type}|items)/, /^You aren't wearing anything like that/, /Both of your hands are empty/].none? { |phrase| phrase =~ line } }
      .drop_while { |line| !line.start_with?('[Use INVENTORY HELP for more options.]') }
      .drop(1)
      .reverse
      .take_while { |line| !items_at_feet || !line.start_with?('Lying at your feet') }
      .map { |item| item.gsub(/^(a|an|some)\s+/, '').gsub(/\s+\(closed\)/, '') }
    else
      # Otherwise, retry the command. Other actions may have flooded the game window.
      get_inventory_by_type(type, line_count + 40)
    end
  end

  # Gets a list of items found in a container via RUMMAGE or LOOK.
  # Default is 'rummage' which returns the full item tap descriptions (e.g. some grey ice skates with black laces)
  # You can pass in 'LOOK' to get back the short item names, which is easier to parse to know the adjective and noun (e.g. some grey ice skates)
  def get_item_list(container, verb = 'rummage')
    case verb
    when /^(r|rummage)$/i
      rummage_container(container)
    when /^(l|look)$/i
      look_in_container(container)
    end
  end

  # Gets a list of items by RUMMAGE the container.
  # Returns a list (empty or otherwise) if able to rummage the container.
  # Returns nil if unable to determine if container's contents (e.g. can't open it or rummage it).
  def rummage_container(container)
    container = "my #{container}" unless container.nil? || container =~ /^my /i
    contents = DRC.bput("rummage #{container}", @@container_is_closed_patterns, @@rummage_success_patterns, @@rummage_failure_patterns)
    case contents
    when *@@rummage_failure_patterns
      return nil
    when *@@container_is_closed_patterns
      return nil unless open_container?(container)
      rummage_container(container)
    else
      # Get string of just the comma separated item list
      contents = contents.match(/You rummage through .* and see (?:a|an|some) (?<items>.*)\./)[:items]

      # Split at a, an, or some, but only when it follows a comma
      # The last two items in the rummage list are never comma delimited, handle shortly
      contents = contents.split(/, (?:a|an|some) /)

      # Grab the last array element which is the final two items that are never comma
      # delimited in game output, split them into their item descriptions
      sub_contents = contents.pop.split(/ and (?:a|an|some) /)

      # Tack those last two items back onto our item list array
      contents = contents.concat(sub_contents)
    end
  end

  # Gets a list of items by LOOK in the container.
  # Returns a list (empty or otherwise) if able to look in the container.
  # Returns nil if unable to determine if container's contents (e.g. can't open it or look in it).
  def look_in_container(container)
    container = "my #{container}" unless container.nil? || container =~ /^my /i
    contents = DRC.bput("look in #{container}", @@container_is_closed_patterns, @@rummage_success_patterns, @@rummage_failure_patterns)
    case contents
    when *@@rummage_failure_patterns
      return nil
    when *@@container_is_closed_patterns
      return nil unless open_container?(container)
      look_in_container(container)
    else
      contents
        .match(/In the .* you see (?:some|an|a) (?<items>.*)\./)[:items]
        .split(/(?:,|and) (?:some|an|a)/)
        .map(&:strip)
    end
  end

  #########################################
  # PUT AWAY ITEM
  #########################################

  # Puts away an item, optionally into a specific container.
  # If no container specified then uses the default stow location.
  # Can provide an array of containers to try, too, in case some might be full.
  def put_away_item?(item, container = nil)
    if container.is_a?(Array)
      container.each do |c|
        return true if put_away_item_safe?(item, c)
      end
      return false
    end
    put_away_item_safe?(item, container)
  end

  # Same as 'put_away_item_unsafe?' but ensures that
  # the container argument is prefixed with 'my' qualifier.
  def put_away_item_safe?(item, container = nil)
    item = "my #{item}" if item && !(item =~ /^my /i)
    container = "my #{container}" unless container.nil? || container =~ /^my /i
    put_away_item_unsafe?(item, container)
  end

  # Puts away an item, optionally into a specific container, optionally
  # using a container preposition (e.g. "ON shelf")
  # If no container specified then uses the default stow location.
  # If no preposition specified, defaults to "in" (e.g. "IN cabinet")
  def put_away_item_unsafe?(item, container = nil, preposition = "in")
    command = "put #{item} #{preposition} #{container}" if container
    command = "stow #{item}" unless container
    result = DRC.bput(command, @@container_is_closed_patterns, @@put_away_item_success_patterns, @@put_away_item_failure_patterns, @@put_away_item_retry_patterns)
    case result
    when *@@container_is_closed_patterns
      return false unless container && open_container?(container)
      return put_away_item_unsafe?(item, container)
    when *@@put_away_item_retry_patterns
      return put_away_item_unsafe?(item, container)
    when *@@put_away_item_success_patterns
      return true
    when *@@put_away_item_failure_patterns
      return false
    else
      return false
    end
  end

  #########################################
  # OPEN/CLOSE CONTAINERS
  #########################################

  def open_container?(container)
    case DRC.bput("open #{container}", @@open_container_success_patterns, @@open_container_failure_patterns)
    when *@@open_container_success_patterns
      return true
    end
    return false
  end

  def close_container?(container)
    case DRC.bput("close #{container}", @@close_container_success_patterns, @@close_container_failure_patterns)
    when *@@close_container_success_patterns
      return true
    end
    return false
  end

  #########################################
  # GIVE/ACCEPT ITEM
  #########################################

  def give_item?(target, item)
    # An offer expires after 30 seconds.
    # The timeout is set to 35 to give some buffer for clock skew.
    case DRC.bput("give my #{item} to #{target}", { 'timeout' => 35 }, "has accepted your offer", "has declined the offer", "Your offer to .* has expired", "You may only have one outstanding offer at a time", "What is it you're trying to give", "There's nothing in your right hand to give away")
    when "has accepted your offer"
      true
    else
      false
    end
  end

  # If you accept then returns the name of the person whose offer you accepted. This serves as a "truthy" value, too.
  # If you don't, or aren't able to, accept then returns false.
  def accept_item?
    case DRC.bput("accept", "You accept .* offer and are now holding", "You have no offers", "Both of your hands are full", "would push you over your item limit")
    when /You accept (?<name>\w+)'s offer and are now holding/
      Regexp.last_match[:name]
    else
      false
    end
  end

end