cb_trmo.txt

# TABLE OF CONTENTS:
#
# SECTION A: Crawl options.
#            Self explanatory.
#
# Section B: Global variables you can change to tweak cb's behavior.
#
# SECTION C: Global varaibles you shouldn't change.
#
# SECTION D: Strategy functions.
#            These fucntions implement specific strategies, such as:
#            Quaff ID a potion. Travel to the lair. Rest. Progress.
#            More general strategies might call on more specific strategies
#            acording to the strategy tables.
#
#            These tables govern which strategies have priority over which
#            other strategies. For instance you would rather berserk than
#            attack. However if there's no reason to beserk (because the
#            situation doesn't pose enough of a threat) or if you can't go
#            berserk for some reason, then attacking normally will be your
#            fall back plan.
#
#            If you're like to change the route (orc before lair for instance)
#            or some other simplistic strategy change, then you may be able to
#            do it here without having to be much of a programmer.
#
# SECTION E: Main functions.
#            These functions include "hit_closest()" which is called when you
#            press TAB. As well as "ready()" which is called when Crawl is
#            ready to accept user input. In addition the heartbeat function
#            "cb_main()" is included. These functions drive the bot, and are
#            the entry points to everything else, so if you're curious how cb
#            works, then this is the place you want to start reading.
#
# SECTION F: Autopickup functions.
#            These functions control cb's dynamic autopickup functionality.
#            There is the "autopickup()" entry point as well as related
#            functions needed for item prioritization.
#
# SECTION G: Utility functions.
#            These functions are called by all the above functions. They
#            include general stuff used everywhere like "say(message)" which
#            is called all over the place for feedback and debugging. As well
#            as some functions that may only be used by one or two strategies.

#############
# SECTION A #
#############

view_delay = 0
use_animations =
clear_messages = true
travel_delay = -1
explore_delay = -1
travel_key_stop = false
default_manual_training = true
auto_exclude =
hp_warning = 0
show_more = false
show_newturn_mark = false
force_more_message =
show_travel_trail = false
skill_focus = false
flush.failure = false
char_set = default
use_fake_player_cursor = true
equip_unequip = true

dump_order = header,hiscore,stats,misc,mutations,skills,spells,inventory
dump_order += overview
dump_order += messages,screenshot,monlist,kills,notes,vaults,action_counts
note_hp_percent = 25
note_skill_levels = 1,3,6,9,12,15,18,21,24,27

# TODO: This section needs some serious work.
fire_order = stone

# We stop exploring here, because we might want to do something that preempts
# exploration, such as worshipping a god or unshafting ourselves.
explore_stop = portals,stairs,altars,greedy_pickup_smart

message_colour ^= mute:Unknown command
message_colour ^= mute:Sorry, you're not good enough to have a special ability.

bindkey = [Y] CMD_NO_CMD_DEFAULT
bindkey = [N] CMD_NO_CMD_DEFAULT

# Lua begins here.

{
---------------
-- Section B --
---------------
-- An important decision to make :)
-- This name needs to use the same capitalization as you.god() does.
local chosen_god = "Okawaru"

-- Another important decision.
-- "s" "d" "i"
local prefered_stat = "d"

-- When loading a saved game, we have no way of knowing for sure if we've been
-- "shafted" or not. If set to true we assume we have been, and go up three levels
-- before working our way down.
local attempt_unshaft_on_start = false

-- Assumes the temple hasn't been explored, even if you already worship a god.
-- Since exploring the temple if you have selected a god is a waste of time, this
-- should be set to true unless you are trying to test something.
local temple_explored = false

-- A number between 0 and 1 that signifies a dangerous percentage of hp.
local low_hp_percent = 0.5

---------------
-- Section C --
---------------
local LOS = 7

local max_shaft_depth = 3

local last_explored_level = -1

local max_reach_range = 2

local run_mode = false

local run_turn = 0

crawl.enable_more(false)

---------------
-- SECTION C --
---------------

function win()
  local win_strategy = {
    rest,
    relax,
    progress,
    fight,
    emergency}

  -- Look before taking action.
  update_monster_array()

  local n = 1
  local success = false
  while not success do
    if not win_strategy[n] then
      -- We've reached the end of the strategy table.
      -- This means we've failed.
      say("ERROR: CB failed to implement any of the strategies in the main table.")
      say("ERROR: CB is out of ideas and is returning control to the user.")
      return false
    end
    success = win_strategy[n]()
    n = n + 1
  end
end

function do_rest()
  do_it("5")
end

function rest()
  -- Reasons not to rest.
  if danger() then
    return false
  end

  -- Reasons to rest.
  local hp, mhp = you.hp()
  local mp, mmp = you.mp()
  if hp < mhp or mp < mmp then
    do_rest()
    return true
  end

  if you.poisoned() or
  you.berserk() or
  you.confused() or
  you.exhausted() or
  you.slowed() or
  you.corrosion() > 0 then
    do_rest()
    return true
  end

  return false
end

function relax()
  local relax_strategy = {
    shuffle_skills,
    eat_chunk,
    butcher_corpse,
    find_nearby_corpse,
    eat_permafood}

  -- Reasons not to relax.
  if danger() then
    return false
  end

  local n = 1
  local success = false
  while not success do
    if not relax_strategy[n] then
      return false
    end
    success = relax_strategy[n]()
    n = n + 1
  end
  return success
end

function shuffle_skills()
  you.train_skill("Stealth", 0)

  you.train_skill("Unarmed Combat", 1)
  you.train_skill("Fighting", 1)
  you.train_skill("Dodging", 1)

  if you.god() ~= chosen_god and you.base_skill("Invocations") < 7 then
    you.train_skill("Invocations", 1)
  else
    you.train_skill("Invocations", 0)
  end
end

function do_eat_chunk()
  do_it("ee")
end

function eat_chunk()
  if have_chunk() and can_eat_chunk() then
    do_eat_chunk()
    return true
  end
  return false
end

function butcher_corpse()
  local corpse_count = 0
  for item in at_feet() do
    -- We can't use item.class because skeletons have class corpse.
    -- It's really fucking dumb.
    if string.find(item.name(), "corpse") then
      corpse_count = corpse_count + 1
    end
  end

  if corpse_count == 1 then
    do_it("c")
    return true
  elseif corpse_count > 1 then
    do_it("ccq")
    return true
  end
  return false
end

function find_nearby_corpse()
  -- We just butcher everything indiscriminately because it's simple.
  -- The final ESC is needed because it makes sure ready() is called again???
  return try_it(control('f') .. "@corpse&&!!skel&&!!rot\ra\r" .. string.char(27))
end

function do_eat_permafood()
  for item in inventory() do
    if item.class(true) == "food" and
       food.edible(item) and
       not food.ischunk(item) then
      say("NOTICE: Eating permafood: " .. item.name())
      items.swap_slots(item.slot, items.letter_to_index("e"), false)
      do_it("ee")
      return
    end
  end
end

function eat_permafood()
  if have_permafood() and need_to_eat() then
    do_eat_permafood()
    return true
  end
  return false
end

function progress()
  local progress_strategy = {
    ascend_with_orb,
    worship_god,
    depart_abyss,
    unshaft,
    -- It's important to take note of what we prioritize above exploration.
    explore,
    temple}

  -- Reasons not to progress.
  if danger() then
    return false
  end

  local n = 1
  local success = false
  while not success do
    if not progress_strategy[n] then
      return false
    end
    success = progress_strategy[n]()
    n = n + 1
  end
  return success
end

function ascend_with_orb()
  return false
end

function worship_god()
  if you.god() == chosen_god then
    return false
  end

  if view.feature_at(0, 0) == "altar_" .. chosen_god:lower() then
    do_it("pYY")
    return true
  end

  return try_it(control('f') .. "@altar&&" .. chosen_god:lower() .. "\ra\r" .. string.char(27))
end

function depart_abyss()
  return false
end

function unshaft()
  branch, level = whereami()

  if last_explored_level == -1 and not attempt_unshaft_on_start then
    -- We make the assumpion that the previous level was the last explored one.
    -- This means we're not shafted of course.
    last_explored_level = level - 1
    return false
  end

  if last_explored_level == -1 and attempt_unshaft_on_start then
    -- We make the assumption that we were 3 floors up before we were shafted.
    last_explored_level = level - max_shaft_depth - 1

    -- A value of 0 means that no levels have been explored, so we will travel to branch:1.
    if last_explored_level < 0 then
      last_explored_level = 0
    end
  end

  if level - 1 > last_explored_level then
     -- The final ESC is needed because it makes sure ready() is called again???
     return try_it("G<" .. string.char(27))
  end
end

function explore()
  -- One ESC key is needed to exit out of shops.
  -- The second ESC is needed because it makes sure ready() is called again???
  return try_it("o" .. string.char(27) .. string.char(27))
end

function temple()
  branch, level = whereami()

  if you.god() == chosen_god and temple_explored == true then
    return false
  end

  if branch == "Temple" then
    temple_explored = true
    return false
  end

  if travel.find_deepest_explored("Temple") == 0 then
    if branch == "D" and level < 7 then
      last_explored_level = level
      -- The final ESC is needed because it makes sure ready() is called again???
      do_it("G>" .. string.char(27))
      return true
    else
      say("ERROR: We can't find the temple for some reason!")
      return false
    end
  else
    -- The final ESC is needed because it makes sure ready() is called again???
    do_it("GT" .. string.char(27))
  end
end

function fight()
  local fight_strategy = {
    stairdance_up,
    retreat_to_upstairs,
    hide,
    whack,
    shoot,
    wait,
    charge}

  -- Nothing to fight...
  if not danger() then
    return false
  end

  local n = 1
  local success = false
  while not success do
    if not fight_strategy[n] then
      say("ERROR: Unable to fight for some reason.")
      return false
    end
    success = fight_strategy[n]()
    n = n + 1
  end
  return success
end

function stairdance_up()
  local floor = view.feature_at(0,0)
  if not floor:find("stone_stairs_up") and
  floor ~= "escape_hatch_up" then
    return false
  end

  if threat_level() < 10 then
    return false
  end

  local result = try_it("<")
  if result then
    -- This is to stop us from going back down the dangerous stairs.
    travel.set_exclude(0, 0, 0)
  end

  return result
end

function retreat_to_upstairs()
  local current_threat = threat_level()

  if current_threat < 10 then
    return false
  end

  if you.slowed() then
    return false
  end

  local branch, level = whereami()
  if branch == "D" and level == 1 then
    return false
  end

  for x = -LOS, LOS do
    for y = -LOS, LOS do
      local m = monster_array[x][y]
      if (m and not m:is_safe())
      or view.invisible_monster(x, y) then
        local r = math.max(math.abs(x), math.abs(y)) - 1
        travel.set_exclude(x, y, r)
      end
    end
  end


  run_mode = true
  run_turn = you.turns()
  local result = try_it("X<\r" .. string.char(27))
  -- Clear the exclusions once we're done.
  try_it("X" .. control('e') .. string.char(27).. string.char(27))
  run_mode = false
  if not result then
    say("WARNING: We tried to run but couldn't!")
    return true
  end

  return result
end

function hide()
  return false
end

function whack()
  local target_x = 0
  local target_y = 0
  local current_highest_threat = -1
  local current_worst_injury = -1
  for x = -1, 1 do
    for y = -1, 1 do
      local m = monster_array[x][y]
      if m and not m:is_safe() then
        if (m:threat() > current_highest_threat) or
        -- -- -- -- --
        (m:threat() == current_highest_threat and
        m:damage_level() > current_worst_injury) or
        -- -- -- -- --
        current_highest_threat < 0 then
          target_x = x
          target_y = y
          if m:is("summoned") then
            current_highest_threat = -1
          else
            current_highest_threat = m:threat()
          end

          current_worst_injury = m:damage_level()
        end
      elseif view.invisible_monster(x, y) then
        -- We'll consider invisible monsters top priority for now.
        current_highest_threat = 4
        target_x = x
        target_y = y
      end
    end
  end

  if target_x == 0 and target_y == 0 then
    return false
  end

  do_it(dtovi(target_x, target_y))
  return true
end

function shoot()
  return false
end

function wait()
  -- We don't want to be waiting if something can hit us from range.
  if not (archer_inrange())
  and not (reacher_inrange())
  and options.autopick_on then
    do_it("s")
    return true
  end

  return false
end

function charge()
  local m, x, y = reacher_inrange()
  if m and view.can_reach(x, y) then
    do_it(dtovi(towards(x, y)))
    return true
  end

  m, x, y = archer_inrange()
  if m and view.can_reach(x, y) then
    do_it(dtovi(towards(x, y)))
    return true
  end

  m, x, y = shimmer_inrange()
  if m and view.can_reach(x, y) then
    do_it(dtovi(towards(x, y)))
    return true
  end

  return false
end

function emergency()
  -- These three situations are hardcoded to block autoexplore.
  -- "You need to eat something NOW!"
  -- "Calm down first, please."
  -- "No exploration algorithm can help you here."
  -- Because of that we need to solve them in order to keep playing
  -- the game in a sensible fashion.

  local emergency_strategy = {
    emergency_starvation,
    emergency_berserk,
    emergency_labyrinth}

  -- We're not going to actually implement this ever because it's
  -- fucking stupid as hell. The resting segment will rest off
  -- berserking. The relaxing segment will eat. As for labyrinths
  -- I have no fucking clue how you got in a labyrinth lmao.
  -- Still keeping this around as a reminder just in case.
  return false
end

---------------
-- SECTION D --
---------------

local current_turn

-- cb takes action, spending one or more turns.
-- Hopefully this brings us closer to victory!


local cb = coroutine.create(win)

-- hit_closest is run when you press tab.
local first_time = true

function hit_closest()
  if(not first_time) then
    if(coroutine.status(cb) == "dead") then
      cb = coroutine.create(win)
      coroutine.resume(cb)
    end
  else
    coroutine.resume(cb)
    first_time = false
  end
end

-- ready is run when crawl is ready for user input.
function ready()
  current_turn = you.turns()
  if(not first_time and coroutine.status(cb) == "suspended") then
    coroutine.resume(cb)
  end
end

-- choose_stat_gain is run on level ups that cause stat gain.
function choose_stat_gain()
  return prefered_stat
end

local vault_safe = {["moth of wrath"] = true}

function ch_mon_is_safe(m, default_is_safe, moving, dist)
  if you.turns() ~= run_turn then
    run_mode = false
  end

  if(run_mode == true) then
    return true
  end

  -- Melee monsters that can't reach us aren't a threat.
  if not m:has_known_ranged_attack() and not monster_can_charge(m) then
    return true
  end

  return default_is_safe
end

---------------
-- SECTION E --
---------------

function autopickup(item, name)
  local c = item.class(true)

  if item.is_useless then
    return false
  end

  if c == "food" and food.edible(item) then
    return true
  elseif c == "gold" then
    return true
  elseif c == "potion" then
    return true
  elseif c == "scroll" then
    return true
  elseif c == "armour" then
    return false
  elseif c == "jewellery" then
    return true
  elseif c == "wand" then
    return true
  elseif c == "missile" then
    return false
  end

  return false
end
clear_autopickup_funcs()
add_autopickup_func(autopickup)

---------------
-- SECTION F --
---------------

function do_it(command)
  local old_turn = you.turns()
  crawl.process_keys(command)
  -- We yield, waiting for us to be ready to accept input again.
  -- When we're ready again, the current_turn may be different.
  coroutine.yield()
  if(current_turn == old_turn) then
    say("ERROR: The action " .. string.format("%q", command) .. " failed unexpectedly.")
  end
end

function try_it(command)
  local old_turn = you.turns()
  crawl.process_keys(command)
  -- We yield, waiting for us to be ready to accept input again.
  -- When we're ready again, the current_turn may be different.
  coroutine.yield()
  if(current_turn == old_turn) then
    return false
  end
  return true
end

function say(x)
  crawl.mpr(x)
  --crawl.take_note(x)
end

function control(c)
  return string.char(string.byte(c) - string.byte('a') + 1)
end

function initialize_monster_array()
  if not monster_array_init then
    monster_array = {}
    local x
    for x = -LOS, LOS do
      monster_array[x] = {}
    end
    monster_array_init = true
  end
end

function update_monster_array()
  initialize_monster_array()

  local x,y
  for x = -LOS, LOS do
    for y = -LOS, LOS do
      monster_array[x][y] = monster.get_monster_at(x, y)
    end
  end
end

function danger()
  if not options.autopick_on then
    return true
  end

  local danger = false
  for x = -LOS, LOS do
    for y = -LOS, LOS do
      local m = monster_array[x][y]
      if m and not m:is_safe() then
        danger = true
      end
    end
  end

  if (shimmer_inrange()) then
    return true
  end

  return danger
end

function dtovi(x, y)
  local d2v = {[-1] = { [-1] = 'y', [0] = 'k', [1] = 'u'},
               [0]  = { [-1] = 'h',            [1] = 'l'},
               [1]  = { [-1] = 'b', [0] = 'j', [1] = 'n'}}

  if x == 0 and y == 0 then
    say("ERROR: We're trying to stand still when we want to be moving!")
    return string.char(27)
  end

  return d2v[y][x]
end

function inventory()
  return iter.invent_iterator:new(items.inventory())
end

function at_feet()
  return iter.invent_iterator:new(you.floor_items())
end

function have_permafood()
  for item in inventory() do
    if item.class(true) == "food" and
       food.edible(item) and
       not food.ischunk(item) then
      return true
    end
  end
  return false
end

function have_chunk()
  for item in inventory() do
    if item.class(true) == "food" and
       food.edible(item) and
       not food.dangerous(item) and
       food.ischunk(item) then
      return true
    end
  end

  -- Also check the floor.
  for item in at_feet() do
    if item.class(true) == "food" and
       food.edible(item) and
       not food.dangerous(item) and
       food.ischunk(item) then
      return true
    end
  end
  return false
end

function can_eat_chunk()
  if you.hunger() < 4 then
    return true
  elseif you.hunger() < 7 and you.gourmand() then
    return true
  end

  return false
end

function need_to_eat()
  -- Triggers if you're "very hungry" or hungrier.
  if you.hunger() < 3 then
    return true
  end
  return false
end

function whereami()
  local branch
  local level
  branch, level = you.where():match("([a-zA-Z]+):([0-9]+)")
  level = tonumber(level)
  if not level then
    branch = you.where()
    level = 1
  end
  return branch, level
end

function archer_inrange()
  local m
  for x = -LOS, LOS do
    for y = -LOS, LOS do
      m = monster_array[x][y]
      if m then
        if m:has_known_ranged_attack() and not m:is_safe() then
          return m, x, y
        end
      end
    end
  end
end

function reacher_inrange()
  local m
  for x = -max_reach_range, max_reach_range do
    for y = -max_reach_range, max_reach_range do
      m = monster_array[x][y]
      if m then
        if m:reach_range() > 1 and not m:is_safe() then
          return m, x, y
        end
      end
    end
  end
end

function shimmer_inrange()
  for x = -LOS, LOS do
    for y = -LOS, LOS do
      if view.invisible_monster(x, y) then
        return true, x, y
      end
    end
  end

  return false
end


function towards(input_x, input_y)
  local x, y

  if input_x < 0 then x = -1 end
  if input_x == 0 then x = 0 end
  if input_x > 0 then x = 1 end
  if input_y < 0 then y = -1 end
  if input_y == 0 then y = 0 end
  if input_y > 0 then y = 1 end

  if math.abs(input_x) > math.abs(input_y) then
    if not travel.feature_traversable(view.feature_at(x,y)) then
      if travel.feature_traversable(view.feature_at(x,0)) then
        y = 0
      else
        x = 0
      end
    end
  else
    if not travel.feature_traversable(view.feature_at(x,y)) then
      if travel.feature_traversable(view.feature_at(0,y)) then
        x = 0
      else
        y = 0
      end
    end
  end
  return x, y
end

function threat_level()
  local total_threat = 0
  local monster_threat = 0

  local m
  for x = -LOS, LOS do
    for y = -LOS, LOS do
      m = monster_array[x][y]
      if m then
        if m:is_safe() then
          break
        end

        monster_threat = m:threat() * 3
        if monster_threat == 0 then
          monster_threat = 1
        end
        total_threat = total_threat + monster_threat
      end
    end
  end

  hp, mhp = you.hp()
  if hp/mhp < low_hp_percent then
    total_threat = total_threat * 2
  end

  return total_threat
end

-- A monster can charge you if it can move closer to you.
function monster_can_charge(m)
  local x, y = m:pos()

  -- There's always three squares that move them "closer."
  local ax, ay, bx, by, cx, cy

  if math.abs(x) == math.abs(y) then
    ax = x - (x / math.abs(x))
    ay = y - (y / math.abs(y))
    bx = x - (x / math.abs(x))
    by = y
    cx = x
    cy = y - (y / math.abs(y))
  elseif math.abs(x) > math.abs(y) then
    ax = x - (x / math.abs(x))
    ay = y
    bx = x - (x / math.abs(x))
    by = y + 1
    cx = x - (x / math.abs(x))
    cy = y - 1
  else
    ax = x
    ay = y - (y / math.abs(y))
    bx = x + 1
    by = y - (y / math.abs(y))
    cx = x - 1
    cy = y - (y / math.abs(y))
  end

  local feature_a = view.feature_at(ax, ay)
  local feature_b = view.feature_at(bx, by)
  local feature_c = view.feature_at(cx, cy)

  if travel.feature_solid(feature_a)
  and travel.feature_solid(feature_b)
  and travel.feature_solid(feature_c) then
    return false
  end

  return true
end

}