tactics.c

/*
 * Rog-O-Matic
 * Automatically exploring the dungeons of doom.
 *
 * Copyright (C) 2008 by Anthony Molinaro
 * Copyright (C) 1985 by Appel, Jacobson, Hamey, and Mauldin.
 *
 * This file is part of Rog-O-Matic.
 *
 * Rog-O-Matic is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Rog-O-Matic is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Rog-O-Matic.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * tactics.c:
 *
 * This file contains all of the 'medium level intelligence' of Rog-O-Matic.
 */

# include <stdio.h>
# include <ctype.h>
# include <setjmp.h>

# include "modern_curses.h"
# include "types.h"
# include "config.h"
# include "globals.h"
# include "install.h"

/*
 * sanity check on PLUNGE_LVL
 */
# if !defined(PLUNGE_LVL)
#  error "PLUNGE_LVL must be defined - try defining it as 13"
# endif
# if PLUNGE_LVL < 1
#  error "PLUNGE_LVL cannot be < 1 - try a more reasonable value such as 13"
# endif
# if PLUNGE_LVL > 25
#  error "PLUNGE_LVL cannot be > 25 - try a more reasonable value such as 13"
# endif

/* static declarations */

/*
 * waitaround: Hang around here waiting for monsters.
 */

static struct {
  int vertstart,
      vertend,
      vertdelt,
      horstart,
      horend,
      hordelt;
} cb [4] = {
  {   3, R-3,  1,   1, C-2,  1},	/* Top left corner */
  {   3, R-3,  1, C-2,   1, -1},	/* Top right corner */
  { R-3,   3, -1, C-2,   1, -1},	/* Bottom right corner */
  { R-3,   3, -1,   1, C-2,  1}
};  /* Bottom left corner */

static int gc = 0; /* Goal corner from 0..3 */

static int waitaround (void);

/*
 * handlearmor: This routine is called to determine whether we should
 * take off or put on armor.
 *
 * Current strategy:   Wear best armor on levels 1..7 or 19 on or
 *                     if protected or have maintain armor.
 *                     Wear 2nd best armor between levels 13..18.
 *                     Wear best leather armor between levels 8..12
 *                     or 2nd best if no leather armor.   DR UTexas 12/15/83
 *
 * Note that leather armor does not rust.
 */

int
handlearmor (void)
{
  int obj;

  /* Only check when armor status is different */
  if (!newarmor || cursedarmor) return (0);

  /*
   * Pick the armor we want to wear. If we are worried about rust monster
   * we wear the second best armor, but if we wont see any rust monsters,
   * if our armor is too good for a rust monster to hit it, or we have a
   * ring of maintain armor, then we should wear our best armor.  On
   * levels 13-18 we wear our second best no matter what.
   */

  obj = havearmor (1, NOPRINT, ANY);		/* Get best armor */

  if (Level > (version < RV52A ? 8 : 7) && Level < 19 &&
      wearing ("maintain armor") == NONE &&
      willrust (obj) &&
      itemis (obj, KNOWN)) {
    obj = NONE;

    if (Level<13)		obj = havearmor (1, NOPRINT, RUSTPROOF);

    if (Level<13 && obj==NONE)	obj = havearmor (3, NOPRINT, ANY);

    if (obj==NONE)		obj = havearmor (2, NOPRINT, ANY);
  }

  /* If  the new armor is really bad, then don't bother wearing any */
  if (obj != NONE && armorclass (obj) > 9 && itemis (obj, KNOWN))
    { obj = NONE; }

  /* If we are wearing the right armor, then don't bother */
  if (obj == currentarmor)
    { newarmor = false; return (0); }

  /* Debugging */
  dwait (D_PACK, __func__, "obj: %d currentarmor: %d", obj, currentarmor);

  /* Take off the wrong armor */
  if (currentarmor != NONE && takeoff ())
    { return (1); }

  /* Put on the right armor, avoid wearing cursed armor */
  if (obj != NONE)
    { return (wear (obj)); }

  /* If we have no armor, then forget it */
  newarmor = false;
  return (0);
}

/*
 * handleweapon: wield our best weapon. Calls haveweapon.
 *
 *  The current strategy is to wield the best weapon from haveweapon.
 */

int
handleweapon (void)
{
  int obj;

  if ((!newweapon || cursedweapon) && !wielding (thrower)) return (0);

  /* haveweapon (1) returns the index of the best weapon in the pack */
  if ((obj = haveweapon (1, NOPRINT)) == NONE) return (0);

  /* If we are not wielding our best weapon, do so */
  if (obj == currentweapon)	{ newweapon = false; return (0); }
  else if (obj != NONE)		{ return (wield (obj)); }
  else				{ newweapon = false; return (0); }
}

/*
 * quaffpotion: check whether we should quaff a potion, and call
 * quaff if so.  We quaff add strength, restore strength, healing,
 * extra healing, and raise level here.  Potions of seeinvisible
 * are handled in 'fightinvisible'.
 *
 * If we are at or below the exp. level, then experiment with unknown potions.
 */

# define MAXSTR (version < RV52A ? 1900 : 3100)

int
quaffpotion (void)
{
  int obj = NONE, obj2 = NONE;

  /* Take advantage of double haste bug -- assures permanent haste */
  if (!doublehasted && version < RV52A &&
      ((hasted && (obj = havenamed (potion, "haste self")) != NONE) ||
       ((obj = havemult (potion, "haste self", 2)) != NONE)) &&
      quaff (obj))
    return (1);

  /*
   * Can we use a gain strength to our advantage? Or a restore?
   * If we have a Gain Strength, or our strength is very bad,
   * then we quaff a Regain Strength.
   */

  if (Str == Strmax && (obj = havenamed (potion, "gain strength")) != NONE &&
      quaff (obj))
    return (1);

  if ((Str < 700 ||
       (Str != Strmax && (havenamed (potion, "gain strength") != NONE))) &&
      (obj = havenamed (potion, "restore strength")) != NONE &&
      quaff (obj))
    return (1);

  if ((Str < 1600 || Level > 12) &&
      (obj = havemult (potion, "restore strength", 2)) != NONE &&
      quaff (obj))
    return (1);

  /* Try to get unblinded by quaffing a potion */
  if (blinded &&
      ((obj = havenamed (potion, "healing")) != NONE ||
       (obj = havenamed (potion, "extra healing")) != NONE ||
       (obj = havenamed (potion, "see invisible")) != NONE) &&
      quaff (obj))
    return (1);

  /* Try to get uncosmic by quaffing a potion */
  if (cosmic &&
      (obj = havenamed(potion, "extra healing")) != NONE &&
      quaff (obj))
    return (1);

  if (cosmic && Str != Strmax &&
      (obj = havenamed (potion, "poison")) != NONE) {
    if ((wearing ("sustain strength") != NONE && quaff (obj)) ||
        findring ("sustain strength"))
      return (1);
  }

  /*
   * Quaff healing to raise our MaxHp
   * Wait for cosmic known to quaff extra healing. DR,TG  UTexas
   */

  if ((Hp == Hpmax) &&
      ((obj = havemult (potion, "healing", 2)) != NONE ||
       (obj = havemult (potion, "extra healing", 2)) != NONE ||
       (know ("blindness") && ((obj = havenamed (potion, "healing")) != NONE)) ||
       (know ("blindness") && (know ("hallucination") || version < RV53A)  &&
       Level < 15 && ((obj = havenamed (potion, "extra healing")) != NONE))) &&
      quaff (obj))
    return (1);

  /*
   * Quaff a raise level potion?
   */

  if ((Explev > 8 || Level > 13) &&
      (obj = havenamed (potion, "raise level")) != NONE &&
      quaff (obj))
    return (1);

  /* Quaff an unknown potion? */
  if ((Level >= (k_exper/10) || objcount >= maxobj || Str<1000 || blinded) &&
      (obj = unknown (potion)) != NONE) {
    if ((obj2 = wearing ("add strength")) != NONE && removering (obj2))
      return (1);
    else if (wearing ("sustain strength") == NONE &&
             (obj2 = havenamed (ring, "sustain strength")) != NONE &&
             puton (obj2))
      return (1);
    else if (quaff (obj))
      return (1);
  }

  return (0);
}

/*
 * readscroll: check whether we should read a scroll, and call reads
 * to actually read it.
 *
 * Scrolls of identify, remove curse, genocide, enchant weapon,
 * enchant armor, magic mapping are defined.  Scrolls of scare
 * monster and confuse monster are handled in 'battlestations'.
 *
 * If we are at or below (k_exper/10), experiment with unknown scrolls.
 * Make certain that we are wearing our best armor when reading
 * enchant armor or an unknown scroll (which could be enchant
 * armor).
 */

int
readscroll (void)
{
  int obj, obj2;

  /* Check the item specific identify scrolls first */
  if ((((obj = havenamed (Scroll, "identify scroll")) != NONE) && (obj2 = unknown (Scroll)) != NONE) ||
      (((obj = havenamed (Scroll, "identify armor")) != NONE) && (obj2 = unknown (armor)) != NONE) ||
      (((obj = havenamed (Scroll, "identify weapon")) != NONE) && (obj2 = unknown (hitter)) != NONE) ||
      (((obj = havenamed (Scroll, "identify potion")) != NONE) && (obj2 = unknown (potion)) != NONE) ||
      ((obj = havenamed (Scroll, "identify ring, wand or staff")) != NONE &&
       ((obj2 = unknown (ring)) != NONE || (obj2 = unknown (wand)) != NONE))) {
    prepareident (obj2, obj);
    return (reads (obj));
  }

  /* In older version, have multiple uses for generic identify scrolls */
  if ((obj = havenamed (Scroll, "identify")) != NONE &&
      (currentweapon != NONE) &&
      (!itemis (currentweapon, KNOWN) &&
       (!usingarrow || goodarrow > R-4))) {
    prepareident (currentweapon, obj);
    return (reads (obj));
  }

  if ((obj = havenamed (Scroll, "identify")) != NONE &&
      ((obj2 = unknown (ring)) != NONE ||
       (obj2 = unidentified (wand)) != NONE ||
       (obj2 = unidentified (Scroll)) != NONE ||
       (Level > 10 && (obj2 = unknown (wand)) != NONE) ||
       ((cheat || version == RV36A) &&
        ((obj2 = unknown (potion)) != NONE ||
         (obj2 = haveother (Scroll, obj)) != NONE)))) {
    prepareident (obj2, obj);
    return (reads (obj));
  }

  if ((cursedarmor || cursedweapon) &&
      (obj = havenamed (Scroll, "remove curse")) != NONE)
    return (reads (obj));

  if ((obj = havenamed (Scroll, "genocide")) != NONE)
    return (reads (obj));

  if (currentweapon != NONE &&
      (goodweapon || usingarrow || MaxLevel > 12) &&
      (obj = havenamed (Scroll, "enchant weapon")) != NONE)
    return (reads (obj));

  if (Level != didreadmap && Level > 12 &&
      (obj = havenamed (Scroll, "magic mapping")) != NONE)
    return (reads (obj));

  /* About to read an unknown scroll. We will assure that we have */
  /* a weapon in hand, and put on our best armor for the occasion */
  /* We must also prepare to identify something, just in case.    */

  if ((obj = havenamed (Scroll, "enchant armor")) != NONE ||
      (obj = havenamed (Scroll, "protect armor")) != NONE ||
      ((currentweapon != NONE) &&
       (Level >= (k_exper/10) || objcount >= maxobj ||
        cursedarmor || cursedweapon) &&
       (exploredlevel || Level > 18 || know ("aggravate monsters")) &&
       (obj = unknown (Scroll)) != NONE)) {
    prepareident (pickident (), obj);

    /* Go to a corner to read the scroll */
    if (version <= RV36B && !know ("create monster") && gotocorner ())
      return (1);

    /* Must put on our good armor first */
    if (!cursedarmor &&
        (!know("enchant armor") || stlmatch(inven[obj].str, "enchant armor") ||
         !know("protect armor") || stlmatch(inven[obj].str, "protect armor"))) {
      int obj2 = havearmor (1, NOPRINT, ANY); /* Pick our best armor */

      if (obj2 == currentarmor);

      /* Take off the bad stuff */
      else if (currentarmor != NONE && takeoff ()) return (1);

      /* Put on the good stuff */
      else if (obj2 != NONE && wear (obj2)) return (1);
    }

    /* No armor handling, so read the scroll */
    return (reads (obj));
  }

  return (0);
}

/*
 * handlering: check whether we should put on a ring, and call
 * puton to wear it.  Calls 'havering' to find the two best rings
 * and wears them if their evaluations are greater than 1000.
 *
 * 'havering' understands about when different rings are good, and how
 * much food we need to use each ring.
 */

int
handlering (void)
{
  int ring1, ring2;

  if (!newring && !beingstalked) return (0);

  ring1 = havering (1, NOPRINT);
  ring2 = havering (2, NOPRINT);

  dwait (D_PACK, __func__, "ring1: %d ring2: %d left: %d right: %d",
         ring1, ring2, leftring, rightring);

  if ((leftring == ring1 && rightring == ring2) ||
      (rightring == ring1 && leftring == ring2)) {
    newring = false; return (0);
  }

  if (leftring != NONE && leftring != ring1 && leftring != ring2 &&
      removering (leftring)) {
    return (1);
  }

  if (rightring != NONE && rightring != ring1 && rightring != ring2 &&
      removering (rightring)) {
    return (1);
  }

  if (ring1 != leftring && ring1 != rightring && puton (ring1)) {
    return (1);
  }

  if (ring2 != leftring && ring2 != rightring && puton (ring2)) {
    return (1);
  }

  return (0);
}

/*
 * findring: called with the named of a ring, attempts to locate such
 * a ring in the pack and wear it. It will remove rings (other than
 * maintain armor) to accomplish this task if it we are wearing two
 * rings.
 *
 * Could be extended to have an ordering of rings to wear.
 */

int
findring (char *name)
{
  int obj;

  if ((obj = havenamed (ring, name)) == NONE ||
      wearing (name) != NONE)
    return (0);

  if (leftring != NONE && rightring != NONE) {
    if (stlmatch (inven[leftring].str, "maintain armor"))
      return (removering (rightring));
    else
      return (removering (leftring));
  }

  return (puton (obj));
}

/*
 * grope: get to a safe square and sit and vibrate (move back and forth)
 * and then sleep for 'turns' turns.
 *
 * Problem: We need to know which side of us the monster is on. Then
 * we could zap him with wands or staves.  This requires some kind of
 * memory and the ability to detect when the motion command (ie 'hit'
 * fails to move us).		MLM
 */

int
grope (int turns)
{
  int k, moves;

  if (atrow < 2 || atcol < 1) {
    command (T_GROPING, "%ds", (turns > 0) ? turns : 1);
    return (1);
  }

  /* Count adjacent CANGO squares */
  for (k=0, moves=0; k<8; k++)
    if (onrc(CANGO, atdrow(k), atdcol(k))) moves++;

  if (moves > 2 && findsafe ()) /* find a spot with 2 or fewer moves */
    return (1);

  /* blindir is direction of adjacent CANGO square which is not a trap */
  for (k=0; k<4; k++, blindir = (blindir+2) % 8)
    if ((onrc(CANGO|TRAP, atdrow(blindir), atdcol(blindir)) == CANGO))
      break;

  if (turns) command (T_GROPING, "%c%c%ds", keydir[blindir],
                        keydir[(blindir+4)&7], turns);
  else       command (T_GROPING, "%c%c", keydir[blindir],
                        keydir[(blindir+4)&7]);

  blindir = (blindir+2) % 8;
  return (1);
}

/*
 * findarrow: This function tries to run over an arrow trap to get a
 *            magic arrow. Make certain we have some food.
 */

int
findarrow (void)
{
  /* If wrong version, not cheating or must go find food, then forget it */
  if (version > RV36B || !cheat || hungry())
    return (0);

  else if (!usingarrow && foundarrowtrap && !on (ARROW) &&
           gotowards (trapr, trapc, 0))
    { display ("Trying for arrow..."); return (1); }

  return (0);
}

/*
 * checkcango: verify that a missile fired in direction 'dir' will
 *             travel 'turns' turns.
 *
 * Modified by mlm, 5/31/83: Return false if a monster is in the way.
 * only return true if the missile will travel EXACTLY the distance
 * specified.  Also changed it to not check the current square (since
 * we can fire from a door, even if we cant shoot through one).
 */

int
checkcango (int dir, int turns)
{
  int r, c, dr, dc;

  for (dr = deltr[dir], dc = deltc[dir], r=atrow+dr, c=atcol+dc;
       turns > 0 && onrc (CANGO | DOOR, r, c) == CANGO;
       r+=dr, c+=dc, turns--)
    ;

  return (turns==0);
}

/*
 * godownstairs: issues a down command and check for the halftimeshow.
 */

/* running - True ==> don't do anything fancy */
int
godownstairs (int running)
{
  int p;

  /* We don't want to go down if we have just gotten an arrow, since */
  /* It is probably bad, and we will want to go back to the trap;   */
  /* Don't go down until we have killed five monsters in one blow.   */
  /* While waiting, run back and forth to look for monsters.        */

  if (cheat && version <= RV36B && !running &&
      foundarrowtrap && usingarrow &&
      have (food) != NONE && goodarrow < 5 && waitaround ()) {
    saynow ("Checking out arrow...");
    return (1);
  }

  /* Check for applicability of this rule */
  if (! new_stairs) return (0);

  /* If we are on the stairs, perhaps we should rest up some */
  p = between ((Explev+larder)*10, 60, 100);

  if (atrow == stairrow && atcol == staircol &&
      !running && larder > 0 && Hp < max (10, percent (Hpmax, p))) {
    command (T_RESTING, "s");
    display ("Resting on stairs before next level");
    return (1);
  }

  /* Allow other rules a chance to notice that we are done with the level */
  if (on (STAIRS) && !exploredlevel)
    { exploredlevel = true; return (1); }

  /* If we are floating, we cant go down, either rest or fail */
  if (floating && running)
    { saynow ("Cannot escape, floating in mid-air!"); return (0); }
  else if (floating) {
    saynow ("Floating above stairs...");
    command (T_RESTING, "s"); return (1);
  }

  /* If we are on the stairs, go down */
  if (on (STAIRS)) {
    halftimeshow (Level);

    /* Send the DOWN command and return */
    command (T_MOVING, ">");
    return (1);
  }

  /* If we are running and can run to the next level, do that */
  if (running && makemove (RUNDOWN, genericinit, downvalue, REEVAL)) {
    return (1);
  }

  /* If we see the stairs or a trap door, go there */
  if (!running && makemove (DOWNMOVE, genericinit, downvalue, REUSE)) {
    goalr = targetrow; goalc = targetcol;   /* Set a goal (CPU time hack) */
    return (1);
  }

  new_stairs = false;
  return (0);
}

/*
 * plunge: Should we head down immediately?
 *
 * If we are being teleported too much or
 *    we are on a bad level (PLUNGE_LVL to 25) or
 *    we want to get past Aquators (level 19) or
 *    we have aggravated all of the monsters then
 *
 * we head down immediately.
 */

int
plunge (void)
{
  /* Check for applicability of this rule */
  if (stairrow == NONE && !foundtrapdoor) return (0);

  if (have (amulet) != NONE) return (0);

  if (teleported > (larder+1)*5 && godownstairs (NOTRUNNING)) {
    if (!on (STAIRS)) saynow ("Giving up on level, too much teleporting");

    return (1);
  }

  if (Level >= PLUNGE_LVL && Level < 26 && godownstairs (NOTRUNNING)) {
    if (!on (STAIRS)) saynow ("Plunge mode!!!");

    return (1);
  }

  if (aggravated && godownstairs (NOTRUNNING)) {
    if (!on (STAIRS)) saynow ("Running from aggravated monsters");

    return (1);
  }

  if (haveexplored (9) && godownstairs (NOTRUNNING)) {
    if (!on (STAIRS)) saynow ("Level explored");

    return (1);
  }

  return (0);
}

/*
 * waitaround: For some reason we want to stay on this level for a while.
 * Try running to each corner of the level.
 */

static int
waitaround (void)
{
  int i, j;

  if (gotowardsgoal ()) return (1);

  ++gc;
  gc = gc % 4;

  for (i = cb[gc].vertstart; i != cb[gc].vertend; i += cb[gc].vertdelt)
    for (j = cb[gc].horstart; j != cb[gc].horend; j += cb[gc].hordelt)
      if (onrc (BEEN | CANGO | ROOM, i, j) &&
          !onrc (TRAP, i, j) && gotowards (i, j, 0))
        { goalr = i; goalc = j; return (1); }

  return (0);
}

/*
 * goupstairs:
 *
 *      If we have the amulet, and our score is good enough, then
 *      go up stairs. This function also checks for the end of the
 *      game, and issues the proper calls to get the score written.
 */

int
goupstairs (int running)
{
  int obj;

  /* Check for applicability of this rule */
  if (stairrow == NONE || have(amulet) == NONE || !running)
    return (0);

  /* If we are on the stairs, then check for win, else go up */
  if (atrow == stairrow && atcol == staircol) {
    /* If we are about to win, dump any magic arrows or minus things */
    if (Level == 1 &&
        ((obj = havearrow ()) != NONE || (obj = haveminus ()) != NONE) &&
        throw (obj, 0))
      { return (1); }

    /* No magic arrows, time to leave */
    else if (Level == 1) {
      /* Send an up command and a space to clear the 'You Made It' */
      sendnow ("< ");

      /* Now read chars until we have the end of the inventory. */
      /* Note misspelling in Rogue 'Peices', so don't assume anything */
      waitfor ("Gold P");

      /* Note that quitrogue sends a '\n' to get the score */
      quitrogue ("total winner", Gold, 0);

      /*
       * record the final state to the end of the level log
       */
      levellog_append ("total winner");
      return (1);
    }

    /* Not at the top yet, keep on trucking */
    else
      { command (T_MOVING, "<"); return (1); }
  }

  /* If we know where the stairs are, go there */
  else if ((goalr = stairrow) > 0 && (goalc = staircol) > 0 &&
           gotowards (goalr, goalc, running))
    return (1);

  return (0);
}

/*
 * restup: If we are low on hit points, sit for a while. Since handlering
 * was called first, we will be wearing a ring of regeneration if need be.
 *
 * First we find a good place to rest (we will move into a room, but not
 * out of one).  In lit rooms, stand far from doors so we can shoot
 * arrows at things coming in.  In dark rooms, stand diagonally away
 * from doors (so we get a one turn warning of monsters coming in that
 * door).  In either case, stand on stairs or next to trap doors and
 * teleport traps).
 *
 * Then rest by searching 's'.  If one blow would not kill us, and we
 * don't plan to shoot arrows, then rest up so as to heal one hit point.
 * If we are critically low, rest up one turn at a time.
 *
 * Other considerations:	Don't move if confused or cosmic.
 *				Drink healing potions if really low.
 *				Don't rest when hungry (and no food)
 */

int
restup (void)
{
  int obj, turns;

  /* If we are confused, sit still so we don't bump into anything bad */
  if (confused) { command (T_RESTING, "s"); return (1); }

  /* If cosmic and plenty of hit points and food, rest for long periods */
  if (cosmic && (Hp >= percent (Hpmax, 80)) && larder > 2) {
    display ("Oh wow man, I'm contemplating my navel!");
    command (T_RESTING, "100s"); return (1);
  }

  /* If we are well, return */
  if (Hp >= max (8, percent (Hpmax, between (Explev*10+k_rest-50, 40, 80))))
    { unrest ();  return (0); }

  /*
   * If we are really ill then try a healing potion (save a healing
   * potion for blindness, extra healing for hallucination).
   */

  if (Hp < Level+10 && Hp < Hpmax/3 &&
      ((obj = havemult (potion, "extra healing", 2)) != NONE ||
       (obj = havemult (potion, "healing", 2)) != NONE ||
       (know ("hallucination") &&
        (obj = havenamed (potion, "extra healing")) != NONE) ||
       (know ("blindness") &&
        (obj = havenamed (potion, "healing")) != NONE)) &&
      quaff (obj))
    { return (1); }

  /* Don't rest when we havent enough to eat */
  if (hungry ()) return (0);

  display ("Resting up...");

  /*
   * Look for a good place to rest
   */

  if (movetorest ()) return (1);

  /*
   * If we are very ill, or we are very deep, or we are in a lit room
   * and can shoot at things as they come ate us, rest only one turn so
   * monsters don't get the first shot. Otherwise rest enough turns
   * to heal one step.
   */

  turns = (Level < 8) ? (20-Explev*2) : 3;

  if ((!darkroom () && ammo) || Hp < Level*2+8 || Level > 15) turns = 1;

  command (T_RESTING, "%ds", turns);
  return (1);
}

/*
 * If goalr and goalc are set (not -1,-1) then attempt to move towards
 * that square. Calls gotowards which calls bfsearch.
 */

int
gotowardsgoal (void)
{
  if (goalr > 0 && goalc > 0) { /* Keep on trucking */
    if (goalr == atrow && goalc == atcol) { goalr = NONE; goalc = NONE; }
    else if (gotowards (goalr, goalc, 0)) { return (1); }
    else                                  { goalr = NONE; goalc = NONE; }
  }

  return (0);
}

/*
 * gotocorner:	Find a corner using downright and try to go there.
 *		This is done so we can destroy old wands by throwing
 *		them into the corner (which destroys them).
 */

int
gotocorner (void)
{
  int r, c;

  if (!downright (&r, &c)) return (0);

  if (debug (D_SCREEN))
    { saynow ("Gotocorner called:"); mvaddch (r, c, 'T'); at (row, col); }

  if (gotowards (r, c, 0)) { goalr=r; goalc=c; return (1); }

  return (0);
}

/*
 * lightroom: Try to light up the room if we are below level 17.
 */

int
light (void)
{
  if (Level < 17) return (0);

  return (lightroom ());
}

/*
 * shootindark: If we are arching at an old monster, fire another arrow.
 */

int
shootindark (void)
{
  int obj, bow;

  /* If no longer arching in the dark, fail */
  if (darkturns < 1 || darkdir == NONE || !darkroom ()) return (0);

  darkturns--;			/* Count off turns till he reaches us */

  /* If he is one turn away, switch back to our sword */
  if (!cursedweapon && wielding (thrower) && darkturns==0 && handleweapon ())
    { dwait (D_BATTLE, __func__, "Switching to 4th sword"); return (1); }

  /* If we have room, switch to our bow */
  if (!cursedweapon && !wielding (thrower) && darkturns > 3 &&
      (bow = havebow (1, NOPRINT)) != NONE && wield (bow))
    return (1);

  /* Fail if we have run out of arrows */
  if ((obj = havemissile ()) == NONE) return (0);

  /* Throw the arrow in the arching direction */
  return (throw (obj, darkdir));
}

/*
 * dinnertime: Eat if we are hungry or if we have a surplus of food.
 */

int
dinnertime (void)
{
  if ((havefood (5) && objcount == maxobj && ! droppedscare) ||
      (larder > 0 && hungry ()))
    { return (eat ()); }

  return (0);
}

/*
 * trywand: Zap a blank wall with an unknown and unused wand in an attempt
 * to generate a message which identifies the wand.
 */

int
trywand (void)
{
  int obj, dir, r, c, count;

  /* If we aren't in a room, if there are monsters around,  */
  /* or we are in the dark, then we can't try this strategy */
  if (!on (ROOM) || mlistlen || darkroom ()) return (0);

  /* Have we a wand to identify? */
  if (((obj = unknown (wand)) == NONE) || (itemis (obj, WORTHLESS)))
    return (0);
  else if (used (inven[obj].str))
    return (0);

  /* Look for a wall either 3 or 4 away */
  for (dir = 0; dir < 8; dir += 2) {
    for (count = 0, r=atrow, c=atcol;
         onrc (CANGO | DOOR, r, c) == CANGO;
         r += deltr[dir], c += deltc[dir])
      count++;

    if (count == 4 || count == 5) break;	/* Found a likely wall */
  }

  /* If we couldnt find room, then fail */
  if (dir > 7) return (0);

  /* point the wand */
  return (point (obj, dir));
}

/*
 * eat: If we have food, eat it.
 */

int
eat (void)
{
  int obj;

  if ((obj = have (food)) != NONE) {
    command (T_HANDLING, "e%c", LETTER (obj));
    return (1);
  }

  return (0);
}