lichbot.lic

# want_script_output
=begin
  Documentation: https://elanthipedia.play.net/Lich_script_repository#lichbot
=end

custom_require.call(%w(common common-arcana common-items common-validation drinfomon events))

class Lichbot
  include DRC
  include DRCA
  include DRCI

  def initialize(sleep)
    Flags.add('give-accepted', '.* has accepted your offer and is now holding .*')
    Flags.add('give-declined', '.* has declined the offer')
    Flags.add('give-expired', 'Your offer to .* has expired')

    Flags.add('stopped-listening', 'Your teacher is not here, so you are no longer learning anything', '.* stops teaching')

    @settings = get_settings
    @last_action = Time.now
    @last_dump_junk = Time.now
    @last_teacher = nil
    @inventory = []
    refresh_inventory

    fput('avoid !all')
    fput('avoid whispering')
    fput('avoid teaching') unless sleep
  end

  def accept(character)
    @last_action = Time.now
    waitrt?
    case bput('accept', 'You accept', 'would push you over your item limit')
    when 'would push you over your item limit'
      fput "whisper #{character} ***ERROR*** I am at my inventory limit and cannot accept that."
      fput 'decline'
      return
    end

    stow_hands
    if right_hand || left_hand
      fput("drop my #{right_hand}") if right_hand
      fput("drop my #{left_hand}") if left_hand
      fput "whisper #{character} ***ERROR*** I was unable to stow that item, so I have dropped it. If you cannot pick it up, try again in 30 seconds."
    else
      refresh_inventory
    end
  end

  def list_buffs(character)
    @last_action = Time.now
    fput "whisper #{character} My buffs are:"
    @settings.lichbot_buffs.each { |buff| fput "whisper #{character}   #{buff['name']} [#{buff['abbrev']}] - #{buff['description']}" }
    fput "whisper #{character} END"
  end

  def cast_buff(character, abbrev)
    @last_action = Time.now
    buff_data = @settings.lichbot_buffs.find { |buff| buff['abbrev'] == abbrev }
    unless buff_data
      fput "whisper #{character} I'm sorry, I do not know spell [#{abbrev}]"
      return
    end

    fput "whisper #{character} Preparing [#{buff_data['name']}] now"
    buff_data = buff_data.clone
    buff_data['cast'] = "cast #{character}"
    buff(buff_data, @settings)
    fput "whisper #{character} Buffing complete"
  end

  def give(character, item)
    @last_action = Time.now
    unless get_item?(item)
      fput "whisper #{character} Sorry, I failed to find [#{item}] in my inventory"
      return
    end

    Flags.reset('give-accepted')
    Flags.reset('give-expired')
    Flags.reset('give-declined')
    return unless give_item?(character, item, false)
    pause 0.5 until Flags['give-accepted'] || Flags['give-expired'] || Flags['give-declined']

    stow_hands
    refresh_inventory if Flags['give-accepted']
  end

  def give_item?(character, item, repeat = false)
    if repeat
      fput('swap') unless right_hand
      command = "give #{character}"
    else
      command = "give my #{item} to #{character}"
    end

    case bput(command, 'You offer', 'What is it', "You don't need to specify the object")
    when 'What is it'
      fput "whisper #{character} Sorry, I failed to give you [#{item}]"
      stow_hands
      return false
    when "You don't need to specify the object"
      return give_item?(character, item, true)
    end

    true
  end

  def inventory(character)
    @last_action = Time.now
    fput "whisper #{character} My inventory is:"
    @inventory.each { |item| fput "whisper #{character}   #{item}" }
    fput "whisper #{character} END"
  end

  def help(character)
    @last_action = Time.now
    fput "whisper #{character} Supported commands are:"
    fput "whisper #{character}   (help) - this list"
    fput "whisper #{character}   (inv|inventory) - view the items I have available"
    fput "whisper #{character}   (give|giveme) [item] - take an item from me"
    if @settings.lichbot_buffs
      fput "whisper #{character}   (buffs|spells) - view the buffs I can cast"
      fput "whisper #{character}   (buff|cast) [abbreviation] - receive [abbreviation] buff from me"
    end
    fput "whisper #{character} I will also accept and stow any item you trade me."
  end

  def ping
    check_for_junk

    return unless @settings.lichbot_train_when_idle
    return if @last_action + 60 * 3 > Time.now
    @last_action = Time.now

    if Flags['stopped-listening'] || @last_teacher.nil? || !listen?(@last_teacher)
      classes = assess_teach
      @last_teacher = classes
                      .reject { |t, s| t.nil? || s.nil? }
                      .sort_by { |_t, s| [DRSkill.getxp(s), DRSkill.getrank(s)] }
                      .find { |t, _s| listen?(t) }
                      .first
      Flags.reset('stopped-listening')
    end

    if should_train?('Attunement')
      bput('perc', 'You reach out')
      waitrt?
    end

    return unless should_train?('Augmentation') || should_train?('Arcana')

    buff_data = @settings
                .lichbot_buffs
                .sort_by { |spell| DRSpells.active_spells[spell['name']] || 0 }
                .first
    buff(buff_data, @settings) if buff_data
  end

  private

  def check_for_junk
    return if DRRoom.room_objs.count < 10
    return if @last_dump_junk + 60 * 1 > Time.now
    @last_dump_junk = Time.now

    if @settings.lichbot_compost
      prepare?('compost', 1)
      pause 1
      cast?
    end

    return if DRRoom.room_objs.count.zero?
    fix_standing
    fput('dump junk')
  end

  def should_train?(skill)
    DRSkill.getxp(skill) < 28
  end

  def get_item?(item)
    waitrt?

    case bput("get #{item}", 'You get', 'You are already holding', 'But that is already in your inventory', 'Please rephrase', 'What were you', 'You should stop playing')
    when 'But that is already in your inventory'
      return get_item?("second #{item}")
    when 'You should stop playing'
      bput('stop play', 'You stop playing your song', 'In the name of', 'But you\'re not performing')
      return get_item?(item)
    when 'Please rephrase', 'What were you'
      return false
    end

    true
  end

  def refresh_inventory
    waitrt?
    bput('inv list', 'Roundtime')

    log = reget(400)
    start_index = log.rindex { |x| x =~ /You have/i } + 1
    end_index = log.rindex { |x| x =~ /Roundtime/i } - 1

    return unless start_index && end_index

    @inventory =
      log[start_index..end_index]
      .select { |item| item.lstrip.start_with?('-') }
      .map { |item| item.strip[1..-1] }
  end
end

arg_definitions = [
  [
    { name: 'start', regex: /start/i, description: 'Required: prevents accidentally starting up lichbot' },
    { name: 'announce', regex: /announce/i, optional: true, description: 'If arg is present, lichbot will announce its presence in LNet' },
    { name: 'sleep', regex: /sleep/i, optional: true, description: 'If arg is present, lichbot will sleep so as not to gain experience' },
    { name: 'greet', regex: /greet/i, optional: true, description: 'If arg is present, lichbot will greet characters after validating (but only once)' }
  ]
]

args = parse_args(arg_definitions)

lichbot = Lichbot.new(args.sleep)
validator = CharacterValidator.new(args.announce, args.sleep, args.greet, 'Lichbot')

@last_room_list = []
loop do
  line = script.gets?
  pause 0.05 unless line

  if DRRoom.pcs != @last_room_list
    (DRRoom.pcs - @last_room_list).each { |name| validator.validate(name) }
    @last_room_list = DRRoom.pcs
  end

  case line
  when /^(.*) offers you (.*).  Enter ACCEPT to accept the offer or DECLINE to decline it.  The offer will expire in 30 seconds.$/
    character = Regexp.last_match(1)

    if validator.valid?(character)
      lichbot.accept(character)
    else
      fput('decline')
    end
  when /^(.*) whispers, "(inv|inventory)"$/i
    character = Regexp.last_match(1)

    next unless validator.valid?(character)
    lichbot.inventory(character)
  when /^(.*) whispers, "(help)"$/i
    character = Regexp.last_match(1)

    next unless validator.valid?(character)
    lichbot.help(character)
  when /^(.*) whispers, "(buffs|spells)"$/i
    character = Regexp.last_match(1)

    next unless validator.valid?(character)
    lichbot.list_buffs(character)
  when /^(.*) whispers, "(give|giveme) (.*)"$/i
    character = Regexp.last_match(1)
    item = Regexp.last_match(3)

    next unless validator.valid?(character)
    lichbot.give(character, item)
  when /^(.*) whispers, "(buff|cast) (.*)"$/i
    character = Regexp.last_match(1)
    abbrev = Regexp.last_match(3)

    next unless validator.valid?(character)
    lichbot.cast_buff(character, abbrev)
  when /^(.*) whispers, ".*"$/i
    character = Regexp.last_match(1)

    next unless validator.valid?(character)
    fput "whisper #{character} I'm sorry, I did not understand that command"
    lichbot.help(character)
  when /^\[server\]: "DR:(.*) is tuned to the following channels.*"$/
    character = Regexp.last_match(1)

    validator.confirm(character)
  when /^\[server\]: "DR:(.*) is connected but not tuned to any channels.*"$/
    character = Regexp.last_match(1)

    validator.confirm(character)
  when /^\[Private\]-.*:(.*): "RequestSlackToken"/
    character = Regexp.last_match(1)
    validator.confirm(character)
    validator.send_slack_token(character)
  else
    lichbot.ping
  end
end