strategy.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/>.
 */

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

# include <stdio.h>
# include <ctype.h>
# include <string.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

/*
 * foughtmonster records whether we engaged in battle recently.  This
 * information is used to tell whether we should sit still, waiting for a
 * confused monster to come back, or to go on about our business.
 * DIDFIGHT is the number of turns to sit still after a battle.
 */

# define DIDFIGHT 3

/* static declarations */

static int callitpending (void);
static int fightmonster (void);
static int tomonster (void);
static int wanttowake(char c);
static int aftermelee (void);
static int battlestations (int m, char *monster, int mbad, int danger, int mdir, int mdist, int alert, int adj);
static int tostuff (void);
static int fightinvisible (void);
static int archery (void);
static int pickupafter (void);
static int dropjunk (void);

/*
 * strategize: Run through each rule until something fires. Return 1 if an
 * action was taken, otherwise return 0 (and then play will read a command
 * from the user).
 */

int
strategize (void)
{
  dwait (D_CONTROL, __func__, "Strategizing");

  /* If replaying, instead of making an action, return the old one */
  if (replaying) return (replaycommand ());

  /* Clear any messages we printed last turn */
  if (msgonscreen) { at (0,0); clrtoeol (); msgonscreen = false; at (row,col); }


  /* ----------------------- Production Rules --------------------------- */


  if (callitpending ())         /* We have this to do */
    return (1);

  if (fightmonster ())          /* We are under attack! */
    return (1);

  if (fightinvisible ())        /* Claude Raines! */
    return (1);

  if (tomonster ())             /* Go play with the pretty monster */
    return (1);

  if (shootindark ())           /* Shoot arrows in dark rooms */
    return (1);

  if (handleweapon ())		/* Play with the nice sword */
    { dwait (D_BATTLE, __func__, "Switching to 1st sword"); return (1); }

  if (light ())			/* Fiat lux! Especially if we lost */
    return (1);			/* a monster from view.		   */

  if (dinnertime ())            /* Soups on! */
    return (1);

  /*
   * These variables are short term memory.  Slowed and
   * cancelled are fuses which are disabled after a small
   * number of turns.
   */

  lyinginwait = false;			/* No more monsters to wait for */

  if (foughtmonster) foughtmonster--;	/* Turns since fought monster */

  if (slowed) slowed--;		        /* Turns since we slowed a monster */

  if (cancelled) cancelled--;		/* Turns since we zapped 'cancel' */

  if (beingheld) beingheld--;		/* Turns since held by a fungus */

  /* ---- End of short term memory modification ---- */

  if (goupstairs (NOTRUNNING))	/* Up we go! Make sure that we get */
    return (1);			  /* a better rank on the board. */

  if (dropjunk ())		/* Send it back */
    return (1);

  if (readscroll ())		/* Get out the reading glasses */
    return (1);			  /* Must come before handlearmor() */

  if (handlearmor ())		/* Play dressup */
    return (1);

  if (quaffpotion ())		/* Glug glug glug ... */
    return (1);			  /* Must come before handlering() */

  if (handlering ())		/* We are engaged! */
    return (1);

  if (blinded && grope (50))	/* Who turned out the lights */
    { display ("Blinded, groping..."); return (1); }

  if (aftermelee ())		/* Wait for lingering monsters */
    return (1);

  if (tostuff ())		/* Pick up the play pretty */
    return (1);

  if (restup ())		/* Yawn! */
    return (1);

  if (trywand ())		/* Try to use a wand */
    return (1);

  if (gotowardsgoal ())		/* Keep on trucking */
    return (1);

  if (exploreroom ())		/* Search the room */
    return (1);

  if (archery ())		/* Try to position for fight */
    return (1);

  if (pickupafter ())		/* Look for stuff dropped by arched mon */
    return (1);

  if (plunge ())		/* Plunge mode */
    return (1);

  if (findarrow ())		/* Do we have an uninitialized arrow? */
    return (1);

  if (findroom ())		/* Look for another room */
    return (1);

  /*
   * 'attempt' records the number of times we have completely searched
   * this level for secret doors.  If attempt is greater than 0, then we
   * have failed once to find the stairs and go down.  If this happens
   * three times, there could be a monster sleeping on the stairs.  We set
   * the SLEEPER bit for each square with a sleeping monster.  Go find
   * such a monster and kill it to see whether (s)he was on the stairs).
   */

  if (attempt > 4 && makemove (ATTACKSLEEP, genericinit, sleepvalue, REUSE)) {
    display ("No stairs, attacking sleeping monster...");
    return (1);
  }

  if (Level>1 && larder>0 && doorexplore ())	/* Grub around */
    return (1);

  if (godownstairs (NOTRUNNING))		/* Down we go! */
    return (1);

  if ((Level<2 || larder<1) && doorexplore())   /* Grub around anyway */
    return (1);

  /*
   * If we think we are on the stairs, but arent, maybe they were moved
   * (ie we were hallucinating when we saw them last time).
   */

  if (on (STAIRS) && (atrow != stairrow || atcol != staircol))
    { dwait (D_ERROR, __func__, "Stairs moved"); findstairs (NONE, NONE); return (1); }

  /*
   * If we failed to find the stairs, explore each possible secret door
   * another ten times.
   */

  while (attempt++ < MAXATTEMPTS) {
    timestosearch += max (3, k_door / 5);
    foundnew ();

    if (doorexplore ()) return (1);
  }

  /*
   * Don't give up, start all over!
   */

  newlevel ();
  display ("I would give up, but I am too stubborn, starting over...");
  return (grope (10));
}

/*
 * callitpending : When going through the inventory we found this to
 *                 do, but we wanted to wait until we were no longer
 *                 in the middle of something else to tag this item
 *                 with this name.
 */

static int
callitpending (void)
{

  if (pending_call_letter != ' ') {
    command (T_OTHER, "c%c%s\n", pending_call_letter, pending_call_name);
    pending_call_letter = ' ';
    memset (pending_call_name, '\0', sizeof(pending_call_name));
    return (1);
  }
  return (0);
}

/*
 * fightmonster: looks for adjacent monsters. If found, it calls
 * battlestations to prepare for battle otherwise hacks with the
 * weapon already in hand.
 */

static int
fightmonster (void)
{
  int i, rr, cc, mdir = NONE, mbad  = NONE, danger = 0;
  int  melee = 0, adjacent = 0, alertmonster = 0;
  int  wanddir = NONE, m = NONE, howmean;
  char mon, monc = ':', *monster;

  /* Check for adjacent monsters */
  for (i = 0; i < mlistlen; i++) {
    rr = mlist[i].mrow; cc = mlist[i].mcol;

    if (max (abs (atrow-rr), abs (atcol-cc)) == 1) {
      if (mlist[i].q != ASLEEP) {
        if (mlist[i].q != HELD || Hp >= Hpmax || !havefood (1)) {
          melee = 1;

          if (mlist[i].q == AWAKE) alertmonster = 1;
        }
      }
    }
  }

  if (!melee || monc == ':') return (0);               /* No one to fight */

  /* Loop to find worst monster and tally danger & number adjacent */
  for (i = 0; i < mlistlen; i++) {
    rr = mlist[i].mrow; cc = mlist[i].mcol;	/* Monster position */

    /*
     * If the monster is adjacent and is either awake or
     * we don't know yet whether he is asleep, but we havent
     * see any alert monsters yet.
     */

    if (max (abs (atrow-rr), abs (atcol-cc)) == 1 &&
        (alertmonster ? mlist[i].q == AWAKE :
         mlist[i].q != ASLEEP)) { /* DR Utexas 26 Jan 84 */
      mon = mlist[i].chr;		/* Record the monster type */
      monster = monname (mon);		/* Record the monster name */
      danger += maxhitchar(mon);	/* Add to the danger */

      /* If he is adjacent, add to the adj count */
      if (onrc (CANGO, rr, atcol) && onrc (CANGO, atrow, cc)) {
        adjacent++; howmean = isholder (monster) ? 10000 : avghit(i);

        /* If he is adjacent and the worst monster yet, save him */
        if (howmean > mbad) {
          wanddir = mdir = direc (rr-atrow, cc-atcol);
          monc = mon; m = i; mbad = howmean;
        }

      /* If we haven't yet a line of sight, check this guy out */
      } else if (wanddir == NONE) {
	wanddir = direc (rr-atrow, cc-atcol);
      }

      /* Debugging breakpoint */
      if (valrc (rr,cc)) {
	dwait (D_BATTLE, __func__, "%c: (%d,%d) danger: %d worst %c: (%d,%d) total: %d",
	       screen[rr][cc], rr-atrow, cc-atcol,
	       danger, monc, mdir, mbad, adjacent);
      }
    }
  }

  /*
   * The following variables have now been set:
   *
   * monc:      The letter of the worst monster we can hit
   * mbad:      Relative scale 0 to 26, how bad is (s)he
   * mdir:      Which direction to him/her
   * danger:    How many hit points can (s)he/they do this round?
   * wanddir:   Direction of worst monster, even if we cant move to it.
   */

  /*
   * Check whether the battlestations expert has a suggested action.
   */

  monster = monname (monc);

  if (battlestations (m, monster, mbad, danger, adjacent ? mdir : wanddir,
                      adjacent ? 1 : 2, alertmonster, max (1, adjacent)))
    { foughtmonster = DIDFIGHT; return (1); }

  /*
   * If we did not wait for him last turn, and he is not adjacent,
   * let him move to us (otherwise, he gets to hits us first).
   */

  if (!lyinginwait && !adjacent) {
    command (T_FIGHTING, "s");
    dwait (D_BATTLE, __func__, "Lying in wait");
    lyinginwait = true;
    foughtmonster = DIDFIGHT;
    return (1);
  }

  /* If we are here but have no direction, there was a bug somewhere */
  if (mdir < 0) {
    dwait (D_BATTLE, __func__, "Adjacent, but no direction known");
    return (0);
  }

  /* If we could die this round, tell the user about it */
  if (danger >= Hp) display ("In trouble...");

  /* Well, nothing better than to hit the beast! Tell dwait about it */
  dwait (D_BATTLE, __func__, "Attacking %s: %d direction: %d total danger: %d",
         monster, mbad, mdir, danger);

  /* Record the monster type */
  lastmonster = monc-'A'+1;

  /* Move towards the monster (this causes us to hit him) */
  rmove (1, mdir, T_FIGHTING);
  lyinginwait = false;
  foughtmonster = DIDFIGHT;
  return (1);
}

/*
 * tomonster: if we can see a monster (and either it is awake or we
 * think we can beat it) then pick the worst one, call battlestations,
 * and then call gotowards to move toward the monster. If the monster
 * is an odd number of turns away, sit once to assure initiative before
 * charging after him. Special case for sitting on a door.
 */

static int
tomonster (void)
{
  int i, dist, rr, cc, mdir = NONE, mbad = NONE;
  int   closest, which, danger = 0, adj = 0, alert = 0;
  char  monc = ':', monchar = ':', *monster;

  /* If no monsters, fail */
  if (mlistlen==0)
    return (0);

  /*
   * Loop through the monsters, 'which' and 'closest' record the index
   * and distance of the closest monster worth fighting.
   */

  for (i = 0, which = NONE, closest = 999; i < mlistlen; i++) {
    dist = max (abs (mlist[i].mrow - atrow), abs (mlist[i].mcol - atcol));
    monchar = mlist[i].chr;

    /*
     * IF   we are not using a magic arrow OR
     *      we want to wake this monster up AND we can beat him OR
     *      he is standing near something we want and we will have to
     *        fight him anywhay
     * THEN consider fighting the monster.
     *
     * Don't pick fights with sleepers if cosmic.  DR UTexas 25 Jan 84
     */

    if (usingarrow || mlist[i].q == AWAKE ||
        (!cosmic && wanttowake (monchar) &&
         (avghit (i) <= 50 || (maxhit (i) + 50 - k_wake) < Hp)) ||
        (mlist[i].q == HELD && Hp >= Hpmax)) {
      danger += maxhit(i);		/* track total danger */
      adj++;				/* count number of monsters */

      /* If he is the closest monster, save his index and distance */
      if (dist < closest) {
	closest = dist; which = i; monc = mlist[i].chr; mbad = avghit(i);

      /* Or if he is meaner than another equally close monster, save him */
      } else if (dist == closest && avghit(i) > avghit(which)) {
        dwait (D_BATTLE, __func__, "Chasing %c: %d rather than %c: %d at distance: %d",
               mlist[i].chr, avghit(i), mlist[which].chr,
               avghit(which), dist);

        closest = dist; which = i; monc = mlist[i].chr; mbad = avghit(i);
      }
    }
  }

  /* No monsters worth bothering, return failure */
  if (which < 0) return (0);

  /* Save the monsters location in registers */
  rr = mlist[which].mrow - atrow; cc = mlist[which].mcol - atcol;

  /* If the monster is on an exact diagonal, record direction */
  mdir = (rr==0 || cc==0 || abs(rr)==abs(cc)) ? direc (rr, cc) : -1;

  /* Get a string which names the monster */
  monster = monname (monc);

  /* Is the monster alert */
  alert = (mlist[which].q == AWAKE) ? 1 : 0;

  /* If 'battlestations' has an action, use that action */
  if (battlestations (which, monster, mbad, danger, mdir, closest, alert, adj))
    return (1);

  /* If he is an odd number of squares away, lie in wait for him */
  if ((closest&1) == 0 && !lyinginwait) {
    command (T_FIGHTING, "s");
    dwait (D_BATTLE, __func__, "Waiting for monster an odd number of squares away");
    lyinginwait = true;
    return (1);
  }

  /* "We have him! Move toward him!" */
  if (gotowards (mlist[which].mrow, mlist[which].mcol, 0)) {
    goalr = mlist[which].mrow; goalc = mlist[which].mcol;
    lyinginwait = false;
    return (1);
  }

  /* Could not find a path to the monster, record failure */
  return (0);
}

/*
 * wanttowake is true for monsters without special attacks, such that the
 * expected damage from hits is a reasonable estimate of their vorpalness.
 * Some monsters are included here because we want to shoot arrows at them.
 */

static int
wanttowake(char c)
{
  char *monster = monname (c);

  if (missedstairs)
    return (1);

  /*
   * If monster sleeping but won't wake up when we move around him,
   * return wanttowake as false.   DR UTexas 09 Jan 84
   */

  if (streq (monster, "centaur") ||
      streq (monster, "dragon") ||
      streq (monster, "floating eye") ||
      streq (monster, "ice monster") ||
      streq (monster, "leprechaun") ||
      streq (monster, "nymph") ||
      streq (monster, "wraith") ||
      streq (monster, "jabberwock") ||
      streq (monster, "purple worm") )
    return (0);

  return (1);
}

/*
 * aftermelee:	called when we have just fought a monster, assures
 *		that it wasn't just a confused monster that backed
 *		away and might get a hit on us if we move. Now only
 *		used when we lost a monster from view.
 *
 *		Also rest if we are critically weak and have some food.
 */

static int
aftermelee (void)
{
  if (foughtmonster > 0) {
    lyinginwait = true;
    command (T_RESTING, "s");
    dwait (D_BATTLE, __func__, "waiting for %d rounds", foughtmonster);
    return (1);
  }

  /* If critically weak, rest up so traps won't kill us.  DR Utexas */
  if (Hp < 6 && larder > 0) {
    command (T_RESTING, "s");
    display ("Recovering from severe beating...");
    return (1);
  }

  return (foughtmonster = 0);
}

/*
 * battlestations:
 *
 *      We are going into battle. Can we think of anything better to
 *      to than simply hacking at him with our weapon?
 */

# define die_in(n)	(Hp/n < danger*50/(100-k_run))
# define live_for(n)	(! die_in(n))

/* m - Monster index */
/* monster - What is it? */
/* mbad - How bad is it? */
/* danger - How many points damage per round? */
/* mdir - Which direction (clear line of sight)? */
/* mdist - How many turns until battle? */
/* alert - Is he known to be awake? */
/* adj - How many attackers are there? */
static int
battlestations (int m, char *monster, int mbad, int danger, int mdir, int mdist, int alert, int adj)
{
  int obj, turns;
  static int stepback = 0;

  /* Ascertain whether we have a clear path to this monster */
  if (mdir != NONE && !checkcango (mdir, mdist))
    mdir = NONE;

  /* Number of turns is one less than distance (modified if we are hasted) */
  turns = hasted ? (mdist-1)*2 : (mdist-1);

  /* No point in wasting resources when we are invulnerable */
  if (on (SCAREM) &&
      (turns > 0 || confused) &&
      !streq(monster, "dragon") &&
      (Hp < percent (Hpmax, 95))) {
    command (T_RESTING, "s");
    display ("Resting on scare monster");
    dwait (D_BATTLE, __func__, "resting, on scaremonster");
    return (1);
  }

  /*
   * Take invisible stalkers into account into account,
   * fightmonster() and tomonster() cant see stalkers.
   */

  if (beingstalked > INVPRES) { turns = 0; danger += INVDAM; }

  /* Debugging breakpoint */
  dwait (D_BATTLE,
         __func__, "%s: %d total danger: %d dir: %d, %d turns: %d adj",
         monster, mbad, danger, mdir, turns, adj);

  /*
   * Switch back to our mace or sword?
   */

  if (live_for (1) && turns < 2 && wielding (thrower) && handleweapon ())
    { dwait (D_BATTLE, __func__, "Switching to 2nd sword"); return (1); }

  /*
   * Don't waste magic when on a scare monster scroll
   */

  if (on (SCAREM) && !streq (monster, "dragon")) {
    dwait (D_BATTLE, __func__, "hitting from scaremonster");
    return (0);
  }

  /*
   * If we were busy resting on the stairs and we see a monster, go down
   * Go on down if about to be attacked by a monster with an effective
   * magic attack.  DR UTexas 25 Jan 84
   *
   * or has a remote attack, or has a significant attack with a permanent
   * effect on the player stats or inventory
   */

  if (on(STAIRS) && ((Level>PLUNGE_LVL && Level<26) || exploredlevel) && !floating &&
      (die_in(5) ||
       ((seeawakemonster ("rattlesnake") || seeawakemonster ("giant ant")) &&
        (havenamed (ring, "sustain strength") < 0)) ||
       ((seeawakemonster ("aquator") || seeawakemonster ("rust monster")) &&
        turns < 2 && willrust (currentarmor) &&
        wearing ("maintain armor") == NONE) ||
       seeawakemonster ("medusa") || seeawakemonster ("umber hulk") ||
       seeawakemonster ("dragon") || seeawakemonster ("wraith") ||
       seeawakemonster ("vampire") || seeawakemonster ("nymph") ||
       seeawakemonster ("ice monster") || seeawakemonster ("leprechaun"))) {
    if (goupstairs (RUNNING) || godownstairs (RUNNING))
      return (1);
  }

  /*
   * Are healing potions worthwhile?
   */

  if (die_in (1) && Hpmax-Hp > 10 && turns > 0 &&
      ((obj = havenamed (potion, "extra healing")) != NONE ||
       (obj = havenamed (potion, "healing")) != NONE))
    return (quaff (obj));

  /*
   * Run away if we are sure of the direction and we are in trouble
   * Don't try to run if a fungi has ahold of us. If we are confused,
   * we will try other things, and we will decide to run later.
   * If we are on a door, wait until the monster is on us (that way
   * we can shoot arrows at him, if we want to).
   * Don't run away from Dragons!!!  They'll just flame you.
   */

  if (!confused && !beingheld && (!on(DOOR) || turns < 1) &&
      (!streq (monster, "dragon") || cosmic) && Hp+Explev < Hpmax &&
      ((die_in(1) || Hp <= danger + between (Level-10, 0, 10)) || chicken) &&
      runaway ()) {
    display ("Run away! Run away!");
    darkdir = NONE; darkturns = 0;
    return(1);
  }

  /*
   * Be clever when facing multiple monsters?
   */

  if (adj > 1 && !confused && !beingheld && !on (STAIRS | DOOR) &&
      backtodoor (turns))
    return (1);

  /*
   * stepback to see if he is awake.
   */

  if (!alert && !beingheld && !stepback && mdir != NONE &&
      turns == 0 && !on (DOOR | STAIRS)) {
    int rdir = (mdir+4)%DNUM;
    int new_r = atdrow (rdir);
    int new_c = atdcol (rdir);

    if (if_onrc (CANGO | TRAP, new_r, new_c) == CANGO)
      { move1 (rdir); stepback = 7; return (1); }
  }

  if (stepback) stepback--;     /* Decrement turns until step back again */

  /*
   * Should we put on our ring of maintain armor?   DR UTexas 19 Jan 84
   */

  if (live_for (1) && currentarmor != NONE &&
      (leftring == NONE || rightring == NONE) &&
      (seemonster ("aquator") || seemonster ("rust monster")) &&
      willrust (currentarmor) &&
      wearing ("maintain armor") == NONE &&
      (obj = havenamed (ring, "maintain armor")) != NONE &&
      puton (obj))
    return (1);

  if (turns > 1 && live_for (2) && leftring != NONE && rightring != NONE &&
      (seemonster ("aquator") || seemonster ("rust monster")) &&
      wearing ("maintain armor") < 0 &&
      findring ("maintain armor"))
    return (1);

  /*
   * Should we put on our ring of sustain strength?  DR UTexas 19 Jan 84
   */

  if ((live_for (1) || turns > 0) &&
      (leftring == NONE || rightring == NONE) &&
      (seemonster ("giant ant") || seemonster ("rattlesnake")) &&
      wearing ("sustain strength") < 0 &&
      (obj = havenamed (ring, "sustain strength")) != NONE &&
      puton (obj))
    return (1);

  if ((live_for (2) || turns > 1) &&
      leftring != NONE && rightring != NONE &&
      (seemonster ("giant ant") || seemonster ("rattlesnake")) &&
      wearing ("sustain strength") < 0 &&
      findring ("sustain strength"))
    return (1);

  /*
   * Should we put on our ring of regeneration? Make sure we wont kill
   * ourselves trying to do it, by checking how many turns it will take to
   * get it on compared to the number of hits we can take.
   */

  /* Have a ring and a free hand, one turn */
  if (die_in (4) && (live_for (1) || turns > 0) &&
      (leftring == NONE || rightring == NONE) &&
      !(turns == 0 && (streq (monster, "rattlesnake") ||
                       streq (monster, "giant ant"))) &&
      wearing ("regeneration") < 0 &&
      (obj = havenamed (ring, "regeneration")) != NONE &&
      puton (obj))
    return (1);

  /* Have a ring and both hands are full, takes two turns */
  if (die_in (4) && (live_for (2) || turns > 1) &&
      leftring != NONE && rightring != NONE &&
      wearing ("regeneration") < 0 &&
      findring ("regeneration"))
    return (1);

  /*
   * Haste ourselves?
   */

  if (!hasted && version > RV36B && (turns > 0 || live_for (1)) &&
      die_in (2) && (obj = havenamed (potion, "haste self")) != NONE &&
      quaff (obj))
    return (1);

  /*
   * Confuse the poor beast?
   */

  if (die_in (2) && turns > 0 && !redhands &&
      ((obj = havenamed (Scroll, "monster confusion")) != NONE))
    return (reads (obj));

  /*
   * Put them all to sleep? This does us little good, since we cant
   * currently infer that we have a scroll of Hold Monster. But we
   * will read scrolls of identify on the second one.  Bug, this
   * does not put them to sleep, it just holds them in place.
   * We have a lot more programming to do here!!!!   Fuzzy
   */

  if (die_in (1) && (obj = havenamed (Scroll, "hold monster")) != NONE &&
      reads (obj)) {
    holdmonsters ();
    return (1);
  }

  /*
   * Drop a scare monster?
   */

  if (die_in (1) && !streq(monster, "dragon") &&
      (obj = havenamed (Scroll, "scare monster")) != NONE &&
      drop (obj)) {
    set (SCAREM);
    droppedscare++;
    return (1);
  }

  /*
   * Buy buy birdy!
   */

  if (die_in (1) && mdir != NONE && turns == 0 &&
      (obj = havewand ("teleport away")) != NONE &&
      ! (itemis (obj, WORTHLESS)) &&
      point (obj, mdir)) {
    if (streq (monster, "violet fungi")) beingheld = false;

    if (streq (monster, "venus flytrap")) beingheld = false;

    return (1);
  }

  /*
   * Eat dust, turkey!
   */

  if (die_in (1) && turns == 0 &&
      (obj = havenamed (Scroll, "teleportation")) != NONE) {
    beingheld = false;
    return (reads (obj));
  }

  /*
   * If we trust our magic arrow, give it a whirl
   */

  if (!confused && creative && usingarrow && goodarrow > 10 && turns == 0)
    return (0);

  /*
   * Try to protect our armor from Rusties.
   */

  if (!cursedarmor && currentarmor != NONE &&
      (seeawakemonster ("rust monster") || seeawakemonster ("aquator")) &&
      live_for (1) &&
      !(cosmic && Level < 8) &&               /* DR UTexas 25 Jan 84 */
      willrust (currentarmor) &&
      wearing ("maintain armor") == NONE &&
      takeoff ())
    { return (1); }

  /*
   * Any life saving wands?
   */

  if (die_in (2) && Hp > 40 && turns < 3 &&
      !(streq (monster, "purple worm") || streq (monster, "jabberwock")) &&
      (obj = havewand ("drain life")) != NONE &&
      ! (itemis (obj, WORTHLESS))
     )
    return (point (obj, 0));

  if (mdir != NONE && die_in (2) &&
      (!cosmic || Level > 18) &&          /* DR UTexas 31 Jan 84 */
      (streq (monster, "dragon")     || streq (monster, "purple worm")   ||
       streq (monster, "jabberwock") || streq (monster, "medusa")        ||
       streq (monster, "xorn")       || streq (monster, "violet fungi")  ||
       streq (monster, "griffin")    || streq (monster, "venus flytrap") ||
       streq (monster, "umber hulk") || streq (monster, "black unicorn")) &&
      (obj = havewand ("polymorph")) != NONE &&
      ! (itemis (obj, WORTHLESS))
      )
    return (point (obj, mdir));

  /*
   * Any life prolonging wands?
   */

  if ((die_in (1) || (turns == 0 && streq (monster, "floating eye")) ||
       (turns == 0 && streq (monster, "ice monster"))) &&
      mdir != NONE && mdist < 6 && !on(DOOR) &&
      (((obj = havewand ("fire")) != NONE && !streq(monster, "dragon")) ||
       (obj = havewand ("cold")) != NONE ||
       (obj = havewand ("lightning")) != NONE) &&
      ! (itemis (obj, WORTHLESS))
     )
    return (point (obj, mdir));

  if (die_in (2) && mdir != NONE && !slowed && (turns>0 || live_for (2)) &&
      (obj = havewand ("slow monster")) != NONE &&
      (slowed = 5) &&
      ! (itemis (obj, WORTHLESS))
     )
    return (point (obj, mdir));

  if (mdir != NONE && !cancelled && turns == 0 &&
      (streq (monster, "wraith") ||
       streq (monster, "vampire") ||
       streq (monster, "floating eye") ||
       streq (monster, "ice monster") ||
       streq (monster, "leprechaun") ||
       streq (monster, "violet fungi") ||
       streq (monster, "venus flytrap")) &&
      (obj = havewand ("cancellation")) != NONE &&
      (cancelled = 10) &&
      ! (itemis (obj, WORTHLESS))
     ) {
    if (streq (monster, "violet fungi") || streq (monster, "venus flytrap"))
      beingheld = false;

    return (point (obj, mdir));
  }

  if (((die_in (3) && live_for (1)) ||
       (turns == 0 && streq (monster, "floating eye")) ||
       (turns == 0 && streq (monster, "ice monster"))) &&
      mdir != NONE &&
      (((obj = havewand ("magic missile")) != NONE && turns > 0) ||
       ((obj = havewand ("striking")) != NONE && turns == 0)) &&
      ! (itemis (obj, WORTHLESS))
     )
    return (point (obj, mdir));

  /*
   * Since we have no directional things, we will try to run even though
   * we are confused. Again, wait at door until the monster is on us.
   * Don't run away from dragons, they'll just flame you!!
   */

  if (confused && !beingheld && (!on(DOOR) || turns < 1) &&
      ! streq (monster, "dragon") &&
      ((die_in (1) && Hp+Explev/2+3 < Hpmax) || chicken) &&
      runaway ())
    { display ("Run away! Run away!"); return(1); }

  /*
   * We can live for a while, try to get to a position where we can run
   * away if we really get into trouble.  Don't run away from dragons,
   * they'll just flame you!!!
   */

  if (!confused && !beingheld && ! streq (monster, "dragon") &&
      (mdir < 0 || turns < 5) &&
      (((adj > 1 || live_for (1)) && die_in (4) && !canrun ())) &&
      unpin ())
    { display ("Unpinning!!!"); return(1); }

  /*
   * Light up the room if we are in combat.
   */

  if (turns > 0 && die_in (3) && lightroom ())
    return (1);

  /*
   * We arent yet in danger and can shoot at the old monster.
   */

  if ((live_for (5) || turns > 1) && shootindark ())
    return (1);

  /*
   * Try out an unknown wand?  Try shooting unknown wands at
   * rattlesnakes since they are such a pain.   DR UTexas  19 Jan 84
   */

  if (live_for (2) && (Level > 8 || streq (monster, "rattlesnake") ||
                       streq (monster, "giant ant")) &&
      mdir != NONE && on(ROOM) && mdist < 6 &&
      ((obj = unknown (wand)) != NONE) && (!used (inven[obj].str)) &&
      ! (itemis (obj, WORTHLESS))
     ) {
    point (obj, mdir);
    usesynch = false;
    return (1);
  }

  /*
   * Wait to see if he is really awake.
   */

  if (!alert && !lyinginwait && turns > 0) {
    command (T_FIGHTING, "s");
    dwait (D_BATTLE, __func__, "Waiting to see if he is awake");
    lyinginwait = true;
    return (1);
  }

  /*
   * Archery: try to move into a better position, and after that, try to
   * shoot an arrow at the beast. Conserve arrows below SAVEARROWS.
   */

  if ((streq (monster, "leprechaun") ||
       streq (monster, "nymph") ||
       streq (monster, "floating eye") ||
       streq (monster, "ice monster") ||
       streq (monster, "giant ant") ||
       streq (monster, "rattlesnake") ||
       streq (monster, "wraith") ||
       streq (monster, "vampire") ||
       streq (monster, "centaur") ||   /* DR UTexas 21 Jan 84 */
       die_in (1+k_arch/20) || ammo > SAVEARROWS+5-k_arch/10) &&
      (obj = havemissile ()) != NONE) {
    /* Move into position */
    if ((!alert || mdir < 0) && turns > 0 && archmonster (m, 1))
      return (1);

    /* If in position */
    if (!on (HALL) && mdir != NONE && turns > 0) {
      int bow;

      /* Wield the bow if we have time */
      if (!cursedweapon && !wielding (thrower) && turns > 4 &&
          (bow = havebow (1, NOPRINT)) != NONE && wield (bow))
        return (1);

      /* And shoot! */
      throw (obj, mdir);
      return (1);
    }
  }

  /*
   * Switch back to our mace or sword?
   */

  if (!cursedweapon && wielding (thrower) && handleweapon ())
    { dwait (D_BATTLE, __func__, "Switching to 3rd sword"); return (1); }

  /*
   * No bright ideas. Return and let the caller figure out what to do.
   */

  return (0);
}

/*
 * tostuff: if we see something to pick up, go to it. If our pack is full,
 * try to drop our least useful item. If pack is still full, fail.
 */

static int
tostuff (void)
{
  int i, closest, dist, w, worst, worstval;
  int   which, wrow, wcol;
  stuff what;

  /* If we don't see anything (or don't care), return failure */
  if (slistlen == 0 || (Level == 1 && have (amulet) != NONE)) return (0);

  /*
   * Now find the closest thing to pick up.  Don't consider things we have
   * already dropped (those squares have the USELESS bit set), unless we
   * have dropped a scroll of SCARE MONSTER, in which case we want our
   * pack to be full.  Don't be fooled by stairs when hallucinating.
   *
   * NOTE: Don't pick up the scaremonster scroll!!!    MLM
   *
   * scaremonster shouldn't be worth going to if we have enough Hp
   * to do something else...
   */

  for (i = 0, which = NONE, closest = 999; i < slistlen; i++) {
    if (!onrc (USELESS, slist[i].srow, slist[i].scol) ||
        (droppedscare && objcount < maxobj &&
         !onrc (SCAREM, slist[i].srow, slist[i].scol))) {
      dist = max (abs (slist[i].srow - atrow), abs (slist[i].scol - atcol));

      /* Ignore Junk */
      if (onrc (USELESS, slist[i].srow, slist[i].scol) &&
         (!onrc (SCAREM, slist[i].srow, slist[i].scol))) dist = ROGINFINITY;

      /* make scaremonster infinity when we don't need it */
      if (onrc (SCAREM, slist[i].srow, slist[i].scol))
         if (Hp > percent (Hpmax, 80))
           dist = ROGINFINITY;

      /* If this is the closest item, save its distance and index */
      if (dist < closest)
        { closest = dist; which = i; }
    }
  }

  /* Could not find anything worth picking up, return failure */
  if (which < 0) return (0);

  /* Found something, save its location and type in registers */
  what= slist[which].what; wrow= slist[which].srow; wcol= slist[which].scol;

  /* We can always pick up more gold */
  if (what == gold) return (gotowards (wrow, wcol, 0));

  /* Have space in our pack, go get it */
  if (objcount < maxobj) return (gotowards (wrow, wcol, 0));

  /* No space in pack and we cannot drop something here, fail */
  if (on (STUFF | DOOR | TRAP | STAIRS)) return (0);

  /* Must drop something, pick least valuable item to drop */
  for (worst = NONE, worstval = 9999, i = 0;   i < invcount;   i++) {
    if (inven[i].count && !itemis (i, INUSE) && (w = worth (i)) < worstval)
      { worst = i; worstval = w; }

    /* Once we have found a totally useless item, stop looking */
    if (worstval == 0) break;
  }

  /* Found an item, drop it */
  if (worst != NONE) return (drop (worst));

  /* Pack is full and we can't find something to drop, fail */
  return (0);
}

/*
 * fightinvisible: being hounded by unseen beasties, try something clever.
 */

static int
fightinvisible (void)
{
  int dir, liberties = 0, lastdir, obj;

  /* Count down the time since we were last hit by a stalker */
  if (--beingstalked < 0)
    { return (beingstalked=0); }

  /* Can we teleport out of here? */
  if (Hp < INVDAM && beingstalked > INVPRES &&
      (obj = havenamed (Scroll, "teleport")) != NONE && reads (obj)) {
    beingstalked = INVPRES-1;
    return (1);
  }

  /* Can we quaff a potion of see invisible? */
  if ((obj = havenamed (potion, "see invisible")) != NONE && quaff (obj))
    { beingstalked = 0; return (1); }

  /* If we have some time, try putting on a ring of see invisible */
  if (Hp > (INVDAM * 3/2) && beingstalked > INVLURK &&
      findring ("see invisible"))
    { return (1); }

  /* If we can bail out to the next level, do so */
  if (((beingstalked < INVPRES  && Hp < (INVDAM * 2)) ||
       (beingstalked >= INVPRES && Hp < (INVDAM * 3))) &&
      godownstairs (RUNNING)) {
    display ("Running like hell from an invisible stalker...");
    return (1);
  }

  /* Nothing worth doing, but he is around somewhere */
  if (beingstalked <= INVPRES)
    return (0);

  /* Must fight him 'mano a mano', tell the user (who cant see him either) */
  display ("Fighting invisible stalker...");

  /* Record the monster type (for didhit and didmiss, see mess.c) */
  if (version < RV53A)
    lastmonster = ('I'-'A'+1);
  else
    lastmonster = ('P'-'A'+1);

  /* Count how many orthogonal moves we can make */
  for (dir=0; dir<8; dir++)
    if (atdrow(dir) > 0 && atdrow(dir) < R-1 &&
        if_onrc(CANGO, atdrow(dir), atdcol(dir)) &&
        if_onrc(CANGO, atdrow(dir), atcol) &&
        if_onrc(CANGO, atrow, atdcol(dir)))
      { liberties++; lastdir = dir; }

  /* If can only go two ways, then go back and forth (will hit) */
  if (liberties == 1 || liberties == 2) {
    command (T_FIGHTING, "%c%c", keydir[lastdir], keydir[(lastdir+4)&7]);
    return (1);

  /* Try to get away, usually gets to a square with only 2 liberties */
  } else if (runaway ()) {
    return (1);
  }

  /* Else run two and then double back on him. If that will */
  /* not work, run in a circle (will hit one out of 4)      */
  for (dir=0; dir<8; dir += 2)
    if ((if_onrc(CANGO, atdrow(dir), atdcol(dir))) &&
        (if_onrc(CANGO, atrow+2*deltr[dir], atcol+2*deltc[dir])))
      break;

  if (dir > 7)	command (T_FIGHTING, "hjlk");
  else		command (T_FIGHTING, "%c%c%c", keydir[dir],
                     keydir[dir], keydir[(dir+4)&7]);

  return (1);
}

/*
 * archery: Try to arch sleeping monsters.  The 'mtokill' attr keeps track
 * of how many arrows we want to be able to pump into a monster before we
 * decide to wake him up.  That means we must be that far away AND have
 * that many missiles in our pack.  This number can be modified by our hit
 * and damage bonuses.
 *
 * Note: some monsters are to wimpy archery, and some too mean.     MLM
 */

static int
archery (void)
{
  int m, mtk;
  char *monster;

  for (m=0; m < mlistlen; m++) {	/* Find a sleeping monster */
    monster = monname (mlist[m].chr);

    /*
     * If he is not awake and either
     *   we are much stronger than he is or
     *   he is a known target for archery and
     * we have enough arrows to wipe this dude out and
     * we have food or he is a leprechaun and we arent hungry yet
     *
     * Then try calling archmonster to move to the right place.
     */

    if (mlist[m].q != AWAKE && gplushit != NONE &&
        !(mlist[m].q == HELD && Hp < Hpmax)  &&	/* DR UTexas 26 Jan 84 */
        (maxhit(m) > Hp/3 ||
         streq (monster, "leprechaun")	  ||
         streq (monster, "nymph")	  ||
         streq (monster, "floating eye")  ||
         streq (monster, "giant ant")	  ||
         streq (monster, "rattlesnake")	  ||
         streq (monster, "centaur")	  ||
         streq (monster, "ice monster"))  &&
        (ammo >= (mtk = monatt[mlist[m].chr-'A'].mtokill - gplushit)) &&
        (larder > 0 || ((streq (monster, "leprechaun") && !hungry ()) || streq (monster, "nymph")))) {
      dwait (D_BATTLE, __func__, "Arching at %c at (%d,%d)",
             mlist[m].chr, mlist[m].mrow, mlist[m].mcol);

      if (archmonster (m, mtk)) return (1);

      dwait (D_BATTLE, __func__, "Archmonster failed in archery");
    }
  }

  return (0);
}

/*
 * pickupafter: Go stand on square where the monster used to be.
 *              If (s)he left something behind (evens just arrows
 *		that missed) we will find it and pick it up.
 *
 * Bug:		Sometimes goes the long way around and doesnt see things.
 */

static int
pickupafter (void)
{
  /* If no goal */
  if (agoalr < 0 || agoalc < 0)
    return (0);

  /* If on goal */
  if (atrow == agoalr && atcol == agoalc) {
    agoalr = agoalc = NONE;
    return (0);
  }

  /* Else go for it */
  return (gotowards (agoalr, agoalc, 0));
}

/*
 * dropjunk: This doesnt just drop something.  It destroys it.
 *           When an object is thrown diagonally into a corner,
 *           Rogue can't find a place to put it, and the object is
 *           removed from the game.
 */

static int
dropjunk (void)
{
  int obj;

  if ((obj = haveuseless ()) != NONE && (gotocorner () || throw (obj, 7)))
    return (1);

  return (0);
}