static void _set_random_target(monsters* mon)
{
    mon->target = random_in_bounds(); // If we don't find anything better
    for (int tries = 0; tries < 150; ++tries)
    {
        coord_def delta = coord_def(random2(13), random2(13)) - coord_def(6,6);
        if (delta.origin())
            continue;

        const coord_def newtarget = delta + mon->pos();
        if (!in_bounds(newtarget))
            continue;
        mon->target = newtarget;
        break;
    }
}

            mon->target = random_in_bounds();

            _set_random_target(mon);

        mon->target = random_in_bounds();

        _set_random_target(mon);

                    mon->target = random_in_bounds();

                    _set_random_target(mon);

                        mon->target = random_in_bounds();

                        _set_random_target(mon);

                monster_attack(monster_index(monster), false);

                monster_attack(monster, false);

            coord_def foepos = menv[monster->foe].pos();

            monsters& mfoe = menv[monster->foe];
            coord_def foepos = mfoe.pos();

                monsters_fight(monster_index(monster), monster->foe, false);

                monsters_fight(monster, &mfoe, false);

static bool _swap_monsters(const int mover_idx, const int moved_idx)

static bool _swap_monsters(monsters* mover, monsters* moved)

    monsters* mover = &menv[mover_idx];
    monsters* moved = &menv[moved_idx];

    mgrd(mover->pos()) = mover_idx;
    mgrd(moved->pos()) = moved_idx;

    mgrd(mover->pos()) = mover->mindex();
    mgrd(moved->pos()) = moved->mindex();

static void _handle_monster_move(int i, monsters *monster)

static void _handle_monster_move(monsters *monster)

    FixedArray <unsigned int, 19, 19> show;

            int cols[] = { RED, WHITE, DARKGREY, GREEN, MAGENTA };
            int newcol = cols[random2(sizeof(cols) / sizeof(cols[0]))];
            monster->colour = newcol;

            const int cols[] = { RED, WHITE, DARKGREY, GREEN, MAGENTA };
            monster->colour = RANDOM_ELEMENT(cols);

                || (monster->pos() - you.pos()).rdist() > 1)

                || (grid_distance(monster->pos(), you.pos()) > 1))

                mmov.reset();

                for (int yi = -1; yi <= 1; ++yi)
                    for (int xi = -1; xi <= 1; ++xi)
                    {
                        coord_def c = monster->pos() + coord_def(xi, yi);
                        if (in_bounds(c) && monster->can_pass_through(c)
                            && one_chance_in(++pfound))
                        {
                            mmov.x = xi;
                            mmov.y = yi;
                        }
                    }
                if (x_chance_in_y(2, 2 + pfound))
                    mmov.reset();
                // Bounds check: don't let confused monsters try to run
                // off the grid.
                const coord_def s = monster->pos() + mmov;
                if (!in_bounds_x(s.x))
                    mmov.x = 0;
                if (!in_bounds_y(s.y))
                    mmov.y = 0;

                for (adjacent_iterator ai(monster->pos(), false); ai; ++ai)
                    if (monster->can_pass_through(*ai))
                        if (one_chance_in(++pfound))
                            mmov = *ai - monster->pos();

                if (!monster->can_pass_through(monster->pos() + mmov))
                    mmov.reset();
                int enemy = mgrd(monster->pos() + mmov);
                if (enemy != NON_MONSTER
                    && !is_sanctuary(monster->pos())
                    && !mmov.origin())

                // OK, mmov determined.
                const coord_def newcell = mmov + monster->pos();
                monsters* enemy = monster_at(newcell);
                if (enemy
                    && newcell != monster->pos()
                    && !is_sanctuary(monster->pos()))

                    if (monsters_fight(i, enemy))

                    if (monsters_fight(monster, enemy))

                            behaviour_event(monster, ME_SCARE, MHITNOT,
                                            monster->pos() + mmov);

                            behaviour_event(monster, ME_SCARE,
                                            MHITNOT, newcell);

            int targmon = mgrd(monster->pos() + mmov);
            if (targmon != NON_MONSTER
                && targmon != i
                && !mons_aligned(i, targmon))

            monsters* targ = monster_at(monster->pos() + mmov);
            if (targ
                && targ != monster
                && !mons_aligned(monster->mindex(), targ->mindex()))

                if (_swap_monsters(i, targmon))

                if (_swap_monsters(monster, targ))

                else if (monsters_fight(i, targmon))

                else if (monsters_fight(monster, targ))

                        monster->target = random_in_bounds();

                        _set_random_target(monster);

                bool isFriendly = mons_friendly(monster);
                bool attacked   = false;

                if (!isFriendly)

                if (!mons_friendly(monster))

                    monster_attack(i);
                    attacked = true;

                    monster_attack(monster);

                        monster->target = random_in_bounds();

                        _set_random_target(monster);

                }
                if (attacked)
                {

        _handle_monster_move(i, monster);

        _handle_monster_move(monster);

    {
        monster_attack( monster_index(monster) );
        return (true);
    }
    // XXX Is this necessary? Isn't it handled by the next case?
    if (f == monster->pos())

        const int mx = monster_index(monster);
        monsters_fight( mx, mx );

        monster_attack(monster);

    if (mgrd(f) != NON_MONSTER)

    // This includes the case where the monster attacks itself.
    if (monsters* def = monster_at(f))

        monsters_fight( monster_index(monster), mgrd(f) );

        monsters_fight(monster, def);

            ret    = monster_attack( monster_index(monster) );

            ret = monster_attack(monster);

        int targmon = mgrd(monster->pos() + mmov);
        if (targmon != NON_MONSTER)

        if (monsters* targ = monster_at(monster->pos() + mmov))

            if (mons_aligned(monster_index(monster), targmon))

            if (mons_aligned(monster->mindex(), targ->mindex()))

                monsters_fight(monster_index(monster), targmon);

                monsters_fight(monster, targ);

// added Sept 18, 2000 -- bwr
/* ***********************************************************************
 * called from: item_use.cc
 * *********************************************************************** */

// added Sept 18, 2000 -- bwr
/* ***********************************************************************
 * called from: describe.cc
 * *********************************************************************** */

// last updated: 08jun2000 {dlb}
/* ***********************************************************************
 * called from: acr - it_use3
 * *********************************************************************** */

// last updated: 08jun2000 {dlb}
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */
bool monster_attack(int monster_attacking, bool allow_unarmed = true);
// last updated: 08jun2000 {dlb}
/* ***********************************************************************
 * called from: monstuff
 * *********************************************************************** */
bool monsters_fight(int monster_attacking, int monster_attacked,

bool monster_attack(monsters* attacker, bool allow_unarmed = true);
bool monsters_fight(monsters* attacker, monsters* attacked,

int calc_your_to_hit( bool random_factor );

int calc_heavy_armour_penalty( bool random_factor );

int calc_your_to_hit(bool random_factor);
int calc_heavy_armour_penalty(bool random_factor);

bool monster_attack(int monster_attacking, bool allow_unarmed)

bool monster_attack(monsters* attacker, bool allow_unarmed)

    monsters *attacker = &menv[monster_attacking];

bool monsters_fight(int monster_attacking, int monster_attacked,

bool monsters_fight(monsters* attacker, monsters* defender,

    monsters *attacker = &menv[monster_attacking];
    monsters *defender = &menv[monster_attacked];

        monster_attack(mi);

        monster_attack(&menv[mi]);