/*
    actions.c  -  functions for dealing with monster actions
   
    XRogue: Expeditions into the Dungeons of Doom
    Copyright (C) 1991 Robert Pietkivitch
    All rights reserved.
    
    Based on "Advanced Rogue"
    Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
    All rights reserved.

    Based on "Rogue: Exploring the Dungeons of Doom"
    Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
    All rights reserved.
    
    See the file LICENSE.TXT for full copyright and licensing information.
*/

#include <ctype.h>
#include <curses.h>
#include <limits.h>
#include "rogue.h"

int mf_count = 0;       /* move_free counter - see actions.c(m_act()) */
int mf_jmpcnt = 0;      /* move_free counter for # of jumps           */

void m_breathe(struct thing *tp);
void m_select(struct thing *th, bool flee);
void m_sonic(struct thing *tp);
void m_spell(struct thing *tp);
void m_summon(struct thing *tp);
bool m_use_it(struct thing *tp, bool flee, struct room *rer, struct room *ree);
bool m_use_pack(struct thing *monster, coord *defend_pos, int dist, 
                coord *shoot_dir);

/* 
 * Did we disrupt a spell? 
 */
void
dsrpt_monster(struct thing *tp, bool always, bool see_him)
{
    switch (tp->t_action) {
    case A_SUMMON:
    case A_MISSILE:
    case A_SLOW:
        tp->t_action = A_NIL;   /* Just make the old fellow start over again */
        tp->t_no_move = movement(tp);
        tp->t_using = NULL; /* Just to be on the safe side */
        turn_on(*tp, WASDISRUPTED);
        if (see_him)
            msg("%s's spell has been disrupted.",prname(monster_name(tp),TRUE));
        /*
         * maybe choose something else to do next time since player
         * is disrupting us
         */
        tp->t_summon *= 2;
        tp->t_cast /= 2;
        return;
    }

    /* We may want to disrupt other actions, too */
    if (always) {
        tp->t_action = A_NIL; /* Just make the old fellow start over again */
        tp->t_no_move = movement(tp);
        tp->t_using = NULL;/* Just to be on the safe side */
    }
}

void
dsrpt_player(void)
{
    int which, action;
    struct linked_list *item;
    struct object *obj;
    
    action = player.t_action;
    which = player.t_selection;

    switch (action) {
    case C_CAST: /* Did we disrupt a spell? */
    case C_PRAY:
    case C_CHANT:
    {
        msg("Your %s was disrupted!", action == C_CAST ? "spell" : "prayer");

        /* Charge him 1/4 anyway */
        if (action == C_CAST)
            spell_power += magic_spells[which].s_cost / 4;
        else if (action == C_PRAY)
            pray_time += cleric_spells[which].s_cost / 4;
        else if (action == C_CHANT)
            chant_time += druid_spells[which].s_cost / 4;
    }
    when C_COUNT: /* counting of gold? */
    {
        if (purse > 0) {
            msg("Your gold goes flying everywhere!");
            do {
                item = spec_item(GOLD, 0, 0, 0);
                obj = OBJPTR(item);
                obj->o_count = min(purse, rnd(20)+1);
                purse -= obj->o_count;
                obj->o_pos = hero;
                fall(item, FALSE);
            } while (purse > 0 && rnd(25) != 1);
        }
    }
    when C_EAT:
        msg("Ack!  You gag on your food for a moment. ");
        del_pack(player.t_using);
        
    when A_PICKUP:
        msg("You drop what you are picking up! ");

    when C_SEARCH:      /* searching for traps and secret doors... */
        msg("Ouch!  You decide to stop searching. ");
        count = 0;      /* don't search again */

    when C_SETTRAP:
        msg("Ouch!  You can't set a trap right now. ");

    when A_NIL:
    default:
        return;
    }
    player.t_no_move = movement(&player); /* disoriented for a while */
    player.t_action = A_NIL;
    player.t_selection = 0;
}

/*
 * m_act:
 *      If the critter isn't doing anything, choose an action for it.
 *      Otherwise, let it perform its chosen action.
 */

void
m_act(struct thing *tp)
{
    struct object *obj;
    bool flee;          /* Are we scared? */

    /* What are we planning to do? */
    switch (tp->t_action) {
        default:
            /* An unknown action! */
            msg("Unknown monster action (%d)", tp->t_action);

            /* Fall through */

        case A_NIL:
            /* If the monster is fairly intelligent and about to die, it
             * may turn tail and run.  But if we are a FRIENDLY creature
             * in the hero's service, don't run.
             */
            if (off(*tp, ISFLEE)                                        &&
                tp->t_stats.s_hpt < tp->maxstats.s_hpt                  &&
                tp->t_stats.s_hpt < max(10, tp->maxstats.s_hpt/6)       &&
                (off(*tp, ISFRIENDLY) || tp->t_dest != &hero)           &&
                rnd(25) < tp->t_stats.s_intel) {
                    turn_on(*tp, ISFLEE);

                    /* It is okay to turn tail */
                    tp->t_oldpos = tp->t_pos;
                }

            /* Should the monster run away? */
            flee = on(*tp, ISFLEE) ||
                ((tp->t_dest == &hero) && on(player, ISINWALL) &&
                 off(*tp, CANINWALL));

            m_select(tp, flee); /* Select an action */
            return;

        when A_ATTACK:
            /* 
             * We're trying to attack the player or monster at t_newpos 
             * if the prey moved, do nothing
             */
            obj = tp->t_using ? OBJPTR(tp->t_using) : NULL;
            if (ce(tp->t_newpos, hero)) {
                attack(tp, obj, FALSE);
            }
            else if (mvwinch(mw, tp->t_newpos.y, tp->t_newpos.x) &&
                     step_ok(tp->t_newpos.y, tp->t_newpos.x, FIGHTOK, tp)) {
                skirmish(tp, &tp->t_newpos, obj, FALSE);
            }

        when A_SELL:
                /* Is the quartermaster still next to us? */
            if (ce(tp->t_newpos, hero)) sell(tp);

                /* The quartermaster moved away */
            else if (off(player, ISBLIND) && cansee(unc(tp->t_pos)) &&
                (off(*tp, ISINVIS)     || on(player, CANSEE)) &&
                (off(*tp, ISSHADOW)    || on(player, CANSEE)) &&
                (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT)) &&
        (rnd(12) < 4))
                msg("%s grunts with frustration",prname(monster_name(tp),TRUE));

        when A_MOVE:
            /* Let's try to move */
            do_chase(tp);

            /* If t_no_move > 0, we found that we have to fight! */
            if (tp->t_no_move > 0) return;

        when A_BREATHE:
            /* Breathe on the critter */
            m_breathe(tp);

        when A_SLOW:
            /* make him move slower */
            add_slow();
            turn_off(*tp, CANSLOW);

        when A_MISSILE:
            /* Start up a magic missile spell */
            m_spell(tp);

        when A_SONIC:
            /* Let out a sonic blast! */
            m_sonic(tp);

        when A_THROW:
            /* We're throwing something (like an arrow) */
            missile(tp->t_newpos.y, tp->t_newpos.x, tp->t_using, tp);

        when A_SUMMON:
            /* We're summoning help */
            m_summon(tp);

        when A_USERELIC:
            /* Use our relic */
            m_use_relic(tp);

        when A_USEWAND:
            /* use the wand we have */
            m_use_wand(tp);
    }

    /* Can we in fact move?  (we might have solidified in solid rock) */
    if (!step_ok(hero.y, hero.x, NOMONST, &player)) {

         if (move_free > 1) goto jump_over;   /* avoid messages */
         if (mf_count > 2)  goto jump_over;   /* limit messages */

         if (pstats.s_hpt < 1) {
         pstats.s_hpt = -1;
             msg("You have merged into the surroundings!  --More--");
             wait_for(' ');
             death(D_PETRIFY);
         }
         else {
             mf_count += 1;  /* count number of times we are here */
             pstats.s_hpt -= rnd(2)+1;
             if (pstats.s_hpt < 1) {
          pstats.s_hpt = -1;
                  msg("You have merged into the surroundings!  --More--");
                  wait_for(' ');
                  death(D_PETRIFY);
             }
         }
         switch (rnd(51)) {
             case 0: msg("Arrrggghhhhh!! ");
             when 5: msg("You can't move! "); 
             when 10: msg("You motion angrily! "); 
             when 15: msg("You feel so weird! ");
             when 20: msg("If only you could phase. ");
             when 25: msg("The rock maggots are closing in! ");
             when 30: msg("You wrench and wrench and wrench... ");
             when 35: msg("You wish you could teleport out of here! ");
             when 40: msg("Your feel your life force ebbing away... ");
             when 45: msg("You partially regain your senses. ");
             when 50: msg("The rock maggots have found you!!! "); 
             otherwise: pstats.s_hpt -= rnd(4)+1;
         }
         if (pstats.s_hpt < 1) {
          pstats.s_hpt = -1;
              msg("You lose the urge to live...  --More--");
              wait_for(' ');
              death(D_PETRIFY);
     }
        jump_over:
        mf_jmpcnt++;          /* count this jump */
        if (mf_jmpcnt > 9) {  /* take a few turns, then reset it */
            mf_jmpcnt = 0;
            mf_count  = 0;
        }
    }

    /* No action now */
    tp->t_action = A_NIL;
    tp->t_using = NULL;
}

/*
 * m_breathe:
 *      Breathe in the chosen direction.
 */

void
m_breathe(struct thing *tp)
{
    register int damage;
    register char *breath = NULL;

    damage = tp->t_stats.s_hpt;
    turn_off(*tp, CANSURPRISE);

    /* Will it breathe at random */
    if (on(*tp, CANBRANDOM)) {
        /* Turn off random breath */
        turn_off(*tp, CANBRANDOM);

        /* Select type of breath */
        switch (rnd(10)) {
            case 0: breath = "acid";
                    turn_on(*tp, NOACID);
            when 1: breath = "flame";
                    turn_on(*tp, NOFIRE);
            when 2: breath = "lightning bolt";
                    turn_on(*tp, NOBOLT);
            when 3: breath = "chlorine gas";
                    turn_on(*tp, NOGAS);
            when 4: breath = "ice";
                    turn_on(*tp, NOCOLD);
            when 5: breath = "nerve gas";
                    turn_on(*tp, NOPARALYZE);
            when 6: breath = "sleeping gas";
                    turn_on(*tp, NOSLEEP);
            when 7: breath = "slow gas";
                    turn_on(*tp, NOSLOW);
            when 8: breath = "confusion gas";
                    turn_on(*tp, ISCLEAR);
            when 9: breath = "fear gas";
                    turn_on(*tp, NOFEAR);
        }
    }

    /* Or can it breathe acid? */
    else if (on(*tp, CANBACID)) {
        turn_off(*tp, CANBACID);
        breath = "acid";
    }

    /* Or can it breathe fire */
    else if (on(*tp, CANBFIRE)) {
        turn_off(*tp, CANBFIRE);
        breath = "flame";
    }

    /* Or can it breathe electricity? */
    else if (on(*tp, CANBBOLT)) {
        turn_off(*tp, CANBBOLT);
        breath = "lightning bolt";
    }

    /* Or can it breathe gas? */
    else if (on(*tp, CANBGAS)) {
        turn_off(*tp, CANBGAS);
        breath = "chlorine gas";
    }

    /* Or can it breathe ice? */
    else if (on(*tp, CANBICE)) {
        turn_off(*tp, CANBICE);
        breath = "ice";
    }

    else if (on(*tp, CANBPGAS)) {
        turn_off(*tp, CANBPGAS);
        breath = "nerve gas";
    }

    /* can it breathe sleeping gas */
    else if (on(*tp, CANBSGAS)) {
        turn_off(*tp, CANBSGAS);
        breath = "sleeping gas";
    }

    /* can it breathe slow gas */
    else if (on(*tp, CANBSLGAS)) {
        turn_off(*tp, CANBSLGAS);
        breath = "slow gas";
    }

    /* can it breathe confusion gas */
    else if (on(*tp, CANBCGAS)) {
        turn_off(*tp, CANBCGAS);
        breath = "confusion gas";
    }

    /* can it breathe fear gas */
    else {
        turn_off(*tp, CANBFGAS);
        breath = "fear gas";
    }

    /* Now breathe */
    shoot_bolt(tp, tp->t_pos, tp->t_newpos, FALSE, 
                    tp->t_index, breath, damage);

    running = FALSE;
    if (fight_flush) flushinp();
}

/*
 * m_select:
 *      Select an action for the monster.
 * flee: True if running away or player is inaccessible in wall
 */

void
m_select(struct thing *th, bool flee)
{
    register struct room *rer, *ree;    /* room of chaser, room of chasee */
    int dist = INT_MIN;
    int mindist = INT_MAX, maxdist = INT_MIN;
    bool rundoor;                       /* TRUE means run to a door */
    char sch;
    coord *last_door=0,                 /* Door we just came from */
           this;                        /* Temporary destination for chaser */

    rer = roomin(&th->t_pos);   /* Find room of chaser */
    ree = roomin(th->t_dest);   /* Find room of chasee */

    /* First see if we want to use an ability or weapon */
    if (m_use_it(th, flee, rer, ree)) return;

    /*
     * We don't count monsters on doors as inside rooms here because when
     * a monster is in a room and the player is not in that room, the
     * monster looks for the best door out.  If we counted doors as part
     * of the room, the monster would already be on the best door out;
     * so he would never move.
     */
    if ((sch = mvwinch(stdscr, th->t_pos.y, th->t_pos.x)) == DOOR ||
        sch == SECRETDOOR || sch == PASSAGE) {
        rer = NULL;
    }
    this = *th->t_dest;

    /*
     * If we are in a room heading for the player and the player is not
     * in the room with us, we run to the "best" door.
     * If we are in a room fleeing from the player, then we run to the
     * "best" door if he IS in the same room.
     *
     * Note:  We don't bother with doors in mazes or if we can walk
     * through walls.
     */
    if (rer != NULL && levtype != MAZELEV && off(*th, CANINWALL)) {
        if (flee) rundoor = (rer == ree);
        else rundoor = (rer != ree);
    }
    else rundoor = FALSE;

    if (rundoor) {
        register struct linked_list *exitptr;   /* For looping through exits */
        coord *exit,                            /* A particular door */
              *entrance;                        /* Place just inside doorway */
        int exity, exitx;                       /* Door's coordinates */
        char dch='\0';                          /* Door character */

        if ((th->t_doorgoal.x != -1) && (th->t_doorgoal.y != -1))
            dch = mvwinch(stdscr, th->t_doorgoal.y, th->t_doorgoal.x);
            
        /* Do we have a valid goal? */
        if ((dch == PASSAGE || dch == DOOR) &&  /* A real door */
            (!flee || !ce(th->t_doorgoal, *th->t_dest))) { /* Prey should not
                                                             * be at door if
                                                             * we are running
                                                             * away
                                                             */
            /* Make sure the player is not in the doorway, either */
            entrance = doorway(rer, &th->t_doorgoal);
            if (!flee || entrance == NULL || !ce(*entrance, *th->t_dest)) {
                this = th->t_doorgoal;
                dist = 0;       /* Indicate that we have our door */
            }
        }

        /* Go through all the doors */
        else for (exitptr = rer->r_exit; exitptr; exitptr = next(exitptr)) {
            exit = DOORPTR(exitptr);
            exity = exit->y;
            exitx = exit->x;

            /* Make sure it is a real door */
            dch = mvwinch(stdscr, exity, exitx);
            if (dch == PASSAGE || dch == DOOR) {
                /* Don't count a door if we are fleeing from someone and
                 * he is standing on it.  Also, don't count it if he is
                 * standing in the doorway.
                 */
                if (flee) {
                    if (ce(*exit, *th->t_dest)) continue;

                    entrance = doorway(rer, exit);
                    if (entrance != NULL && ce(*entrance, *th->t_dest))
                        continue;
                }
                
                /* Were we just on this door? */
                if (ce(*exit, th->t_oldpos)) last_door = exit;

                else {
                    dist = DISTANCE(th->t_dest->y, th->t_dest->x, exity, exitx);

                    /* If fleeing, we want to maximize distance from door to
                     * what we flee, and minimize distance from door to us.
                     */
                    if (flee)
                       dist -= DISTANCE(th->t_pos.y, th->t_pos.x, exity, exitx);

                    /* Maximize distance if fleeing, otherwise minimize it */
                    if ((flee && (dist > maxdist)) ||
                        (!flee && (dist < mindist))) {
                        th->t_doorgoal = *exit;  /* Use this door */
                        this = *exit;
                        mindist = maxdist = dist;
                    }
                }
            }
        }

        /* Could we not find a door? */
        if (dist == INT_MIN) {
            /* If we were on a door, go ahead and use it */
            if (last_door) {
                th->t_doorgoal = *last_door;
                this = th->t_oldpos;
                dist = 0;       /* Indicate that we found a door */
            }
            else th->t_doorgoal.x = th->t_doorgoal.y = -1; /* No more door goal */
        }

        /* Indicate that we do not want to flee from the door */
        if (dist != INT_MIN) flee = FALSE;
    }
    else th->t_doorgoal.x = th->t_doorgoal.y = -1;    /* Not going to any door */

    /* Now select someplace to go and start the action */
    chase(th, &this, rer, ree, flee);
}

/*
 * m_sonic:
 *      The monster is sounding a sonic blast.
 */

void
m_sonic(struct thing *tp)
{
    register int damage;
    struct object blast =
    {
        MISSILE, {0, 0}, 0, "", "150" , NULL, 0, 0, 0, 0
    };

    turn_off(*tp, CANSONIC);
    turn_off(*tp, CANSURPRISE);
    do_motion(&blast, tp->t_newpos.y, tp->t_newpos.x, tp);
    damage = rnd(61)+40;
    if (save(VS_BREATH, &player, -3))
        damage /= 2;
    msg ("%s's ultra-sonic blast hits you", prname(monster_name(tp), TRUE));
    if ((pstats.s_hpt -= damage) <= 0) {
    pstats.s_hpt = -1;
        death(tp->t_index);
    }
    running = FALSE;
    if (fight_flush) flushinp();
    dsrpt_player();
}

/*
 * m_spell:
 *      The monster casts a spell.  Currently this is limited to
 *      magic missile.
 */
void
m_spell(struct thing *tp)
{
    struct object missile =
    {
        MISSILE, {0, 0}, 0, "", "0d4 " , NULL, 0, WS_MISSILE, 100, 1
    };

    sprintf(missile.o_hurldmg, "%dd4", tp->t_stats.s_lvl);
    do_motion(&missile, tp->t_newpos.y, tp->t_newpos.x, tp);
    hit_monster(unc(missile.o_pos), &missile, tp);
    turn_off(*tp, CANMISSILE);
    turn_off(*tp, CANSURPRISE);

    running = FALSE;
    if (fight_flush) flushinp();
}

/*
 * m_summon:
 *      Summon aid.
 */

void
m_summon(struct thing *tp)
{
    register char *helpname, *mname;
    int fail, numsum;
    register int which, i;

    /* Let's make sure our prey is still here */
    if (!cansee(unc(tp->t_pos)) || fallpos(&hero, FALSE, 2) == NULL) return;

    /*
     * Non-uniques can only summon once.  Uniques get fewer
     * creatures with each successive summoning. Also, the
     * probability of summoning goes down
     */
    if (off(*tp, ISUNIQUE))
            turn_off(*tp, CANSUMMON);

    turn_off(*tp, CANSURPRISE);
    mname = monster_name(tp);
    helpname = monsters[tp->t_index].m_typesum;
    which = findmindex(helpname);

    if ((off(*tp, ISINVIS)     || on(player, CANSEE)) &&
        (off(*tp, ISSHADOW)    || on(player, CANSEE)) &&
        (off(*tp, CANSURPRISE) || ISWEARING(R_ALERT))) {
        if (monsters[which].m_normal == FALSE) { /* genocided? */
            msg("%s appears dismayed", prname(mname, TRUE));
            monsters[tp->t_index].m_numsum = 0;
        }
        else {
            msg("%s summons %ss for help", prname(mname, TRUE), helpname);
        }
    }
    else {
        if (monsters[which].m_normal == FALSE) /* genocided? */
            monsters[tp->t_index].m_numsum = 0;
        else {
            msg("%ss seem to appear from nowhere!", helpname);
        }
    }
    numsum = monsters[tp->t_index].m_numsum;
    if (numsum && on(*tp, ISUNIQUE)) {   /* UNIQUEs summon less each time */
        monsters[tp->t_index].m_numsum--; 
        tp->t_summon *= 2; /* cut probability in half */
    }

    /*
     * try to make all the creatures around player but remember
     * if unsuccessful
     */
    for (i=0, fail=0; i<numsum; i++) {
         if (!creat_mons(&player, which, FALSE))
             fail++;    /* remember the failures */
    }

    /*
     * try once again to make the buggers
     */
    for (i=0; i<fail; i++)
         creat_mons(tp, which, FALSE);
    
    /* Now let the poor fellow see all the trouble */
    light(&hero);
    turn_on(*tp, HASSUMMONED);
}

/*
 * m_use_it:
 *      See if the monster (tp) has anything useful it can do
 *      (ie. an ability or a weapon) other than just move.
 */

bool
m_use_it(struct thing *tp, bool flee, struct room *rer, struct room *ree)
{
    int dist;
    register coord *ee = tp->t_dest, *er = &tp->t_pos; 
    coord *shoot_dir = NULL;
    coord straight_dir;
    int   straight_shot = FALSE;
    struct thing *prey;
    bool dest_player;   /* Are we after the player? */

    /*
     * If we are fleeing, there's a chance, depending on our
     * intelligence, that we'll just run in terror.
     */
    if (flee && rnd(25) >= tp->t_stats.s_intel) return(FALSE);

    /*
     * Make sure that we have a living destination, and record whether
     * it is the player.
     */
    if (ee != NULL) {
        if (ce(*ee, hero)) {
            dest_player = TRUE;
            prey = &player;
        }
        else {
            struct linked_list *item;

            dest_player = FALSE;

            /* What is the monster we're chasing? */
            item = find_mons(ee->y, ee->x);
            if (item != NULL) prey = THINGPTR(item);
            else return(FALSE);
        }
    }
    else return(FALSE);

    /*
     * If we are friendly to the hero, we don't do anything.
     */
    if (on(*tp, ISFRIENDLY) && dest_player) return(FALSE);

    /*
     * Also, for now, if our prey is in a wall, we won't do
     * anything.  The prey must be in the same room as we are OR
     * we must have a straight shot at him.  Note that
     * shoot_dir must get set before rer is checked so
     * that we get a valid value.
     */
 
    if (can_shoot(er, ee, &straight_dir) == 0)
        shoot_dir = &straight_dir;
    else
        shoot_dir = NULL;

    if (on(*prey, ISINWALL) ||
        ( (shoot_dir == NULL) && (rer == NULL || rer != ree)))
        return(FALSE);

    /*
     * If we can't see the prey then forget it
     */
    if (on(*prey, ISINVIS) && off(*tp, CANSEE))
        return(FALSE);

    /* How far are we from our prey? */
    dist = DISTANCE(er->y, er->x, ee->y, ee->x);

    /* 
     * Shall we summon aid so we don't have to get our hands dirty? 
     * For now, we will only summon aid against the player.
     * We'll wait until he's within 2 dots of a missile length.
     */
    if (on(*tp, CANSUMMON) && dest_player                       &&
        dist < (BOLT_LENGTH+2)*(BOLT_LENGTH+2)                  &&
        rnd(tp->t_summon) < tp->t_stats.s_lvl                   &&
        monsters[tp->t_index].m_numsum > 0                      &&
        fallpos(&hero, FALSE, 2) != NULL) {
        tp->t_action = A_SUMMON;        /* We're going to summon help */
        tp->t_no_move = movement(tp); /* It takes time! */
        return(TRUE);
    }

    /*
     * If the creature can cast a slow spell and if the prey is within
     * 2 dots of a missile fire, then see whether we will cast it.
     * if next to player, lessen chance because we don't like being
     * disrupted
     */
    if (on(*tp, CANSLOW) && dest_player                 && 
        dist < (BOLT_LENGTH+5)*(BOLT_LENGTH+5)          &&
        rnd(100) < (dist > 3 ? tp->t_cast : tp->t_cast/2)) {
            tp->t_action = A_SLOW;              /* We're going to slow him */
            tp->t_no_move = 3 * movement(tp);   /* Takes time! */
            debug("casting slow spell!");
            return(TRUE);
    }

    /*
     * If we have a special magic item, we might use it.  We will restrict
     * this options to uniques with relics and creatures with wands for now.  
     * Also check for the quartermaster. Don't want him shooting wands....
     */
    if ((on(*tp, ISUNIQUE) || on(*tp, CARRYSTICK)) && 
        off(*tp, CANSELL) && dest_player           &&
        m_use_pack(tp, ee, dist, shoot_dir)) {
            return(TRUE);
    }

    /* From now on, we must have a direct shot at the prey */
    if (!straight_shot) return(FALSE);

    /* We may use a sonic blast if we can, only on the player */
    if (on(*tp, CANSONIC)               && 
        dest_player                     &&
        (dist < BOLT_LENGTH*2)          &&
        (rnd(100) < tp->t_breathe)) {
        tp->t_newpos = *shoot_dir;      /* Save the direction */
        tp->t_action = A_SONIC; /* We're going to sonic blast */
        tp->t_no_move = 2 * movement(tp); /* Takes 2 movement periods */
    }

    /* If we can breathe, we may do so */
    else if (on(*tp, CANBREATHE)                &&
         (dist < BOLT_LENGTH*BOLT_LENGTH)       &&
         (rnd(100) < tp->t_breathe)) {
            tp->t_newpos = *shoot_dir;  /* Save the direction */
            tp->t_action = A_BREATHE;   /* We're going to breathe */
            tp->t_no_move = movement(tp); /* It takes 1 movement period */
    }

    /* 
     * We may shoot missiles if we can 
     * if next to player, lessen chance so we don't get disrupted as often
     */
    else if (on(*tp,CANMISSILE) && 
             rnd(100) < (dist > 3 ? tp->t_cast : tp->t_cast/2)){
            tp->t_newpos = *shoot_dir;  /* Save the direction */
            tp->t_action = A_MISSILE;   /* We're going to shoot MM's */
            tp->t_no_move = 3 * movement(tp); /* Takes time! */
    }

    /* 
     * If we can shoot or throw something, we might do so.
     * If next to player, then forget it
     */
    else if ((on(*tp,CANSHOOT)          || on(*tp,CARRYWEAPON) || 
              on(*tp,CARRYDAGGER)       || on(*tp, CARRYAXE))           &&
              dist > 3                                                  &&
              off(*tp, CANSELL)                                         &&
             (get_hurl(tp) != NULL)) {
            tp->t_newpos = *shoot_dir;  /* Save the direction */
            tp->t_action = A_THROW;     /* We're going to throw something */
            tp->t_using = get_hurl(tp);       /* Save our weapon */
            tp->t_no_move = 2 * movement(tp); /* Takes 2 movement periods */
    }
    
    /* We couldn't find anything to do */
    else return(FALSE);

    return(TRUE);

}

void
reap(void)
{
    _t_free_list(&rlist);
}

/*
 * runners:
 *      Make all the awake monsters try to do something.
 * segments: Number of segments since last called
 */

int
runners(int segments)
{
    register struct linked_list *item;
    register struct thing *tp = NULL;
    register int min_time = 20;     /* Minimum time until a monster can act */

    /*
     * loop thru the list of running (wandering) monsters and see what
     * each one will do this time. 
     *
     * Note: the special case that one of this buggers kills another.
     *       if this happens than we have to see if the monster killed
     *       himself or someone else. In case its himself we have to get next
     *       one immediately. If it wasn't we have to get next one at very
     *       end in case he killed the next one.
     */
    for (item = mlist; item != NULL; item = item->l_next)
    {
        tp = THINGPTR(item);
        turn_on(*tp, NEEDSTOACT);
    }

    for(;;)
    {
        for (item = mlist; item != NULL; item = item->l_next)
        {
            tp = THINGPTR(item);

            if (on(*tp, NEEDSTOACT))
                break;
        }

        if (item == NULL)
            break;

        turn_off(*tp, NEEDSTOACT);

        /* If we are not awake, just skip us */

        if (off(*tp, ISRUN) && off(*tp, ISHELD))
            continue;

        /* See if it's our turn */

        tp->t_no_move -= segments;

        if (tp->t_no_move > 0)
        {
            if (tp->t_no_move < min_time) min_time = tp->t_no_move;
                continue;
        }

        /* If we were frozen, we're moving now */

        if (tp->t_action == A_FREEZE)
            tp->t_action = A_NIL;

        if (on(*tp, ISHELD))
        {
            /* Make sure the action and using are nil */

            tp->t_action = A_NIL;
            tp->t_using = NULL;

            /* Can we break free? */

            if (rnd(tp->t_stats.s_lvl) > 11)
            {
                turn_off(*tp, ISHELD);

                runto(tp, &hero);

                if (cansee(tp->t_pos.y, tp->t_pos.x))
                    msg("%s breaks free from the hold spell", 
                        prname(monster_name(tp), TRUE));
            }
            else /* Too bad -- try again later */
                tp->t_no_move = movement(tp);
        }

        /* Heal the creature if it's not in the middle of some action */

        if (tp->t_action == A_NIL)
           doctor(tp);

        while (off(*tp, ISELSEWHERE) &&
               off(*tp, ISDEAD) &&
               tp->t_no_move <= 0 &&
               off(*tp, ISHELD) &&
               on(*tp, ISRUN)       )
        {
            /* Let's act (or choose an action if t_action = A_NIL) */

            m_act(tp);
        }

        if ( off(*tp,ISELSEWHERE) && off(*tp,ISDEAD) )
        {
            if (tp->t_no_move < min_time)
               min_time = tp->t_no_move;

            if (tp->t_quiet < 0)
               tp->t_quiet = 0;
        }
    }

    return(min_time);
}

/*
 * See if a monster has some magic it can use.  Return TRUE if so.
 * Only care about relics and wands for now.
 */
bool
m_use_pack(struct thing *monster, coord *defend_pos, int dist, coord *shoot_dir)
{
    register struct object *obj;
    register struct linked_list *pitem, *relic, *stick;
    register int units = -1;

    relic = stick = NULL;

    for (pitem=monster->t_pack; pitem; pitem=next(pitem)) {
        obj = OBJPTR(pitem);
        if (obj->o_flags & ISCURSED) continue;
        if (obj->o_type == RELIC) {
            switch (obj->o_which) {
                case MING_STAFF:
                    if (shoot_dir != NULL) {
                        units = 2;      /* Use 2 time units */
                        relic = pitem;
                    }

                when EMORI_CLOAK:
                    if (obj->o_charges != 0     && 
                        shoot_dir != NULL) {
                            units = 2;  /* Use 2 time units */
                            relic = pitem;
                    }

                when ASMO_ROD:
                    /* The bolt must be able to reach the defendant */
                    if (shoot_dir != NULL                       && 
                        dist < BOLT_LENGTH * BOLT_LENGTH) {
                        units = 2;      /* Use 2 time units */
                        relic = pitem;
                    }

                when BRIAN_MANDOLIN:
                    /* The defendant must be the player and within 4 spaces */
                    if (ce(*defend_pos, hero)           && 
                        dist < 25                       &&
                        player.t_action != A_FREEZE) {
                        units = 4;
                        relic = pitem;
                    }

                when GERYON_HORN:
                    /* The defendant must be the player and within 5 spaces */
                    if (ce(*defend_pos, hero)                                &&
                        dist < 25                                            &&
                        (off(player,ISFLEE)|| player.t_dest!=&monster->t_pos)) {
                        units = 3;
                        relic = pitem;
                    }
            }
        }
        if (obj->o_type == STICK) {
            if (obj->o_charges < 1) continue;
            switch(obj->o_which) {
                case WS_ELECT:
                case WS_FIRE:
                case WS_COLD:
                    /* The bolt must be able to reach the defendant */
                    if (shoot_dir != NULL                       && 
                        dist < BOLT_LENGTH * BOLT_LENGTH) {
                            units = 3;
                            stick = pitem;
                    }

                when WS_MISSILE:
                case WS_SLOW_M:
                case WS_CONFMON:
                case WS_PARALYZE:
                case WS_MDEG:
                case WS_FEAR:
                    if (shoot_dir != NULL) {
                        units = 3;
                        stick = pitem;
                    }
                
                otherwise:
                    break;
            }
        }
    }

    /* use relics in preference to all others */
    if (relic) debug("chance to use relic = %d%%", monster->t_artifact);
    if (stick) debug("chance to use stick = %d%%", monster->t_wand);
    if (relic && rnd(100) < monster->t_artifact)  {
        monster->t_action = A_USERELIC;
        pitem = relic;
    }
    else if (stick && rnd(100) < monster->t_wand) {
        /*
         * see if the monster will use the wand 
         */
        pitem = stick;
        monster->t_action = A_USEWAND;
    }
    else {
        return(FALSE);
    }

    monster->t_no_move = units * movement(monster);
    monster->t_using = pitem;
    monster->t_newpos = *shoot_dir;
    return(TRUE);
}

