/home/leaf/crossfire/server/branches/1.12/server/monster.c

Go to the documentation of this file.

/*
 * static char *rcsid_monster_c =
 *    "$Id: monster.c 11644 2009-04-15 06:24:55Z mwedel $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002-2007 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program 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 2 of the License, or
    (at your option) any later version.

    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#include <assert.h>
#include <global.h>
#ifndef __CEXTRACT__
#include <sproto.h>
#include <spells.h>
#include <skills.h>
#endif

static int can_hit(object *ob1, object *ob2, rv_vector *rv);
static int monster_cast_spell(object *head, object *part, object *pl, int dir, rv_vector *rv);
static int monster_use_scroll(object *head, object *part, object *pl, int dir, rv_vector *rv);
static int monster_use_skill(object *head, object *part, object *pl, int dir);
static int monster_use_range(object *head, object *part, object *pl, int dir);
static int monster_use_bow(object *head, object *part, object *pl, int dir);
static void monster_check_pickup(object *monster);
static int monster_can_pick(object *monster, object *item);
static void monster_apply_below(object *monster);
static int dist_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv);
static int run_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv);
static int hitrun_att(int dir, object *ob, object *enemy);
static int wait_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv);
static int disthit_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv);
static int wait_att2(int dir, object *ob, object *enemy, object *part, rv_vector *rv);
static void circ1_move(object *ob);
static void circ2_move(object *ob);
static void pace_movev(object *ob);
static void pace_moveh(object *ob);
static void pace2_movev(object *ob);
static void pace2_moveh(object *ob);
static void rand_move(object *ob);
static int talk_to_npc(object *op, object *npc, const char *txt, int *talked);

#define MIN_MON_RADIUS 3 /* minimum monster detection radius */

object *check_enemy(object *npc, rv_vector *rv) {
    /* if this is pet, let him attack the same enemy as his owner
     * TODO: when there is no ower enemy, try to find a target,
     * which CAN attack the owner. */
    if ((npc->attack_movement&HI4) == PETMOVE) {
        if (npc->owner == NULL)
            npc->enemy = NULL;
        else if (npc->enemy == NULL)
            npc->enemy = npc->owner->enemy;
    }

    /* periodically, a monster mayu change its target.  Also, if the object
     * has been destroyed, etc, clear the enemy.
     * TODO: this should be changed, because it invokes to attack forced or
     * attacked monsters to leave the attacker alone, before it is destroyed
     */
    /* i had removed the random target leave, this invokes problems with friendly
     * objects, getting attacked and defending herself - they don't try to attack
     * again then but perhaps get attack on and on
     * If we include a aggravated flag in , we can handle evil vs evil and good vs good
     * too. */

    if (npc->enemy) {
        /* I broke these if's apart to better be able to see what
         * the grouping checks are.  Code is the same.
         */
        if (QUERY_FLAG(npc->enemy, FLAG_REMOVED)
        || QUERY_FLAG(npc->enemy, FLAG_FREED)
        || !on_same_map(npc, npc->enemy)
        || npc == npc->enemy
        || QUERY_FLAG(npc, FLAG_NEUTRAL)
        || QUERY_FLAG(npc->enemy, FLAG_NEUTRAL))
            npc->enemy = NULL;

        else if (QUERY_FLAG(npc, FLAG_FRIENDLY) && (
                (QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && !(should_arena_attack(npc, npc->owner, npc->enemy)))
                || ((npc->enemy->type == PLAYER) && !(should_arena_attack(npc, npc->owner, npc->enemy)))
                || npc->enemy == npc->owner))
            npc->enemy = NULL;
        else if (!QUERY_FLAG(npc, FLAG_FRIENDLY)
        && (!QUERY_FLAG(npc->enemy, FLAG_FRIENDLY) && npc->enemy->type != PLAYER))
            npc->enemy = NULL;

        /* I've noticed that pets could sometimes get an arrow as the
         * target enemy - this code below makes sure the enemy is something
         * that should be attacked.  My guess is that the arrow hits
         * the creature/owner, and so the creature then takes that
         * as the enemy to attack.
         */
        else if (!QUERY_FLAG(npc->enemy, FLAG_MONSTER)
        && !QUERY_FLAG(npc->enemy, FLAG_GENERATOR)
        && npc->enemy->type != PLAYER
        && npc->enemy->type != GOLEM)
            npc->enemy = NULL;

    }
    return can_detect_enemy(npc, npc->enemy, rv) ? npc->enemy : NULL;
}

object *find_nearest_living_creature(object *npc) {
    int i, mflags;
    sint16 nx, ny;
    mapstruct *m;
    object *tmp;
    int search_arr[SIZEOFFREE];

    get_search_arr(search_arr);
    for (i = 0; i < SIZEOFFREE; i++) {
        /* modified to implement smart searching using search_arr
         * guidance array to determine direction of search order
         */
        nx = npc->x+freearr_x[search_arr[i]];
        ny = npc->y+freearr_y[search_arr[i]];
        m = npc->map;

        mflags = get_map_flags(m, &m, nx, ny, &nx, &ny);
        if (mflags&P_OUT_OF_MAP)
            continue;

        if (mflags&P_IS_ALIVE) {
            tmp = GET_MAP_OB(m, nx, ny);
            while (tmp != NULL
            && !QUERY_FLAG(tmp, FLAG_MONSTER)
            && !QUERY_FLAG(tmp, FLAG_GENERATOR)
            && tmp->type != PLAYER)
                tmp = tmp->above;

            if (!tmp) {
                LOG(llevDebug, "find_nearest_living_creature: map %s (%d,%d) has is_alive set but did not find a monster?\n", m->path, nx, ny);
            } else {
                if (can_see_monsterP(m, nx, ny, i))
                    return tmp;
            }
        } /* is something living on this space */
    }
    return NULL;  /* nothing found */
}

static object *find_enemy(object *npc, rv_vector *rv) {
    object *attacker, *tmp = NULL;

    attacker = npc->attacked_by; /* save this for later use. This can be a attacker. */
    npc->attacked_by = NULL;     /* always clear the attacker entry */

    /* if we berserk, we don't care about others - we attack all we can find */
    if (QUERY_FLAG(npc, FLAG_BERSERK)) {
        tmp = find_nearest_living_creature(npc);
        if (tmp)
            get_rangevector(npc, tmp, rv, 0);
        return tmp;
    }

    /* Here is the main enemy selection.
     * We want this: if there is an enemy, attack him until its not possible or
     * one of both is dead.
     * If we have no enemy and we are...
     * a monster: try to find a player, a pet or a friendly monster
     * a friendly: only target a monster which is targeting you first or targeting a player
     * a neutral: fight a attacker (but there should be none), then do nothing
     * a pet: attack player enemy or a monster
     */

    /* pet move */
    if ((npc->attack_movement&HI4) == PETMOVE) {
        tmp = get_pet_enemy(npc, rv);
        if (tmp)
            get_rangevector(npc, tmp, rv, 0);
        return tmp;
    }

    /* we check our old enemy. */
    if ((tmp = check_enemy(npc, rv)) == NULL) {
        if (attacker) { /* if we have an attacker, check him */
            /* we want be sure this is the right one! */
            if (attacker->count == npc->attacked_by_count) {
                /* TODO: thats not finished */
                /* we don't want a fight evil vs evil or good against non evil */
                if (QUERY_FLAG(npc, FLAG_NEUTRAL)
                || QUERY_FLAG(attacker, FLAG_NEUTRAL) /* neutral */
                || (QUERY_FLAG(npc, FLAG_FRIENDLY) && QUERY_FLAG(attacker, FLAG_FRIENDLY))
                || (!QUERY_FLAG(npc, FLAG_FRIENDLY) && (!QUERY_FLAG(attacker, FLAG_FRIENDLY) && attacker->type != PLAYER)))
                    CLEAR_FLAG(npc, FLAG_SLEEP); /* skip it, but lets wakeup */
                else if (on_same_map(npc, attacker)) { /* thats the only thing we must know... */
                    CLEAR_FLAG(npc, FLAG_SLEEP); /* well, NOW we really should wake up! */
                    npc->enemy = attacker;
                    get_rangevector(npc, attacker, rv, 0);
                    return attacker; /* yes, we face our attacker! */
                }
            }
        }

        /* we have no legal enemy or attacker, so we try to target a new one */
        if (!QUERY_FLAG(npc, FLAG_UNAGGRESSIVE)
        && !QUERY_FLAG(npc, FLAG_FRIENDLY)
        && !QUERY_FLAG(npc, FLAG_NEUTRAL)) {
            npc->enemy = get_nearest_player(npc);
            if (npc->enemy)
                tmp = check_enemy(npc, rv);
        }

    }

    return tmp;
}

static int check_wakeup(object *op, object *enemy, rv_vector *rv) {
    int radius = MAX(op->stats.Wis, MIN_MON_RADIUS);

    /* Trim work - if no enemy, no need to do anything below */
    if (!enemy)
        return 0;

    /* blinded monsters can only find nearby objects to attack */
    if (QUERY_FLAG(op, FLAG_BLIND))
        radius = MIN_MON_RADIUS;

    /* This covers the situation where the monster is in the dark
     * and has an enemy. If the enemy has no carried light (or isnt
     * glowing!) then the monster has trouble finding the enemy.
     * Remember we already checked to see if the monster can see in
     * the dark. */
    else if (op->map
    && op->map->darkness > 0
    && enemy
    && !enemy->invisible
    && !stand_in_light(enemy)
    && (!QUERY_FLAG(op, FLAG_SEE_IN_DARK) || !QUERY_FLAG(op, FLAG_SEE_INVISIBLE))) {
        int dark = radius/(op->map->darkness);

        radius = (dark > MIN_MON_RADIUS) ? (dark+1) : MIN_MON_RADIUS;
    } else if (!QUERY_FLAG(op, FLAG_SLEEP))
        return 1;

    /* enemy should already be on this map, so don't really need to check
     * for that.
     */
    if (rv->distance < (QUERY_FLAG(enemy, FLAG_STEALTH) ? (radius/2)+1 : radius)) {
        CLEAR_FLAG(op, FLAG_SLEEP);
        return 1;
    }
    return 0;
}

static int move_randomly(object *op) {
    int i;

    /* Give up to 15 chances for a monster to move randomly */
    for (i = 0; i < 15; i++) {
        if (move_object(op, RANDOM()%8+1))
            return 1;
    }
    return 0;
}

#define MAX_EXPLORE 5000

int compute_path(object *source, object *target, int default_dir) {
    char *path;
    int explore_x[MAX_EXPLORE], explore_y[MAX_EXPLORE];
    int current = 0, dir, max = 1, size, x, y, check_dir;

    if (target->map != source->map)
        return default_dir;

    /*    printf("compute_path (%d, %d) => (%d, %d)\n", source->x, source->y, target->x, target->y);*/

    size = source->map->width*source->map->height;
    path = calloc(size, sizeof(char));
    if (path == NULL) {
        fatal(OUT_OF_MEMORY);
    }
    explore_x[0] = target->x;
    explore_y[0] = target->y;

    while (current < max) {
        for (check_dir = 0; check_dir < 8; check_dir++) {
            dir = absdir(default_dir+check_dir);
            x = explore_x[current]+freearr_x[dir];
            y = explore_y[current]+freearr_y[dir];

            if (x == source->x && y == source->y) {
                /*          LOG(llevDebug, "compute_path => %d\n", absdir(dir+4));*/
                free(path);
                return absdir(dir+4);
            }

            if (OUT_OF_REAL_MAP(source->map, x, y))
                continue;
            if (ob_blocked(source, source->map, x, y))
                continue;

            assert(source->map->height*x+y >= 0);
            assert(source->map->height*x+y < size);

            if (path[source->map->height*x+y] == 0) {
                assert(max < MAX_EXPLORE);
                explore_x[max] = x;
                explore_y[max] = y;

                path[source->map->height*x+y] = absdir(dir+4);
                /*                printf("explore[%d] => (%d, %d) %d\n", max, x, y, path[source->map->height*x+y]);*/
                max++;
                if (max == MAX_EXPLORE) {
                    free(path);
                    return default_dir;
                }
            }
        }
        current++;
    }

    free(path);
    return default_dir;
}

static void monster_do_living(object *op) {
    assert(QUERY_FLAG(op, FLAG_MONSTER));

    /*  generate hp, if applicable */
    if (op->stats.Con > 0 && op->stats.hp < op->stats.maxhp) {
        /* last heal is in funny units.  Dividing by speed puts
         * the regeneration rate on a basis of time instead of
         * #moves the monster makes.  The scaling by 8 is
         * to capture 8th's of a hp fraction regens
         *
         * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
         * overflow might produce monsters with negative hp.
         */

        op->last_heal += (int)((float)(8*op->stats.Con)/FABS(op->speed));
        op->stats.hp = MIN((sint32)op->stats.hp+op->last_heal/32, op->stats.maxhp); /* causes Con/4 hp/tick */
        op->last_heal %= 32;

        /* So if the monster has gained enough HP that they are no longer afraid */
        if (QUERY_FLAG(op, FLAG_RUN_AWAY)
        && op->stats.hp >= (signed short)(((float)op->run_away/(float)100)*(float)op->stats.maxhp))
            CLEAR_FLAG(op, FLAG_RUN_AWAY);

        if (op->stats.hp > op->stats.maxhp)
            op->stats.hp = op->stats.maxhp;
    }

    /* generate sp, if applicable */
    if (op->stats.Pow > 0 && op->stats.sp < op->stats.maxsp) {
        /*  last_sp is in funny units.  Dividing by speed puts
         * the regeneration rate on a basis of time instead of
         * #moves the monster makes.  The scaling by 8 is
         * to capture 8th's of a sp fraction regens
         *
         * Cast to sint32 before comparing to maxhp since otherwise an (sint16)
         * overflow might produce monsters with negative sp.
         */

        op->last_sp += (int)((float)(8*op->stats.Pow)/FABS(op->speed));
        op->stats.sp = MIN(op->stats.sp+op->last_sp/128, op->stats.maxsp);  /* causes Pow/16 sp/tick */
        op->last_sp %= 128;
    }

    /* this should probably get modified by many more values.
    * (eg, creatures resistance to fear, level, etc. )
    */
    if (QUERY_FLAG(op, FLAG_SCARED) && !(RANDOM()%20)) {
        CLEAR_FLAG(op, FLAG_SCARED); /* Time to regain some "guts"... */
    }
}

static int monster_move_no_enemy(object *op) {
    assert(QUERY_FLAG(op, FLAG_MONSTER));

    if (QUERY_FLAG(op, FLAG_ONLY_ATTACK))  {
        remove_ob(op);
        free_object(op);
        return 1;
    }

    /* Probably really a bug for a creature to have both
       * stand still and a movement type set.
           */
    if (!QUERY_FLAG(op, FLAG_STAND_STILL))  {
        if (op->attack_movement&HI4) {
            switch (op->attack_movement&HI4) {
            case(PETMOVE):
                pet_move(op);
                break;

            case(CIRCLE1):
                circ1_move(op);
                break;

            case(CIRCLE2):
                circ2_move(op);
                break;

            case(PACEV):
                pace_movev(op);
                break;

            case(PACEH):
                pace_moveh(op);
                break;

            case(PACEV2):
                pace2_movev(op);
                break;

            case(PACEH2):
                pace2_moveh(op);
                break;

            case(RANDO):
                rand_move(op);
                break;

            case(RANDO2):
                move_randomly(op);
                break;
            }
            return 0;
        } else if (QUERY_FLAG(op, FLAG_RANDOM_MOVE))
            move_randomly(op);

    } /* stand still */

    return 0;
}

int move_monster(object *op) {
    int dir, diff;
    object *owner, *enemy, *part, *oph = op;
    rv_vector rv;

    /* Monsters not on maps don't do anything.  These monsters are things
     * Like royal guards in city dwellers inventories.
     */
    if (!op->map)
        return 0;

    /* for target facing, we copy this value here for fast access */
    if (oph->head)          /* force update the head - one arch one pic */
        oph = oph->head;

    if (QUERY_FLAG(op, FLAG_NO_ATTACK))  /* we never ever attack */
        enemy = op->enemy = NULL;
    else if ((enemy = find_enemy(op, &rv))) {
        /* we have an enemy, just tell him we want him dead */
        enemy->attacked_by = op;       /* our ptr */
        enemy->attacked_by_count = op->count; /* our tag */
    }

    if (QUERY_FLAG(op, FLAG_SLEEP)
    || QUERY_FLAG(op, FLAG_BLIND)
    || ((op->map->darkness > 0) && !QUERY_FLAG(op, FLAG_SEE_IN_DARK) && !QUERY_FLAG(op, FLAG_SEE_INVISIBLE))) {
        if (!check_wakeup(op, enemy, &rv))
            return 0;
    }

    /* check if monster pops out of hidden spot */
    if (op->hide)
        do_hidden_move(op);

    if (op->pick_up)
        monster_check_pickup(op);

    if (op->will_apply)
        monster_apply_below(op); /* Check for items to apply below */

    monster_do_living(op);

    /* If we don't have an enemy, do special movement or the like */
    if (!enemy) {
        return monster_move_no_enemy(op);
    } /* no enemy */

    /* We have an enemy.  Block immediately below is for pets */
    if ((op->attack_movement&HI4) == PETMOVE && (owner = get_owner(op)) != NULL && !on_same_map(op, owner)) {
        follow_owner(op, owner);
        /* If the pet was unable to follow the owner, free it */
        if (QUERY_FLAG(op, FLAG_REMOVED) && FABS(op->speed) > MIN_ACTIVE_SPEED) {
            remove_friendly_object(op);
            free_object(op);
            return 1;
        }
        return 0;
    }

    /* doppleganger code to change monster facing to that of the nearest
     * player.  Hmm.  The code is here, but no monster in the current
     * arch set uses it.
     */
    if ((op->race != NULL)&& strcmp(op->race, "doppleganger") == 0) {
        op->face = enemy->face;
        if (op->name)
            free_string(op->name);
        add_refcount(op->name = enemy->name);
    }

    /* Calculate range information for closest body part - this
     * is used for the 'skill' code, which isn't that smart when
     * it comes to figuring it out - otherwise, giants throw boulders
     * into themselves.
     */
    get_rangevector(op, enemy, &rv, 0);
    if (op->direction != rv.direction) {
        op->direction = rv.direction;
        op->facing = op->direction;
        if (op->animation_id)
            animate_object(op, op->direction);
    }

    /* Move the check for scared up here - if the monster was scared,
     * we were not doing any of the logic below, so might as well save
     * a few cpu cycles.
     */
    if (!QUERY_FLAG(op, FLAG_SCARED)) {
        rv_vector rv1;

        /* now we test every part of an object .... this is a real ugly piece of code */
        for (part = op; part != NULL; part = part->more) {
            get_rangevector(part, enemy, &rv1, 0x1);
            dir = rv1.direction;

            /* hm, not sure about this part - in original was a scared flag here too
             * but that we test above... so can be old code here
             */
            if (QUERY_FLAG(op, FLAG_RUN_AWAY))
                dir = absdir(dir+4);
            if (QUERY_FLAG(op, FLAG_CONFUSED))
                dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

            if (QUERY_FLAG(op, FLAG_CAST_SPELL) && !(RANDOM()%3)) {
                if (monster_cast_spell(op, part, enemy, dir, &rv1))
                    return 0;
            }

            if (QUERY_FLAG(op, FLAG_READY_SCROLL) && !(RANDOM()%3)) {
                if (monster_use_scroll(op, part, enemy, dir, &rv1))
                    return 0;
            }

            if (QUERY_FLAG(op, FLAG_READY_RANGE) && !(RANDOM()%3)) {
                if (monster_use_range(op, part, enemy, dir))
                    return 0;
            }
            if (QUERY_FLAG(op, FLAG_READY_SKILL) && !(RANDOM()%3)) {
                if (monster_use_skill(op, rv.part, enemy, rv.direction))
                    return 0;
            }
            if (QUERY_FLAG(op, FLAG_READY_BOW) && !(RANDOM()%2)) {
                if (monster_use_bow(op, part, enemy, dir))
                    return 0;
            }
        } /* for processing of all parts */
    } /* If not scared */


    /* code below is for when we didn't use a range attack or a skill, so
     * either move or hit with hth attack. */

    part = rv.part;
    dir = rv.direction;

    if (QUERY_FLAG(op, FLAG_SCARED) || QUERY_FLAG(op, FLAG_RUN_AWAY))
        dir = absdir(dir+4);
    else if (!can_hit(part, enemy, &rv))
        dir = compute_path(op, enemy, rv.direction);

    if (QUERY_FLAG(op, FLAG_CONFUSED))
        dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

    if ((op->attack_movement&LO4) && !QUERY_FLAG(op, FLAG_SCARED)) {
        switch (op->attack_movement&LO4) {
        case DISTATT:
            dir = dist_att(dir, op, enemy, part, &rv);
            break;

        case RUNATT:
            dir = run_att(dir, op, enemy, part, &rv);
            break;

        case HITRUN:
            dir = hitrun_att(dir, op, enemy);
            break;

        case WAITATT:
            dir = wait_att(dir, op, enemy, part, &rv);
            break;

        case RUSH: /* default - monster normally moves towards player */
        case ALLRUN:
            break;

        case DISTHIT:
            dir = disthit_att(dir, op, enemy, part, &rv);
            break;

        case WAIT2:
            dir = wait_att2(dir, op, enemy, part, &rv);
            break;

        default:
            LOG(llevDebug, "Illegal low mon-move: %d\n", op->attack_movement&LO4);
        }
    }

    if (!dir)
        return 0;

    if (!QUERY_FLAG(op, FLAG_STAND_STILL)) {
        if (move_object(op, dir)) /* Can the monster move directly toward player? */
            return 0;

        if (QUERY_FLAG(op, FLAG_SCARED)
        || !can_hit(part, enemy, &rv)
        || QUERY_FLAG(op, FLAG_RUN_AWAY)) {
            /* Try move around corners if !close */
            int maxdiff = (QUERY_FLAG(op, FLAG_ONLY_ATTACK) || RANDOM()&1) ? 1 : 2;
            for (diff = 1; diff <= maxdiff; diff++) {
                /* try different detours */
                int m = 1-(RANDOM()&2);          /* Try left or right first? */
                if (move_object(op, absdir(dir+diff*m))
                || move_object(op, absdir(dir-diff*m)))
                    return 0;
            }
        }
    } /* if monster is not standing still */

    /*
     * Eneq(@csd.uu.se): Patch to make RUN_AWAY or SCARED monsters move a random
     * direction if they can't move away.
     */
    if (!QUERY_FLAG(op, FLAG_ONLY_ATTACK)
    && (QUERY_FLAG(op, FLAG_RUN_AWAY) || QUERY_FLAG(op, FLAG_SCARED)))
        if (move_randomly(op))
            return 0;

    /*
     * Try giving the monster a new enemy - the player that is closest
     * to it.  In this way, it won't just keep trying to get to a target
     * that is inaccessible.
     * This could be more clever - it should go through a list of several
     * enemies, as it is now, you could perhaps get situations where there
     * are two players flanking the monster at close distance, but which
     * the monster can't get to, and a third one at a far distance that
     * the monster could get to - as it is, the monster won't look at that
     * third one.
     */
    if (!QUERY_FLAG(op, FLAG_FRIENDLY) && enemy == op->enemy) {
        object *nearest_player = get_nearest_player(op);

        if (nearest_player && nearest_player != enemy && !can_hit(part, enemy, &rv)) {
            op->enemy = NULL;
            enemy = nearest_player;
        }
    }

    if (!QUERY_FLAG(op, FLAG_SCARED) && can_hit(part, enemy, &rv)) {
        /* The adjustement to wc that was here before looked totally bogus -
         * since wc can in fact get negative, that would mean by adding
         * the current wc, the creature gets better?  Instead, just
         * add a fixed amount - nasty creatures that are runny away should
         * still be pretty nasty.
         */
        if (QUERY_FLAG(op, FLAG_RUN_AWAY)) {
            part->stats.wc += 10;
            (void)skill_attack(enemy, part, 0, NULL, NULL);
            part->stats.wc -= 10;
        } else
            (void)skill_attack(enemy, part, 0, NULL, NULL);
    } /* if monster is in attack range */

    if (QUERY_FLAG(part, FLAG_FREED))   /* Might be freed by ghost-attack or hit-back */
        return 1;

    if (QUERY_FLAG(op, FLAG_ONLY_ATTACK)) {
        remove_ob(op);
        free_object(op);
        return 1;
    }
    return 0;
}

static int can_hit(object *ob1, object *ob2, rv_vector *rv) {
    object *more;
    rv_vector rv1;

    if (QUERY_FLAG(ob1, FLAG_CONFUSED)&&!(RANDOM()%3))
        return 0;

    if (abs(rv->distance_x) < 2 && abs(rv->distance_y) < 2)
        return 1;

    /* check all the parts of ob2 - just because we can't get to
     * its head doesn't mean we don't want to pound its feet
     */
    for (more = ob2->more; more != NULL; more = more->more) {
        get_rangevector(ob1, more, &rv1, 0);
        if (abs(rv1.distance_x) < 2 && abs(rv1.distance_y) < 2)
            return 1;
    }
    return 0;
}

static int monster_should_cast_spell(object *monster, object *spell_ob) {
    if (spell_ob->subtype == SP_BOLT
    || spell_ob->subtype == SP_BULLET
    || spell_ob->subtype == SP_EXPLOSION
    || spell_ob->subtype == SP_CONE
    || spell_ob->subtype == SP_BOMB
    || spell_ob->subtype == SP_SMITE
    || spell_ob->subtype == SP_MAGIC_MISSILE
    || spell_ob->subtype == SP_SUMMON_GOLEM
    || spell_ob->subtype == SP_MAGIC_WALL
    || spell_ob->subtype == SP_SUMMON_MONSTER
    || spell_ob->subtype == SP_MOVING_BALL
    || spell_ob->subtype == SP_SWARM
    || spell_ob->subtype == SP_INVISIBLE)
        return 1;

    return 0;
}

#define MAX_KNOWN_SPELLS 20

static object *monster_choose_random_spell(object *monster) {
    object *altern[MAX_KNOWN_SPELLS];
    object *tmp;
    int i = 0;

    for (tmp = monster->inv; tmp != NULL; tmp = tmp->below)
        if (tmp->type == SPELLBOOK || tmp->type == SPELL) {
            /* Check and see if it's actually a useful spell.
             * If its a spellbook, the spell is actually the inventory item.
             * if it is a spell, then it is just the object itself.
             */
            if (monster_should_cast_spell(monster, (tmp->type == SPELLBOOK) ? tmp->inv : tmp)) {
                altern[i++] = tmp;
                if (i == MAX_KNOWN_SPELLS)
                    break;
            }
        }
    if (!i)
        return NULL;
    return altern[RANDOM()%i];
}

static int monster_cast_spell(object *head, object *part, object *pl, int dir, rv_vector *rv) {
    object *spell_item;
    object *owner;
    rv_vector rv1;

    /* If you want monsters to cast spells over friends, this spell should
     * be removed.  It probably should be in most cases, since monsters still
     * don't care about residual effects (ie, casting a cone which may have a
     * clear path to the player, the side aspects of the code will still hit
     * other monsters)
     */
    if (!(dir = path_to_player(part, pl, 0)))
        return 0;

    if (QUERY_FLAG(head, FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
        get_rangevector(head, owner, &rv1, 0x1);
        if (dirdiff(dir, rv1.direction) < 2) {
            return 0; /* Might hit owner with spell */
        }
    }

    if (QUERY_FLAG(head, FLAG_CONFUSED))
        dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

    /* If the monster hasn't already chosen a spell, choose one
     * I'm not sure if it really make sense to pre-select spells (events
     * could be different by the time the monster goes again).
     */
    if (head->spellitem == NULL) {
        if ((spell_item = monster_choose_random_spell(head)) == NULL) {
            LOG(llevMonster, "Turned off spells in %s\n", head->name);
            CLEAR_FLAG(head, FLAG_CAST_SPELL); /* Will be turned on when picking up book */
            return 0;
        }
        if (spell_item->type == SPELLBOOK) {
            if (!spell_item->inv) {
                LOG(llevError, "spellbook %s does not contain a spell?\n", spell_item->name);
                return 0;
            }
            spell_item = spell_item->inv;
        }
    } else
        spell_item = head->spellitem;

    if (!spell_item)
        return 0;

    /* Best guess this is a defensive/healing spell */
    if (spell_item->range <= 1 || spell_item->stats.dam < 0)
        dir = 0;

    /* Monster doesn't have enough spell-points */
    if (head->stats.sp < SP_level_spellpoint_cost(head, spell_item, SPELL_MANA))
        return 0;

    if (head->stats.grace < SP_level_spellpoint_cost(head, spell_item, SPELL_GRACE))
        return 0;

    head->stats.sp -= SP_level_spellpoint_cost(head, spell_item, SPELL_MANA);
    head->stats.grace -= SP_level_spellpoint_cost(head, spell_item, SPELL_GRACE);

    /* set this to null, so next time monster will choose something different */
    head->spellitem = NULL;

    return cast_spell(part, part, dir, spell_item, NULL);
}

static int monster_use_scroll(object *head, object *part, object *pl, int dir, rv_vector *rv) {
    object *scroll;
    object *owner;
    rv_vector rv1;

    /* If you want monsters to cast spells over friends, this spell should
     * be removed.  It probably should be in most cases, since monsters still
     * don't care about residual effects (ie, casting a cone which may have a
     * clear path to the player, the side aspects of the code will still hit
     * other monsters)
     */
    if (!(dir = path_to_player(part, pl, 0)))
        return 0;

    if (QUERY_FLAG(head, FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
        get_rangevector(head, owner, &rv1, 0x1);
        if (dirdiff(dir, rv1.direction) < 2) {
            return 0; /* Might hit owner with spell */
        }
    }

    if (QUERY_FLAG(head, FLAG_CONFUSED))
        dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

    for (scroll = head->inv; scroll; scroll = scroll->below)
        if (scroll->type == SCROLL && monster_should_cast_spell(head, scroll->inv))
            break;

    /* Used up all his scrolls, so nothing do to */
    if (!scroll) {
        CLEAR_FLAG(head, FLAG_READY_SCROLL);
        return 0;
    }

    /* Spell should be cast on caster (ie, heal, strength) */
    if (scroll->inv->range == 0)
        dir = 0;

    /* Face the direction that we want to cast. */
    head->direction = dir;
    head->facing = head->direction;
    if (head->animation_id)
        animate_object(head, head->direction);

    ob_apply(scroll, part, 0);
    return 1;
}

static int monster_use_skill(object *head, object *part, object *pl, int dir) {
    object *skill, *owner;

    if (!(dir = path_to_player(part, pl, 0)))
        return 0;

    if (QUERY_FLAG(head, FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
        int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
        if (dirdiff(dir, dir2) < 1)
            return 0; /* Might hit owner with skill -thrown rocks for example ?*/
    }
    if (QUERY_FLAG(head, FLAG_CONFUSED))
        dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

    /* skill selection - monster will use the next unused skill.
     * well...the following scenario will allow the monster to
     * toggle between 2 skills. One day it would be nice to make
     * more skills available to monsters.
     */

    for (skill = head->inv; skill != NULL; skill = skill->below)
        if (skill->type == SKILL && skill != head->chosen_skill) {
            head->chosen_skill = skill;
            break;
        }

    if (!skill && !head->chosen_skill) {
        LOG(llevDebug, "Error: Monster %s (%d) has FLAG_READY_SKILL without skill.\n", head->name, head->count);
        CLEAR_FLAG(head, FLAG_READY_SKILL);
        return 0;
    }
    /* use skill */
    return do_skill(head, part, head->chosen_skill, dir, NULL);
}

static int monster_use_range(object *head, object *part, object *pl, int dir) {
    object *wand, *owner;
    int at_least_one = 0;

    if (!(dir = path_to_player(part, pl, 0)))
        return 0;

    if (QUERY_FLAG(head, FLAG_FRIENDLY) && (owner = get_owner(head)) != NULL) {
        int dir2 = find_dir_2(head->x-owner->x, head->y-owner->y);
        if (dirdiff(dir, dir2) < 2)
            return 0; /* Might hit owner with spell */
    }
    if (QUERY_FLAG(head, FLAG_CONFUSED))
        dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

    for (wand = head->inv; wand != NULL; wand = wand->below) {
        if (wand->type == WAND) {
            /* Found a wand, let's see if it has charges left */
            at_least_one = 1;
            if (wand->stats.food <= 0)
                continue;

            cast_spell(head, wand, dir, wand->inv, NULL);
            drain_wand_charge(wand);

            /* Success */
            return 1;
        } else if (wand->type == ROD || wand->type == HORN) {
            /* Found rod/horn, let's use it if possible */
            at_least_one = 1;
            if (wand->stats.hp < MAX(wand->inv->stats.sp, wand->inv->stats.grace))
                continue;

            /* drain charge before casting spell - can be a case where the
             * spell destroys the monster, and rod, so if done after, results
             * in crash.
             */
            drain_rod_charge(wand);
            cast_spell(head, wand, dir, wand->inv, NULL);

            /* Success */
            return 1;
        }
    }

    if (at_least_one)
        return 0;

    LOG(llevError, "Error: Monster %s (%d) HAS_READY_RANG() without wand/horn/rod.\n", head->name, head->count);
    CLEAR_FLAG(head, FLAG_READY_RANGE);
    return 0;
}

static int monster_use_bow(object *head, object *part, object *pl, int dir) {
    object *owner;
    rv_vector rv;
    sint16 x, y;
    mapstruct *map;

    get_rangevector(part, pl, &rv, 1);
    if (rv.distance > 100)
        /* Too far */
        return 0;
    if (rv.distance_x != 0 && rv.distance_y != 0 && abs(rv.distance_x) != abs(rv.distance_y))
        /* Player must be on same horizontal, vertical or diagonal line. */
        return 0;
    dir = absdir(find_dir_2(rv.distance_x, rv.distance_y)+4);

    if (QUERY_FLAG(head, FLAG_FRIENDLY))
        owner = get_owner(head);
    else
        owner = NULL;

    /* The monster can possibly fire, let's see if the path is ok for an arrow. */
    x = part->x;
    y = part->y;
    map = part->map;
    while (x != pl->x || y != pl->y || map != pl->map) {
        x += freearr_x[dir];
        y += freearr_y[dir];
        map = get_map_from_coord(map, &x, &y);
        if (!map) {
            LOG(llevError, "monster_use_bow: no map but still path exists??\n");
            return 0;
        }
        if ((GET_MAP_MOVE_BLOCK(map, x, y)&MOVE_FLY_LOW) == MOVE_FLY_LOW)
            return 0;
        if (owner && owner->x == x && owner->y == y && owner->map == map)
            /* Don't hit owner! */
            return 0;
    }

    /* Finally, path is clear, can fire. */

    if (QUERY_FLAG(head, FLAG_CONFUSED))
        dir = absdir(dir+RANDOM()%3+RANDOM()%3-2);

    /* in server/player.c */
    return fire_bow(head, NULL, dir, 0, part->x, part->y);
}

static int check_good_weapon(object *who, object *item) {
    object *other_weap;
    int val = 0, i;

    for (other_weap = who->inv; other_weap != NULL; other_weap = other_weap->below)
        if (other_weap->type == item->type && QUERY_FLAG(other_weap, FLAG_APPLIED))
            break;

    if (other_weap == NULL) /* No other weapons */
        return 1;

    /* Rather than go through and apply the new one, and see if it is
     * better, just do some simple checks
     * Put some multipliers for things that hvae several effects,
     * eg, magic affects both damage and wc, so it has more weight
     */

    val = item->stats.dam-other_weap->stats.dam;
    val += (item->magic-other_weap->magic)*3;
    /* Monsters don't really get benefits from things like regen rates
     * from items.  But the bonus for their stats are very important.
     */
    for (i = 0; i < NUM_STATS; i++)
        val += (get_attr_value(&item->stats, i)-get_attr_value(&other_weap->stats, i))*2;

    if (val > 0)
        return 1;
    else
        return 0;
}

static int check_good_armour(object *who, object *item) {
    object *other_armour;
    int val = 0, i;

    for (other_armour = who->inv; other_armour != NULL; other_armour = other_armour->below)
        if (other_armour->type == item->type && QUERY_FLAG(other_armour, FLAG_APPLIED))
            break;

    if (other_armour == NULL) /* No other armour, use the new */
        return 1;

    /* Like above function , see which is better */
    val = item->stats.ac-other_armour->stats.ac;
    val = (item->resist[ATNR_PHYSICAL]-other_armour->resist[ATNR_PHYSICAL])/5;
    val += (item->magic-other_armour->magic)*3;

    /* for the other protections, do weigh them very much in the equation -
     * it is the armor protection which is most important, because there is
     * no good way to know what the player may attack the monster with.
     * So if the new item has better protection than the old, give that higher
     * value.  If the reverse, then decrease the value of this item some.
     */
    for (i = 1; i < NROFATTACKS; i++) {
        if (item->resist[i] > other_armour->resist[i])
            val++;
        else if (item->resist[i] < other_armour->resist[i])
            val--;
    }

    /* Very few armours have stats, so not much need to worry about those. */

    if (val > 0)
        return 1;
    else
        return 0;

}

static void monster_check_pickup(object *monster) {
    object *tmp, *next;
    int next_tag;

    for (tmp = monster->below; tmp != NULL; tmp = next) {
        next = tmp->below;
        next_tag = next ? next->count : 0;
        if (monster_can_pick(monster, tmp)) {
            remove_ob(tmp);
            tmp = insert_ob_in_ob(tmp, monster);
            (void)monster_check_apply(monster, tmp);
        }
        /* We could try to re-establish the cycling, of the space, but probably
         * not a big deal to just bail out.
         */
        if (next && was_destroyed(next, next_tag))
            return;
    }
}

/*
 * monster_can_pick(): If the monster is interested in picking up
 * the item, then return 0.  Otherwise 0.
 * Instead of pick_up, flags for "greed", etc, should be used.
 * I've already utilized flags for bows, wands, rings, etc, etc. -Frank.
 */

static int monster_can_pick(object *monster, object *item) {
    int flag = 0;
    int i;

    if (!can_pick(monster, item))
        return 0;

    if (QUERY_FLAG(item, FLAG_UNPAID))
        return 0;

    if (monster->pick_up&64)           /* All */
        flag = 1;

    else {
        if (IS_WEAPON(item))
            flag = (monster->pick_up&8) || QUERY_FLAG(monster, FLAG_USE_WEAPON);
        else if (IS_ARMOR(item))
            flag = (monster->pick_up&16) || QUERY_FLAG(monster, FLAG_USE_ARMOUR);
        else if (IS_SHIELD(item))
            flag = (monster->pick_up&16) || QUERY_FLAG(monster, FLAG_USE_SHIELD);
        else switch (item->type) {
            case MONEY:
            case GEM:
                flag = monster->pick_up&2;
                break;

            case FOOD:
                flag = monster->pick_up&4;
                break;

            case SKILL:
                flag = QUERY_FLAG(monster, FLAG_CAN_USE_SKILL);
                break;

            case RING:
                flag = QUERY_FLAG(monster, FLAG_USE_RING);
                break;

            case WAND:
            case HORN:
            case ROD:
                flag = QUERY_FLAG(monster, FLAG_USE_RANGE);
                break;

            case SPELLBOOK:
                flag = (monster->arch != NULL && QUERY_FLAG((&monster->arch->clone), FLAG_CAST_SPELL));
                break;

            case SCROLL:
                flag = QUERY_FLAG(monster, FLAG_USE_SCROLL);
                break;

            case BOW:
            case ARROW:
                flag = QUERY_FLAG(monster, FLAG_USE_BOW);
                break;
            }
        /* Simplistic check - if the monster has a location to equip it, he will
         * pick it up.  Note that this doesn't handle cases where an item may
         * use several locations.
         */
        for (i = 0; i < NUM_BODY_LOCATIONS; i++) {
            if (monster->body_info[i] && item->body_info[i]) {
                flag = 1;
                break;
            }
        }
    }

    if (((!(monster->pick_up&32)) && flag) || ((monster->pick_up&32) && (!flag)))
        return 1;
    return 0;
}

/*
 * monster_apply_below():
 * Vick's (vick@bern.docs.uu.se) @921107 -> If a monster who's
 * eager to apply things, encounters something apply-able,
 * then make him apply it
 */
static void monster_apply_below(object *monster) {
    object *tmp, *next;

    for (tmp = monster->below; tmp != NULL; tmp = next) {
        next = tmp->below;
        switch (tmp->type) {
        case CF_HANDLE:
        case TRIGGER:
            if (monster->will_apply&WILL_APPLY_HANDLE)
                manual_apply(monster, tmp, 0);
            break;

        case TREASURE:
            if (monster->will_apply&WILL_APPLY_TREASURE)
                manual_apply(monster, tmp, 0);
            break;
        }
        if (QUERY_FLAG(tmp, FLAG_IS_FLOOR))
            break;
    }
}

/*
 * monster_check_apply() is meant to be called after an item is
 * inserted in a monster.
 * If an item becomes outdated (monster found a better item),
 * a pointer to that object is returned, so it can be dropped.
 * (so that other monsters can pick it up and use it)
 * Note that as things are now, monsters never drop something -
 * they can pick up all that they can use.
 */

/* Sept 96, fixed this so skills will be readied -b.t.*/

void monster_check_apply(object *mon, object *item) {
    int flag = 0;

    if (item->type == SPELLBOOK
    && mon->arch != NULL
    && (QUERY_FLAG((&mon->arch->clone), FLAG_CAST_SPELL))) {
        SET_FLAG(mon, FLAG_CAST_SPELL);
        return;
    }

    /* If for some reason, this item is already applied, no more work to do */
    if (QUERY_FLAG(item, FLAG_APPLIED))
        return;

    /* Might be better not to do this - if the monster can fire a bow,
     * it is possible in his wanderings, he will find one to use.  In
     * which case, it would be nice to have ammo for it.
     */
    if (QUERY_FLAG(mon, FLAG_USE_BOW) && item->type == ARROW) {
        /* Check for the right kind of bow */
        object *bow;

        for (bow = mon->inv; bow != NULL; bow = bow->below)
            if (bow->type == BOW && bow->race == item->race) {
                SET_FLAG(mon, FLAG_READY_BOW);
                LOG(llevMonster, "Found correct bow for arrows.\n");
                return;     /* nothing more to do for arrows */
            }
    }

    if (item->type == TREASURE && mon->will_apply&WILL_APPLY_TREASURE)
        flag = 1;
    /* Eating food gets hp back */
    else if (item->type == FOOD && mon->will_apply&WILL_APPLY_FOOD)
        flag = 1;
    else if (item->type == SCROLL && QUERY_FLAG(mon, FLAG_USE_SCROLL)) {
        if (!item->inv)
            LOG(llevDebug, "Monster %d having scroll %d with empty inventory!\n", mon->count, item->count);
        else if (monster_should_cast_spell(mon, item->inv))
            SET_FLAG(mon, FLAG_READY_SCROLL);
        /* Don't use it right now */
        return;
    } else if (item->type == WEAPON)
        flag = check_good_weapon(mon, item);
    else if (IS_ARMOR(item) || IS_SHIELD(item))
        flag = check_good_armour(mon, item);
    /* Should do something more, like make sure this is a better item */
    else if (item->type == RING)
        flag = 1;
    else if (item->type == WAND || item->type == ROD || item->type == HORN) {
        /* We never really 'ready' the wand/rod/horn, because that would mean the
        * weapon would get undone.
        */
        if (!(can_apply_object(mon, item)&CAN_APPLY_NOT_MASK)) {
            SET_FLAG(mon, FLAG_READY_RANGE);
            SET_FLAG(item, FLAG_APPLIED);
        }
        return;
    } else if (item->type == BOW) {
        /* We never really 'ready' the bow, because that would mean the
        * weapon would get undone.
        */
        if (!(can_apply_object(mon, item)&CAN_APPLY_NOT_MASK))
            SET_FLAG(mon, FLAG_READY_BOW);
        return;
    } else if (item->type == SKILL) {
        /*
         * skills are specials: monsters must have the 'FLAG_READY_SKILL' flag set,
         * else they can't use the skill...
         * Skills also don't need to get applied, so return now.
         */
        SET_FLAG(mon, FLAG_READY_SKILL);
        return;
    }

    /* if we don't match one of the above types, return now.
     * can_apply_object will say that we can apply things like flesh,
     * bolts, and whatever else, because it only checks against the
     * body_info locations.
     */
    if (!flag)
        return;

    /* Check to see if the monster can use this item.  If not, no need
     * to do further processing.  Note that can_apply_object already checks
     * for the CAN_USE flags.
     */
    if (can_apply_object(mon, item)&CAN_APPLY_NOT_MASK)
        return;

    /* should only be applying this item, not unapplying it.
     * also, ignore status of curse so they can take off old armour.
     * monsters have some advantages after all.
     */
    manual_apply(mon, item, AP_APPLY|AP_IGNORE_CURSE);
    return;
}

void npc_call_help(object *op) {
    int x, y, mflags;
    object *npc;
    sint16 sx, sy;
    mapstruct *m;

    for (x = -3; x < 4; x++)
        for (y = -3; y < 4; y++) {
            m = op->map;
            sx = op->x+x;
            sy = op->y+y;
            mflags = get_map_flags(m, &m, sx, sy, &sx, &sy);
            /* If nothing alive on this space, no need to search the space. */
            if ((mflags&P_OUT_OF_MAP) || !(mflags&P_IS_ALIVE))
                continue;

            for (npc = GET_MAP_OB(m, sx, sy); npc != NULL; npc = npc->above)
                if (QUERY_FLAG(npc, FLAG_ALIVE) && QUERY_FLAG(npc, FLAG_UNAGGRESSIVE))
                    npc->enemy = op->enemy;
        }
}

static int dist_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv) {
    if (can_hit(part, enemy, rv))
        return dir;
    if (rv->distance < 10)
        return absdir(dir+4);
    else if (rv->distance > 18)
        return dir;
    return 0;
}

static int run_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv) {
    if ((can_hit(part, enemy, rv) && ob->move_status < 20) || ob->move_status < 20) {
        ob->move_status++;
        return (dir);
    } else if (ob->move_status > 20)
        ob->move_status = 0;
    return absdir(dir+4);
}

static int hitrun_att(int dir, object *ob, object *enemy) {
    if (ob->move_status++ < 25)
        return dir;
    else if (ob->move_status < 50)
        return absdir(dir+4);
    else
        ob->move_status = 0;
    return absdir(dir+4);
}

static int wait_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv) {
    int inrange = can_hit(part, enemy, rv);

    if (ob->move_status || inrange)
        ob->move_status++;

    if (ob->move_status == 0)
        return 0;
    else if (ob->move_status < 10)
        return dir;
    else if (ob->move_status < 15)
        return absdir(dir+4);
    ob->move_status = 0;
    return 0;
}

static int disthit_att(int dir, object *ob, object *enemy, object *part, rv_vector *rv) {
    /* The logic below here looked plain wrong before.  Basically, what should
     * happen is that if the creatures hp percentage falls below run_away,
     * the creature should run away (dir+4)
     * I think its wrong for a creature to have a zero maxhp value, but
     * at least one map has this set, and whatever the map contains, the
     * server should try to be resilant enough to avoid the problem
     */
    if (ob->stats.maxhp && (ob->stats.hp*100)/ob->stats.maxhp < ob->run_away)
        return absdir(dir+4);
    return dist_att(dir, ob, enemy, part, rv);
}

static int wait_att2(int dir, object *ob, object *enemy, object *part, rv_vector *rv) {
    if (rv->distance < 9)
        return absdir(dir+4);
    return 0;
}

static void circ1_move(object *ob) {
    static const int circle [12] = { 3, 3, 4, 5, 5, 6, 7, 7, 8, 1, 1, 2 };

    if (++ob->move_status > 11)
        ob->move_status = 0;
    if (!(move_object(ob, circle[ob->move_status])))
        (void)move_object(ob, RANDOM()%8+1);
}

static void circ2_move(object *ob) {
    static const int circle[20] = { 3, 3, 3, 4, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 1, 1, 1, 2, 2 };

    if (++ob->move_status > 19)
        ob->move_status = 0;
    if (!(move_object(ob, circle[ob->move_status])))
        (void)move_object(ob, RANDOM()%8+1);
}

static void pace_movev(object *ob) {
    if (ob->move_status++ > 6)
        ob->move_status = 0;
    if (ob->move_status < 4)
        (void)move_object(ob, 5);
    else
        (void)move_object(ob, 1);
}

static void pace_moveh(object *ob) {
    if (ob->move_status++ > 6)
        ob->move_status = 0;
    if (ob->move_status < 4)
        (void)move_object(ob, 3);
    else
        (void)move_object(ob, 7);
}

static void pace2_movev(object *ob) {
    if (ob->move_status++ > 16)
        ob->move_status = 0;
    if (ob->move_status < 6)
        (void)move_object(ob, 5);
    else if (ob->move_status < 8)
        return;
    else if (ob->move_status < 13)
        (void)move_object(ob, 1);
    else
        return;
}

static void pace2_moveh(object *ob) {
    if (ob->move_status++ > 16)
        ob->move_status = 0;
    if (ob->move_status < 6)
        (void)move_object(ob, 3);
    else if (ob->move_status < 8)
        return;
    else if (ob->move_status < 13)
        (void)move_object(ob, 7);
    else
        return;
}

static void rand_move(object *ob) {
    int i;

    if (ob->move_status < 1
    || ob->move_status > 8
    || !(move_object(ob, ob->move_status || !(RANDOM()%9))))
        for (i = 0; i < 5; i++)
            if (move_object(ob, ob->move_status = RANDOM()%8+1))
                return;
}

void check_earthwalls(object *op, mapstruct *m, int x, int y) {
    object *tmp;

    for (tmp = GET_MAP_OB(m, x, y); tmp != NULL; tmp = tmp->above) {
        if (tmp->type == EARTHWALL) {
            hit_player(tmp, op->stats.dam, op, AT_PHYSICAL, 1);
            return;
        }
    }
}

void check_doors(object *op, mapstruct *m, int x, int y) {
    object *tmp;

    for (tmp = GET_MAP_OB(m, x, y); tmp != NULL; tmp = tmp->above) {
        if (tmp->type == DOOR) {
            hit_player(tmp, 1000, op, AT_PHYSICAL, 1);
            return;
        }
    }
}

void communicate(object *op, const char *txt) {
    object *npc;
    int i, mflags, talked = 0;
    sint16 x, y;
    mapstruct *mp, *orig_map = op->map;
    char buf[MAX_BUF];

    snprintf(buf, sizeof(buf), "%s says: %s", op->name, txt);
    if (op->type == PLAYER) {
        ext_info_map(NDI_WHITE, op->map, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_SAY, buf, NULL);
    }

    /* Note that this loop looks pretty inefficient to me - we look and try to talk
     * to every object within 2 spaces.  It would seem that if we trim this down to
     * only try to talk to objects with npc->msg set, things would be a lot more efficient,
     * but I'm not sure if there are any objects out there that don't have a message and instead
     * rely sorely on events - MSW 2009-04-14
     */
    for (i = 0; i <= SIZEOFFREE2; i++) {
        mp = op->map;
        x = op->x+freearr_x[i];
        y = op->y+freearr_y[i];

        mflags = get_map_flags(mp, &mp, x, y, &x, &y);
        if (mflags&P_OUT_OF_MAP)
            continue;

        for (npc = GET_MAP_OB(mp, x, y); npc != NULL; npc = npc->above) {
            talk_to_npc(op, npc, txt, &talked);
            if (orig_map != op->map) {
                LOG(llevDebug, "Warning: Forced to swap out very recent map - MAX_OBJECTS should probably be increased\n");
                return;
            }
        }
    }

    /* if talked is set, then the talk_to_npc() wrote out this information, so
     * don't do it again.
     */
    if (!talked) {
    }
}

static int do_talk_npc(object *op, object *npc, const char *txt, int *talked) {
    char buf[MAX_BUF];
    struct_dialog_reply *reply;
    struct_dialog_message *message;

    if (!get_dialog_message(npc, txt, &message, &reply))
        return 0;

    if (reply) {
        snprintf(buf, sizeof(buf), "%s %s: %s", op->name, (reply->type == rt_reply ? "replies" : "asks"), reply->message);
        ext_info_map(NDI_WHITE, op->map, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_SAY, buf, NULL);
        *talked = 1;
    }
#if 0
    /* let the caller handle this reply - no reason we need to.  Leaving this in for the
     * time being, as I don't completely understand what all of this is trying to do.
     * MSW 2009-04-14
     */

    else if (!*talked) {
        *talked = 1;
        snprintf(buf, sizeof(buf), "%s says: %s", op->name, txt);
        ext_info_map(NDI_WHITE, op->map, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_SAY, buf, NULL);
    }
#endif

    if (npc->type == MAGIC_EAR) {
        ext_info_map(NDI_NAVY|NDI_UNIQUE, npc->map, MSG_TYPE_DIALOG, MSG_TYPE_DIALOG_MAGIC_MOUTH, message->message, NULL);
        use_trigger(npc);
    } else {
        npc_say(npc, message->message);
        reply = message->replies;

        if (reply) {
            draw_ext_info(NDI_WHITE, 0, op, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_SAY, "Replies:", NULL);
            while (reply) {
                draw_ext_info_format(NDI_WHITE, 0, op, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_SAY, " - %s: %s", NULL, reply->reply, reply->message);
                reply = reply->next;
            }
        }
    }

    return 1;
}

void npc_say(object *npc, const char *cp) {
    char buf[HUGE_BUF], name[MAX_BUF];

    query_name(npc, name, sizeof(name));
    snprintf(buf, sizeof(buf), "%s says: %s", name, cp);
    ext_info_map(NDI_NAVY|NDI_UNIQUE, npc->map, MSG_TYPE_DIALOG, MSG_TYPE_DIALOG_NPC,
                 buf, buf);
}

static int talk_to_npc(object *op, object *npc, const char *txt, int *talked) {
    object *cobj;

    /* Move this commone area up here - shouldn't cost much extra cpu
     * time, and makes the function more readable */
    /* Lauwenmark: Handle for plugin say event */
    if (execute_event(npc, EVENT_SAY, op, NULL, txt, SCRIPT_FIX_ALL) != 0)
        return 0;
    /* Lauwenmark - Here we let the objects inside inventories hear and answer, too. */
    /* This allows the existence of "intelligent" weapons you can discuss with */
    for (cobj = npc->inv; cobj != NULL; cobj = cobj->below) {
        if (execute_event(cobj, EVENT_SAY, npc, NULL, txt, SCRIPT_FIX_ALL) != 0)
            return 0;
    }
    if (op == npc)
        return 0;
    return do_talk_npc(op, npc, txt, talked);
}

/* find_mon_throw_ob() - modeled on find_throw_ob
 * This is probably overly simplistic as it is now - We want
 * monsters to throw things like chairs and other pieces of
 * furniture, even if they are not good throwable objects.
 * Probably better to have the monster throw a throwable object
 * first, then throw any non equipped weapon.
 */
object *find_mon_throw_ob(object *op) {
    object *tmp = NULL;

    if (op->head)
        tmp = op->head;
    else
        tmp = op;

    /* New throw code: look through the inventory. Grap the first legal is_thrown
     * marked item and throw it to the enemy.
     */

    for (tmp = op->inv; tmp; tmp = tmp->below) {
        /* Can't throw invisible objects or items that are applied */
        if (tmp->invisible || QUERY_FLAG(tmp, FLAG_APPLIED))
            continue;

        if (QUERY_FLAG(tmp, FLAG_IS_THROWN))
            break;
    }

#ifdef DEBUG_THROW
    {
        char what[MAX_BUF];

        query_name(tmp, what, MAX_BUF);
        LOG(llevDebug, "%s chooses to throw: %s (%d)\n", op->name, !(tmp) ? "(nothing)" : what, tmp ? tmp->count : -1);
    }
#endif

    return tmp;
}

/* determine if we can 'detect' the enemy. Check for walls blocking the
 * los. Also, just because its hidden/invisible, we may be sensitive/smart
 * enough (based on Wis & Int) to figure out where the enemy is. -b.t.
 * modified by MSW to use the get_rangevector so that map tiling works
 * properly.  I also so odd code in place that checked for x distance
 * OR y distance being within some range - that seemed wrong - both should
 * be within the valid range. MSW 2001-08-05
 * Returns 0 if enemy can not be detected, 1 if it is detected
 */
int can_detect_enemy(object *op, object *enemy, rv_vector *rv) {
    int radius = MIN_MON_RADIUS, hide_discovery;

    /* null detection for any of these condtions always */
    if (!op || !enemy || !op->map || !enemy->map)
        return 0;

    /* If the monster (op) has no way to get to the enemy, do nothing */
    if (!on_same_map(op, enemy))
        return 0;

    get_rangevector(op, enemy, rv, 0);

    /* Monsters always ignore the DM */
    if ((op->type != PLAYER) && QUERY_FLAG(enemy, FLAG_WIZ))
        return 0;

    /* simple check.  Should probably put some range checks in here. */
    if (can_see_enemy(op, enemy))
        return 1;

    /* The rest of this is for monsters. Players are on their own for
     * finding enemies!
     */
    if (op->type == PLAYER)
        return 0;

    /* Quality invisible? Bah, we wont see them w/o SEE_INVISIBLE
     * flag (which was already checked) in can_see_enmy (). Lets get out of here
     */
    if (enemy->invisible && (!enemy->contr || (!enemy->contr->tmp_invis && !enemy->contr->hidden)))
        return 0;

    /* use this for invis also */
    hide_discovery = op->stats.Int/5;

    /* Determine Detection radii */
    if (!enemy->hide) /* to detect non-hidden (eg dark/invis enemy) */
        radius = MAX((op->stats.Wis/5)+1, MIN_MON_RADIUS);
    else { /* a level/INT/Dex adjustment for hiding */
        object *sk_hide;
        int bonus = (op->level/2)+(op->stats.Int/5);

        if (enemy->type == PLAYER) {
            if ((sk_hide = find_skill_by_number(enemy, SK_HIDING)))
                bonus -= sk_hide->level;
            else {
                LOG(llevError, "can_detect_enemy() got hidden player w/o hiding skill!\n");
                make_visible(enemy);
                radius = MAX(radius, MIN_MON_RADIUS);
            }
        } else /* enemy is not a player */
            bonus -= enemy->level;

        radius += bonus/5;
        hide_discovery += bonus*5;
    } /* else creature has modifiers for hiding */

    /* Radii stealth adjustment. Only if you are stealthy
    * will you be able to sneak up closer to creatures */
    if (QUERY_FLAG(enemy, FLAG_STEALTH))
        radius = radius/2, hide_discovery = hide_discovery/3;

    /* Radii adjustment for enemy standing in the dark */
    if (op->map->darkness > 0 && !stand_in_light(enemy)) {
        /* on dark maps body heat can help indicate location with infravision
         * undead don't have body heat, so no benefit detecting them.
         */
        if (QUERY_FLAG(op, FLAG_SEE_IN_DARK) && !is_true_undead(enemy))
            radius += op->map->darkness/2;
        else
            radius -= op->map->darkness/2;

        /* op next to a monster (and not in complete darkness)
         * the monster should have a chance to see you.
         */
        if (radius < MIN_MON_RADIUS && op->map->darkness < 5 && rv->distance <= 1)
            radius = MIN_MON_RADIUS;
    } /* if on dark map */

    /* Lets not worry about monsters that have incredible detection
     * radii, we only need to worry here about things the player can
     * (potentially) see.  This is 13, as that is the maximum size the player
     * may have for their map - in that way, creatures at the edge will
     * do something.  Note that the distance field in the
     * vector is real distance, so in theory this should be 18 to
     * find that.
     */
    if (radius > 13)
        radius = 13;

    /* Enemy in range! Now test for detection */
    if ((int)rv->distance <= radius) {
        /* ah, we are within range, detected? take cases */
        if (!enemy->invisible) /* enemy in dark squares... are seen! */
            return 1;

        /* hidden or low-quality invisible */
        if (enemy->hide && (rv->distance <= 1) && (RANDOM()%100 <= hide_discovery)) {
            make_visible(enemy);
            /* inform players of new status */
            if (enemy->type == PLAYER && player_can_view(enemy, op))
                draw_ext_info_format(NDI_UNIQUE, 0, enemy, MSG_TYPE_SKILL, MSG_TYPE_SKILL_FAILURE,
                                     "You are discovered by %s!",
                                     "You are discovered by %s!",
                                     op->name);
            return 1; /* detected enemy */
        } else if (enemy->invisible) {
            /* Change this around - instead of negating the invisible, just
             * return true so that the mosnter that managed to detect you can
             * do something to you.  Decreasing the duration of invisible
             * doesn't make a lot of sense IMO, as a bunch of stupid creatures
             * can then basically negate the spell.  The spell isn't negated -
             * they just know where you are!
             */
            if ((RANDOM()%50) <= hide_discovery) {
                if (enemy->type == PLAYER) {
                    char name[MAX_BUF];

                    query_name(op, name, MAX_BUF);
                    draw_ext_info_format(NDI_UNIQUE, 0, enemy, MSG_TYPE_SKILL, MSG_TYPE_SKILL_FAILURE,
                                         "You see %s noticing your position.",
                                         "You see %s noticing your position.",
                                         name);
                }
                return 1;
            }
        }
    } /* within range */

    /* Wasn't detected above, so still hidden */
    return 0;
}

/* determine if op stands in a lighted square. This is not a very
 * intellegent algorithm. For one thing, we ignore los here, SO it
 * is possible for a bright light to illuminate a player on the
 * other side of a wall (!).
 */
int stand_in_light(object *op) {
    sint16 nx, ny;
    mapstruct *m;

    if (!op)
        return 0;
    if (op->glow_radius > 0)
        return 1;

    if (op->map) {
        int x, y, x1, y1;

        /* Check the spaces with the max light radius to see if any of them
         * have lights, and if any of them light the player enough, then return 1.
         */
        for (x = op->x-MAX_LIGHT_RADII; x <= op->x+MAX_LIGHT_RADII; x++) {
            for (y = op->y-MAX_LIGHT_RADII; y <= op->y+MAX_LIGHT_RADII; y++) {
                m = op->map;
                nx = x;
                ny = y;

                if (get_map_flags(m, &m, nx, ny, &nx, &ny)&P_OUT_OF_MAP)
                    continue;

                x1 = abs(x-op->x)*abs(x-op->x);
                y1 = abs(y-op->y)*abs(y-op->y);
                if (isqrt(x1+y1) < GET_MAP_LIGHT(m, nx, ny))
                    return 1;
            }
        }
    }
    return 0;
}

/*
 * assuming no walls/barriers, lets check to see if its *possible*
 * to see an enemy. Note, "detection" is different from "seeing".
 * See can_detect_enemy() for more details. -b.t.
 * return 0 if can't be seen, 1 if can be
 */
int can_see_enemy(object *op, object *enemy) {
    object *looker = op->head ? op->head : op;

    /* safety */
    if (!looker || !enemy || !QUERY_FLAG(looker, FLAG_ALIVE))
        return 0;

    /* we dont give a full treatment of xrays here (shorter range than normal,
     * see through walls). Should we change the code elsewhere to make you
     * blind even if you can xray?
     */
    if (QUERY_FLAG(looker, FLAG_BLIND) && !QUERY_FLAG(looker, FLAG_XRAYS))
        return 0;

    /* checking for invisible things */
    if (enemy->invisible) {
        /* HIDDEN ENEMY. by definition, you can't see hidden stuff!
         * However, if you carry any source of light, then the hidden
         * creature is seeable (and stupid) */
        if (has_carried_lights(enemy)) {
            if (enemy->hide) {
                make_visible(enemy);
                draw_ext_info(NDI_UNIQUE, 0, enemy, MSG_TYPE_SKILL, MSG_TYPE_SKILL_FAILURE,
                              "Your light reveals your hiding spot!",
                              NULL);
            }
            return 1;
        } else if (enemy->hide)
            return 0;

        /* Invisible enemy.  Break apart the check for invis undead/invis looker
         * into more simple checks - the QUERY_FLAG doesn't return 1/0 values,
         * and making it a conditional makes the code pretty ugly.
         */
        if (!QUERY_FLAG(looker, FLAG_SEE_INVISIBLE)) {
            if (makes_invisible_to(enemy, looker))
                return 0;
        }
    } else if (looker->type == PLAYER) /* for players, a (possible) shortcut */
        if (player_can_view(looker, enemy))
            return 1;

    /* ENEMY IN DARK MAP. Without infravision, the enemy is not seen
     * unless they carry a light or stand in light. Darkness doesnt
     * inhibit the undead per se (but we should give their archs
     * CAN_SEE_IN_DARK, this is just a safety
     * we care about the enemy maps status, not the looker.
     * only relevant for tiled maps, but it is possible that the
     * enemy is on a bright map and the looker on a dark - in that
     * case, the looker can still see the enemy
     */
    if (enemy->map->darkness > 0
    && !stand_in_light(enemy)
    && (!QUERY_FLAG(looker, FLAG_SEE_IN_DARK) || !is_true_undead(looker) || !QUERY_FLAG(looker, FLAG_XRAYS)))
        return 0;

    return 1;
}

---