burgle.lic

=begin

Very simple Breaking and Entering script.  Use at your own risk - there are VERY high fines if you get caught

Documentation: https://elanthipedia.play.net/Lich_script_repository#burgle

=end

custom_require.call(%w[common common-travel common-items equipmanager])

class Burgle
  include DRC
  include DRCT
  include DRCI

  def initialize

    arg_definitions = [
      [
        { name: 'start', regex: /start/,optional: false, description: 'Required: prevents accidentally running burgle and protects against burgle typo for starting script' },
        { name: 'entry', options: %w[lockpick rope cycle prioritylockpick priorityrope], optional: true, description: 'Override yaml setting for entry_type.' },
        { name: 'roomid', regex: /\d+/, optional: true, description: 'Override yaml setting and go to room id (#) specified.  The room should be chosen VERY carefully.'},
        { name: 'loot_type', options: %w[drop keep pawn bin], optional: true, description: 'Override yaml setting for loot. (items on item_whitelist are always kept.)' },
        { name: 'hometown', options: $HOMETOWN_LIST, optional: true, description: 'Override yaml hometown settings for bin and pawn.  If no bin or pawnshop in that hometown, loot_type will revert to drop.'},
        { name: 'follow', options: %w[follow], optional: true, description: "Follow another player, don't actually burgle.  You must group with them first."}
      ]
    ]

    args = parse_args(arg_definitions)

    #Ensure hometown is in sentence case if it's specified - fixes the fact parse_args is always lower case
    args.hometown = args.hometown.gsub(/\b('?[a-z])/) { $1.capitalize } if args.hometown
    #kludge fix for Mer'Kresh
    args.hometown = "Mer'Kresh" if args.hometown == "Mer'kresh"
    @follow = false
    @follow = true if args.follow

    #hash which maps directions to their reverse, for backing out of the house
    @reverse_direction_map = {
      'east' => 'west',
      'west' => 'east',
      'south' => 'north',
      'north' => 'south',
      'northeast' => 'southwest',
      'southwest' => 'northeast',
      'northwest' => 'southeast',
      'southeast' => 'northwest'
    }

    #maps the searchable objects based on the room title
    @room_searchable_objects_map = {
      "Kitchen" => 'counter',
      "Bedroom" => 'bed',
      "Armory" => 'rack',
      "Library" => 'bookshelf',
      "Sanctum" => 'desk',
      "Work Room" => 'table'
    }

    start_script('jail-buddy') unless Script.running?('jail-buddy')

    @settings = get_settings
    @burgle_settings = @settings.burgle_settings
    @loot_container = @burgle_settings['loot_container']
    @use_lockpick_ring =  @burgle_settings['use_lockpick_ring']
    @lockpick_container =  @burgle_settings['lockpick_container']
    @max_priority_mindstate = @burgle_settings['max_priority_mindstate'] || 26
    @loot_room_id = nil

    #set yaml settings unless being overridden from the command line arguments
    @entry_type = args.entry || @burgle_settings['entry_type']
    @burgle_room = args.roomid || @burgle_settings['room']
    @loot_type = args.loot_type ||  @burgle_settings['loot']
    @hometown = args.hometown || @burgle_settings['hometown'] || @settings.hometown
    @burgle_before_scripts = @burgle_settings['before']
    @burgle_after_scripts = @burgle_settings['after']

    if @entry_type =~ /lockpick|cycle/ && ( @use_lockpick_ring == nil || @lockpick_container == nil )
      message("Settings for lockpick rings are now in burgle_settings:use_lockpick_ring and burgle_settings:lockpick_container.")
      message("Using old setting of use_lockpick_ring and lockpick_container from pick for now, but this will be removed in the future.")
      message("To reuse the same settings, please use anchors: https://github.com/rpherbig/dr-scripts/wiki/YAML-Anchors")
      @use_lockpick_ring = @settings.use_lockpick_ring if @use_lockpick_ring == nil
      @lockpick_container = @settings.lockpick_container if @lockpick_container == nil
    end

    #setup an empty list for loot.  used to store the loot you manage to get, to ether drop, pawn or bin.
    @loot_list = []

    #Add flag to watch for warning sign, unless safe mode is turned off - safe_mode is defaulted
    #anywhere this flag is checked, it prevents further actions being taken and should force you out of the house
    Flags.add('burgle-footsteps',"Footsteps nearby make you wonder if you're pushing your luck.") unless @burgle_settings['safe_mode'] == false

    #Check minimal yaml settings before starting.  Missing these can lead to staying in the house too long
    #this is not a 100% check.  it is still possible to mess up and get stuck in the house if you're not careful with your settings
    if !valid_burgle_settings?
      message("It is very important that you check the documentation before running: https://elanthipedia.play.net/Lich_script_repository#burgle ")
      message("This is a dangerous script to run if it's not understood.  If you get caught there are very high fines, and the loss of all your items is possible if you can't pay your debt.")
      pause 10
      exit
    end

    burgle
  end

  def valid_burgle_settings?
    if @burgle_settings.empty?
      message("You have empty burgle_settings.  These must be set before running.")
      return false
    end
    if @burgle_room == nil || @burgle_room =~ /\D/
      message("Invalid burgle_settings:room setting.  This must be room id of the room you want to burgle from.")
      return false
    end
    if @entry_type == nil || @entry_type !~ /lockpick|rope|cycle|prioritylockpick|priorityrope/i
      message("Invalid burgle_settings:entry_type setting.")
      return false
    end
    if @burgle_settings['max_search_count'] > 0
      if /(already open|^You.+open|^You can't do that)/ !~ bput("open my #{@loot_container}", 'already open', '^You.+open', '^You spread your arms, carefully holding your bag well away from your body', 'Please rephrase that command', 'What were you referring', 'You can\'t do that')
        message("You do not have a burgle_settings:loot_container set/set to container you have.  Loot must have a place to be stored prior to exiting the house, even if dropping loot.")
        return false
      end
    end

    case @loot_type
    when /bin/
      validate_bin_settings
    when /pawn/
      validate_pawn_settings
    else
      @loot_room_id = nil
    end

    return true
  end

  def validate_bin_settings
    # bin only works if you're a thief, and there is a bin in your hometown
    # fall back to pawning if you can't bin for some reason, next best option since you don't want to keep the loot
    if DRStats.thief?
      @loot_room_id = get_hometown_target_id(@hometown,'thief_bin')
      if !(@loot_room_id)
        message("Binning not supported in #{@hometown}. Attempting fallback to pawning loot.")
        pause 5
        @loot_type = 'pawn'
        validate_pawn_settings
      end
    else
      message("You are not a thief.  You can't use thief bins.  Attempting fallback to pawning loot.")
      pause 5
      @loot_type = 'pawn'
      validate_pawn_settings
    end
  end

  def validate_pawn_settings
    # pawn only works if there is a pawnshop in your hometown
    # fall back to drop if you can't pawn, next best option since you don't want to keep the loot
    @loot_room_id = get_hometown_target_id(@hometown,'pawnshop')
    if !(@loot_room_id)
      @loot_type = 'drop'
      message("Pawning not supported in #{@hometown}.  Fallback to dropping loot.")
    end
  end

  def burgle
    #check to make sure you aren't under cooldown.  If you are, you will be instantly arrested, so return from script if this is the case
    return unless /The heat has died down from your last caper/ =~ bput('burgle recall', '^You should wait at least \d+ roisaen for the heat to die down', '^The heat has died down from your last caper')

    #don't bother with entry type checks if following
    if !@follow
      #check for entry method, and ensure you have the required items
      case @entry_type
      when /priorityrope/
        if DRSkill.getxp('Athletics') <= @max_priority_mindstate || DRSkill.getxp('Athletics') < DRSkill.getxp('Locksmithing')
          check_cycle_priority('rope')
        else
          check_cycle_priority('lockpick')
        end
      when /prioritylockpick/
        if DRSkill.getxp('Locksmithing') <= @max_priority_mindstate || DRSkill.getxp('Locksmithing') < DRSkill.getxp('Athletics')
          check_cycle_priority('lockpick')
        else
          check_cycle_priority('rope')
        end
      when /rope/i
        if !check_entry?(@entry_type)
          message("Couldn't find entry item: heavy rope")
          exit
        end
      when /lockpick/i
        if !check_entry?(@entry_type)
          if @use_lockpick_ring
            message("Couldn't find entry item: #{@lockpick_container}")
          else
            message("Couldn't find entry item: lockpick")
          end
          exit
        end
      when /cycle/i
        case DRSkill.getxp('Athletics') <=> DRSkill.getxp('Locksmithing')
        when -1
          check_cycle_priority("rope")
        when 0
          if DRSkill.getrank('Athletics') < DRSkill.getrank('Locksmithing')
            check_cycle_priority("rope")
          else
            check_cycle_priority("lockpick")
          end
        when 1
          check_cycle_priority("lockpick")
        end
      else
        message("Unknown entry method: #{@entry_type}")
        return
      end
    end

    #entry method must be in your right hand, or have a worn lockpick ring
    #the item in your takes priority, so store any items in your hands before beginning
    EquipmentManager.new.empty_hands
    if DRC.right_hand || DRC.left_hand
      echo "Exited due to item that could not be stowed.  Please check your hands and gear settings then try again."
      exit
    end

    #don't bother heading to the right area, if following
    if !@follow
      if !walk_to(@burgle_room)
        message("Unable to get to your burgle room.  Exiting to prevent errors.")
        exit
      end
    end

    execute_extra_scripts(@burgle_before_scripts)
    get_entry(@entry_type) unless @follow
    wait_for_script_to_complete('buff', ['burgle']) if @settings.waggle_sets['burgle']

    fix_standing
    #ensure you're in hiding or invis before starting
    if !invisible?
      hide_attempts = 3
      until hide?
        hide_attempts -= 1
        if hide_attempts <= 0
          message("Couldn't hide.  Find a better room.")
          return
        end
      end
    end

    #setup flags for group burgle here
    Flags.add('group-burgle-disband','With aid from your group')
    Flags.add('group-burgle-leave','With aid from his group','With aid from her group')

    #prevent race condition that can occur with bput and invisibility and playing music
    bput('stop play','In the name of love','You stop playing') if invisible? && (Script.running?('performance') || Script.running?('play'))

    #match is for room title, so that in rob_the_place the XMLData.room_title is already properly set
    if @follow
      waitfor("Someone Else's Home")
    else
      bput('burgle',"Someone Else's Home")
    end

    #leave the group/disband so you aren't carried around
    if Flags['group-burgle-leave']
      fput('leave')
    elsif Flags['group-burgle-disband']
      fput('disband stalk')
      fput('disband group')
    else
      pause 1   # need a pause because there is no indicator if you are part of a group currently with 2 person rope entry
    end

    if @burgle_settings['max_search_count'] > 0
      @search_count = 0
      rob_the_place
    end

    bput('go window', 'You take a moment to reflect on the caper')

    #likely to have invisibility up if you have access to it.
    #be sure to release it since it breaks a lot of things
    release_invisibility

    #reset Flags so that store_loot fires correctly
    Flags.reset('burgle-footsteps')

    #make hands empty again, as they likely have loot/entry method in them
    store_loot

    execute_extra_scripts(@burgle_after_scripts)

    process_loot
  end

  #ensures you have the proper entry methods accessible
  def check_entry?(entry_type)
    case entry_type
    when /rope/i
      return exists?("heavy rope")
    when /lockpick/i
      if @use_lockpick_ring
        return exists?(@lockpick_container)
      else
        return exists?("lockpick")
      end
    end
    return false #invalid entry type
  end

  #selected cycle for entry_type, validate that you have the prioritized entry_type, and if not, fallback to other
  def check_cycle_priority(entry_type)
    case entry_type
    when /rope/i
      if !check_entry?("rope")          #if you don't have a rope, fall back to lockpick
        if !check_entry?("lockpick")    #if you don't have a lockpick, after falling back from rope, you can't do anything
          message("Couldn't find any entry method.")
          exit
        else
          message("Set to cycle or priority, but could only find lockpick.")  #warn user that they are missing an entry method. cycle requires presence of both to work right
        end
        @entry_type = "lockpick"
      else
        @entry_type = "rope"
      end
    when /lockpick/i
      if !check_entry?("lockpick")    #if you don't have a lockpick, fall back to rope
        if !check_entry?("rope")      #if you don't have a rope, after falling back from lockpick, you can't do anything
          message("Couldn't find any entry method.")
          exit
        else
          message("Set to cycle or priority, but could only find rope.")    #warn user that they are missing an entry method. cycle requires presence of both to work right
        end
        @entry_type = "rope"
      else
        @entry_type = "lockpick"
      end
    else
      message("Invalid priority type.")
      exit
    end
  end

  #Should already have checked for entry type, now get it (right before buff/robbing), but this validates anyway to be safe
  def get_entry(entry_type)
    case entry_type
    when /rope/i
      if bput('get my heavy rope', 'You get', 'You are already holding' ,'What were you') =~ /What were you/
        message("Couldn't find entry item: heavy rope")
        exit
      end
    when /lockpick/i
      if @use_lockpick_ring
        return
      elsif bput('get my lockpick', 'You get', 'You are already holding' ,'What were you') =~ /What were you/
        message("Couldn't find entry item: lockpick")
        exit
      end
    end
  end

  #direction is the direction you came from to get to this room
  def rob_the_place(direction = nil)
    #empty array for directions you have already visited
    visited = []
    #if you came from a previous room, add it to the array so you don't loop
    visited.push(direction) unless direction == nil

    #get the room type, which is used to get searchable objects
    if room_match = XMLData.room_title.match(/\[\[Someone Else's Home, (?<room>.*)\]\]/)
      current_room = room_match[:room]
      #search the lootable objects unless the room type has been blacklisted
      search_for_loot(@room_searchable_objects_map[current_room]) unless @burgle_settings['room_blacklist'].include?(current_room)
      #while you still have other rooms from this room to visit, you haven't exhausted your search count, and you haven't seen footsteps in safe_mood:
      while XMLData.room_exits.count > visited.count && @search_count < @burgle_settings['max_search_count'] && !(Flags['burgle-footsteps']) do
        #pick a new room to go to
        newdir = XMLData.room_exits.reject { |exit| visited.include?(exit) }.sample
        #store that you're going to it
        visited.push(newdir)
        #store how to back out
        reverse = @reverse_direction_map[newdir]
        #go to the picked room
        burgle_move(newdir)
        #loot the new room, unless you've seen footsteps in safe_mode
        rob_the_place(reverse) unless Flags['burgle-footsteps']
        #backup to the original room
        burgle_move(reverse)
      end
    end
  end

  def search_for_loot(target)
    #don't hide/search if you've seen footsteps and are in safe_mode
    return if Flags['burgle-footsteps']
    #ensure you're in hiding or invis before looting -> only try once because of timer
    if !invisible?
      hide?
      message("Couldn't hide.  Searching to avoid delays.") unless hidden?
    end

    #don't search if you've seen footsteps and are in safe_mode
    return if Flags['burgle-footsteps']
    result = bput("search #{target}",'It looks valuable','Roundtime','I could not')
    @search_count += 1
    if result =~ /It looks valuable/
      store_loot if DRC.right_hand && DRC.left_hand
      return
    elsif @burgle_settings['retry'] && @search_count < @burgle_settings['max_search_count'] && !(Flags['burgle-footsteps'])
      search_for_loot(target)
      return
    end
  end

  def store_loot
    #if you've seen footsteps, don't bother storing items, and just get out if in safe mode
    return if Flags['burgle-footsteps']
    #store loot in your loot container, unless the item in your hands is a rope or lockpick
    case DRC.right_hand
    when nil
    when /(?:lockpick|rope)$/
      stow_hand("right")
    when *@burgle_settings['item_whitelist']
      put_item?(DRC.right_hand)
    else
      temp_loot = DRC.right_hand
      @loot_list.push(temp_loot) if put_item?(DRC.right_hand)
    end

    #if you've seen footsteps, don't bother still storing items, and just get out if in safe mode
    return if Flags['burgle-footsteps']
    #store loot in your loot container, unless the item in your hands is a rope or lockpick
    case DRC.left_hand
    when nil
    when /(?:lockpick|rope)$/
      stow_hand("left")
    when *@burgle_settings['item_whitelist']
      put_item?(DRC.left_hand)
    else
      temp_loot = DRC.left_hand
      @loot_list.push(temp_loot) if put_item?(DRC.left_hand)
    end
  end

  #specialized move routine - sneaks when in hiding, when needed, moves when not to speed up script
  def burgle_move(direction)
    if !invisible? && hidden? && @search_count < @burgle_settings['max_search_count'] && !(Flags['burgle-footsteps'])
      result = bput("sneak #{direction}","Someone Else's Home",'Sneaking is an',"You can't",'In YOUR condition')
      return if /Someone Else's Home/ =~ result
    end
    bput(direction,"Someone Else's Home")   #don't use move as it can cause a race condition with invisibility and blacklisting kitchen
  end

  #ripped out of steal.lic
  def put_item?(item)
    case bput("put my #{item} in my #{@loot_container}", 'What were you', 'You put', "You can't do that", 'no matter how you arrange it', 'even after stuffing', 'The .* is *.* too \w+ to fit in', 'There isn\'t any more room', 'perhaps try doing that again')
    when 'perhaps try doing that again'
      return put_item?(item)
    when 'You put'
      return true
    when 'What were you'
      handheld = held_item(item)
      drop_item(held_item(item)) if handheld
      return false
    else
      drop_item(item)
      return false
    end

    false
  end

  #ripped out of steal.lic
  def drop_item(item)
    case bput("drop my #{item}", 'You drop', 'You spread', 'You wince', 'would damage it', 'smashing it to bits', 'Something appears different about', 'What were you')
    when 'would damage it', 'Something appears different about'
      drop_item(item)
    when 'What were you'
      handheld = held_item(item)
      return drop_item(held_item(item)) if handheld
    end
  end

  #ripped out of steal.lic
  def held_item(item)
    [DRC.right_hand, DRC.left_hand].each do |hand_item|
      hand_item.split.each do |item_word|
        return hand_item if item.include?(item_word)
      end
    end

    return nil
  end

  def pawn_item(item)
    case bput("sell my #{item}",
      'You sell your',                        # success
      "You'll want to empty that first",      # non-empty container
      /shakes (his|her) head and says/,       # not worth enough (generic)
      'Relf briefly glances at your',         # not worth enough (hib - special messaging)
      'Oweede growls and says,',              # not worth enough (Mer'Kresh)
      "There's folk around here that'd slit", # Too expensive (Shard, Crossing)
      "but it's much too fine for me.",       # Too expensive (Riverhaven, Theren)
      "Bynari laughs")                        # Not enough/too expensive (Langenfirth)
    when 'You sell your'
      return
    else
      drop_item(item)
    end
  end

  #ripped out of hunting-buddy
  def execute_extra_scripts(extra_scripts)
    extra_scripts.each do |script|
      DRC.message "***STATUS*** EXECUTE #{script}"
      script_args = script.split(' ')
      script_name = script_args.shift
      DRC.wait_for_script_to_complete(script_name, script_args)
    end
  end

  def process_loot
    #return if loot_type isn't one of the supported process kind
    return if @loot_type !~ /drop|pawn|bin/
    #return if loot_list is empty.
    return if @loot_list.empty?

    walk_to(@loot_room_id) unless @loot_room_id == nil

    @loot_list.each do |item|
      case bput("get #{item} from my #{@loot_container}", 'You get', 'What were you referring to?')
      when /^You get/
        case @loot_type
        when 'bin'
          bput("put #{item} in bin", 'nods toward you as your .* falls into the .* bin')
        when 'pawn'
          pawn_item(item)
        when 'drop'
          drop_item(item)
        end
      when /^What were you referring to/  #handle items that stack/missing items
        next
      end
    end
  end

end

before_dying do
  #resume the previously paused scripts
  Script.running.find_all { |s| s.paused? && !s.no_pause_all && $scripts_to_unpause.include?(s.name) }.each(&:unpause)
  Flags.delete('burgle-footsteps')
end

#Pause all running scripts, that do not have no_pause_all flag set
#Do not use pause_all/unpause_all, as when resuming this could resume scripts that were not paused by burgle
$scripts_to_unpause = []
Script.running.find_all { |s| !s.paused? && !s.no_pause_all && s.name != Script.self.name}.each do  |s|
  s.pause
  $scripts_to_unpause << s.name
end

Burgle.new