const signed char trav = you.permanent_levitation() ?
            TRAVERSABLE : IMPASSABLE;

        const signed char trav = (you.permanent_levitation() ? TRAVERSABLE
                                                             : IMPASSABLE);

    TAG_MINOR_VERSION = 7       // Current version

    TAG_MINOR_MPATROL = 8,      // Added monster patrol points.
    TAG_MINOR_VERSION = 8       // Current version

    marshallCoord(th, m.patrol_point);

    if (_tag_minor_version >= TAG_MINOR_MPATROL)
        unmarshallCoord(th, m.patrol_point);

    // update list of monsters beholding player

    // Update list of monsters beholding player.

            // no piety loss if god gifts killed by other monsters

            // No piety loss if god gifts killed by other monsters.

}                               // end monster_cleanup()

}

    // first, find a suitable spot for the child {dlb}:

    // First, find a suitable spot for the child {dlb}:

        // loop moves beyond those tiles contiguous to parent {dlb}:

        // Loop moves beyond those tiles contiguous to parent {dlb}:

    }                           // end of for jex

    }   // end of for jex

    // handle impact of split on parent {dlb}:

    // Handle impact of split on parent {dlb}:

    // create child {dlb}:
    // this is terribly partial and really requires

    // Create child {dlb}:
    // This is terribly partial and really requires

    child->max_hit_points = child->hit_points;

    child->max_hit_points  = child->hit_points;

// if you're invis and throw/zap whatever, alerts menv to your position

// If you're invis and throw/zap whatever, alerts menv to your position.

            if (mon->is_patrolling())
                break;

        // will turn monster against <src>, unless they

        // Will turn monster against <src>, unless they

               && mon->behaviour != BEH_FLEE && mon->behaviour != BEH_PANIC))

                && mon->behaviour != BEH_FLEE && mon->behaviour != BEH_PANIC))

        // now set target x,y so that monster can whack
        // back (once) at an invisible foe

        // Now set target x,y so that monster can whack
        // back (once) at an invisible foe.

        // will alert monster to <src> and turn them

        if (mon->is_patrolling())
            break;
        // Will alert monster to <src> and turn them

        // it won't turn friends hostile either.

        // It won't turn friends hostile either.

        // Just set behaviour.. foe doesn't change.

        // Just set behaviour... foe doesn't change.

    // now, break charms if appropriate

    // Now, break charms if appropriate.

    // do any resultant foe or state changes

    // Do any resultant foe or state changes.

}
static bool _choose_random_target_grid_in_los(monsters *mon)
{
    int pos_x, pos_y;
    int count_grids = 0;
    for (int j = -LOS_RADIUS; j < LOS_RADIUS; j++)
        for (int k = -LOS_RADIUS; k < LOS_RADIUS; k++)
        {
            if (j == 0 && k == 0)
                continue;
            pos_x = mon->x + j;
            pos_y = mon->y + k;
            if (!in_bounds(pos_x, pos_y))
                continue;
            if (!mon->mon_see_grid(pos_x, pos_y))
                continue;
            if (!mon->can_pass_through_feat(grd[pos_x][pos_y]))
                continue;
            if (one_chance_in(++count_grids))
            {
                mon->target_x = pos_x;
                mon->target_y = pos_y;
            }
        }
    return (count_grids);

    bool isHurt    = (mon->hit_points <= mon->max_hit_points / 4 - 1);
    bool isHealthy = (mon->hit_points > mon->max_hit_points / 2);
    bool isSmart   = (mons_intel(mon->type) > I_ANIMAL);
    bool isScared  = mon->has_ench(ENCH_FEAR);
    bool isMobile  = !mons_is_stationary(mon);

    bool isHurt     = (mon->hit_points <= mon->max_hit_points / 4 - 1);
    bool isHealthy  = (mon->hit_points > mon->max_hit_points / 2);
    bool isSmart    = (mons_intel(mon->type) > I_ANIMAL);
    bool isScared   = mon->has_ench(ENCH_FEAR);
    bool isMobile   = !mons_is_stationary(mon);
    bool patrolling = mon->is_patrolling();

    // validate current target exists

    // Validate current target exists.

        // now, the corollary to that is that sometimes, if a
        // player is right next to a monster, they will 'see'

        // Now, the corollary to that is that sometimes, if a
        // player is right next to a monster, they will 'see'.

        // [dshaligram] Very smart monsters have a chance of cluing in to

        // [dshaligram] Very smart monsters have a chance of clueing in to

    // monsters do not attack themselves {dlb}

    // Monsters do not attack themselves. {dlb}

        // evaluate these each time; they may change

        // Evaluate these each time; they may change.

        // track changes to state; attitude never changes here.
        beh_type new_beh = mon->behaviour;

        // Track changes to state; attitude never changes here.
        beh_type new_beh     = mon->behaviour;

        switch(mon->behaviour)

        switch (mon->behaviour)

                if (!proxPlayer || isNeutral)

                if (!proxPlayer || isNeutral || patrolling)

                if (patrolling)
                {
                    new_foe = MHITNOT;
                    new_beh = BEH_WANDER;
                    break;
                }

            // monster can see foe: continue 'tracking'
            // by updating target x,y

            // Monster can see foe: continue 'tracking'
            // by updating target x,y.

                // sometimes, your friends will wander a bit.

                // Sometimes, your friends will wander a bit.

            // is our foe in LOS?

            // Is our foe in LOS?

                mon->target_x = 10 + random2(GXM - 10);
                mon->target_y = 10 + random2(GYM - 10);

                if (patrolling)
                {
                    if (mon->patrol_point != coord_def(mon->x, mon->y)
                        || !_choose_random_target_grid_in_los(mon))
                    {
                        mon->target_x = mon->patrol_point.x;
                        mon->target_y = mon->patrol_point.y;
                    }
                }
                else
                {
                    mon->target_x = 10 + random2(GXM - 10);
                    mon->target_y = 10 + random2(GYM - 10);
                }

            // during their wanderings, monsters will
            // eventually relax their guard (stupid
            // ones will do so faster, smart monsters
            // have longer memories

            // During their wanderings, monsters will eventually relax their
            // guard (stupid ones will do so faster, smart monsters have
            // longer memories.

            // Smart monsters flee until they can
            // flee no more...  possible to get a
            // 'CORNERED' event, at which point
            // we can jump back to WANDER if the foe
            // isn't present.

            // Smart monsters flee until they can flee no more...
            // possible to get a 'CORNERED' event, at which point
            // we can jump back to WANDER if the foe isn't present.

                // Special-cased below so that it will flee *towards* you

                // Special-cased below so that it will flee *towards* you.

                // try to flee _from_ the correct position

                // Try to flee _from_ the correct position.

                if ((isFriendly || proxPlayer) && !isNeutral)

                if ((isFriendly || proxPlayer) && !isNeutral && !patrolling)

// choose nearest monster as a foe
// (used for berserking monsters)

// Choose nearest monster as a foe. (Used for berserking monsters.)

            // same comments as to invisibility as above.

            // Same comments as to invisibility as above.

    // don't allow offscreen throwing for now.

    // Don't allow offscreen throwing for now.

            // calculates mmov_x, mmov_y based on monster target.

            // Calculates mmov_x, mmov_y based on monster target.

             if (mons_is_confused(monster)
                 || monster->type == MONS_AIR_ELEMENTAL
                    && monster->has_ench(ENCH_SUBMERGED))
             {
                 std::vector<coord_def> moves;

            if (mons_is_confused(monster)
                || monster->type == MONS_AIR_ELEMENTAL
                   && monster->has_ench(ENCH_SUBMERGED))
            {
                std::vector<coord_def> moves;

                 int pfound = 0;
                 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;
                         }
                     }

                int pfound = 0;
                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 (random2(2 + pfound) < 2)
                     mmov_x = mmov_y = 0;

                if (random2(2 + pfound) < 2)
                    mmov_x = mmov_y = 0;

                 // Bounds check: don't let confused monsters try to run
                 // off the map.
                 if (monster->x + mmov_x < 0 || monster->x + mmov_x >= GXM)
                     mmov_x = 0;

                // Bounds check: don't let confused monsters try to run
                // off the map.
                if (monster->x + mmov_x < 0 || monster->x + mmov_x >= GXM)
                    mmov_x = 0;

                 if (monster->y + mmov_y < 0 || monster->y + mmov_y >= GYM)
                     mmov_y = 0;

                if (monster->y + mmov_y < 0 || monster->y + mmov_y >= GYM)
                    mmov_y = 0;

                 if (!monster->can_pass_through(monster->x + mmov_x,
                                                monster->y + mmov_y))
                 {
                     mmov_x = mmov_y = 0;
                 }

                if (!monster->can_pass_through(monster->x + mmov_x,
                                               monster->y + mmov_y))
                {
                    mmov_x = mmov_y = 0;
                }

                 if (mgrd[monster->x + mmov_x][monster->y + mmov_y] != NON_MONSTER
                     && !is_sanctuary(monster->x, monster->y)
                     && (mmov_x != 0 || mmov_y != 0))
                 {
                     monsters_fight(i,
                         mgrd[monster->x + mmov_x][monster->y + mmov_y]);

                int enemy = mgrd[monster->x + mmov_x][monster->y + mmov_y];
                if (enemy != NON_MONSTER
                    && !is_sanctuary(monster->x, monster->y)
                    && (mmov_x != 0 || mmov_y != 0))
                {
                    if (monsters_fight(i, enemy))
                    {
                        brkk = true;
                        mmov_x = 0;
                        mmov_y = 0;
                        DEBUG_ENERGY_USE("monsters_fight()");
                    }
                    else
                    {
                        // FIXME: None of these work!
                        // Instead run away!
                        if (monster->add_ench(mon_enchant(ENCH_FEAR)))
                        {
                            behaviour_event(monster, ME_SCARE, MHITNOT,
                                            monster->x + mmov_x,
                                            monster->y + mmov_y);
                        }
                        break;
/*
                        if (monster->foe == enemy || mons_friendly(monster)
                                                     && monster->foe == MHITYOU)
                        {
                            monster->foe = MHITNOT;
                            monster->behaviour = BEH_WANDER;
                        }

                     brkk = true;
                     mmov_x = 0;
                     mmov_y = 0;
                     DEBUG_ENERGY_USE("monsters_fight()");
                 }
             }

                        monster->target_x = 10 + random2(GXM - 10);
                        monster->target_y = 10 + random2(GYM - 10);
*/
                    }
                }
            }

             if (brkk)
                 continue;

            if (brkk)
                continue;

                // figure out if they fight

                // Figure out if they fight.

        // reevaluate behaviour, since the monster's

        // Reevaluate behaviour, since the monster's

    // smacking the player is always a good move if we're
    // hostile (even if we're heading somewhere else)
    // also friendlies want to keep close to the player
    // so it's okay as well

    // Smacking the player is always a good move if we're
    // hostile (even if we're heading somewhere else).
    // Also friendlies want to keep close to the player
    // so it's okay as well.

    // smacking another monster is good, if the monsters
    // are aligned differently

    // Smacking another monster is good, if the monsters
    // are aligned differently.

    MG_PERMIT_BANDS = 0x1,
    MG_FORCE_PLACE  = 0x2,
    MG_FORCE_BEH    = 0x4,
    MG_PLAYER_MADE  = 0x8

    MG_PERMIT_BANDS = 0x01,
    MG_FORCE_PLACE  = 0x02,
    MG_FORCE_BEH    = 0x04,
    MG_PLAYER_MADE  = 0x08,
    MG_PATROLLING   = 0x10

    bool needs_patrol_point() const { return (flags & MG_PATROLLING); }

                                const coord_def &where)

                                const coord_def &where,
                                unsigned flags = 0)

            || holiness == MH_NONLIVING || holiness == MH_PLANT);

                || holiness == MH_NONLIVING || holiness == MH_PLANT);

        ret = !foe || foe->backlit();

        ret = (!foe || foe->backlit());

      target_x(0), target_y(0), inv(NON_ITEM), spells(), attitude(ATT_HOSTILE),
      behaviour(BEH_WANDER), foe(MHITYOU), enchantments(), flags(0L),
      experience(0), number(0), colour(BLACK), foe_memory(0), shield_blocks(0),
      god(GOD_NO_GOD), ghost(), seen_context("")

      target_x(0), target_y(0), patrol_point(0, 0), inv(NON_ITEM), spells(),
      attitude(ATT_HOSTILE), behaviour(BEH_WANDER), foe(MHITYOU),
      enchantments(), flags(0L), experience(0), number(0), colour(BLACK),
      foe_memory(0), shield_blocks(0), god(GOD_NO_GOD), ghost(),
      seen_context("")

    patrol_point = coord_def(0, 0);

    patrol_point      = mon.patrol_point;

bool monsters::is_patrolling() const
{
    return (patrol_point != coord_def(0, 0));
}

             || (flags & MF_BANISHED)
             || type == MONS_ROYAL_JELLY
             || (you.level_type == LEVEL_DUNGEON && hit_dice > 8 + random2(25)))

                || (flags & MF_BANISHED)
                || type == MONS_ROYAL_JELLY
                || you.level_type == LEVEL_DUNGEON && hit_dice > 8 + random2(25))

            || (mons_is_zombified(this) && base_monster == MONS_HYDRA));

            || mons_is_zombified(this) && base_monster == MONS_HYDRA);

        target_x = you.x_pos;
        target_y = you.y_pos;
        foe = MHITYOU;

        target_x  = you.x_pos;
        target_y  = you.y_pos;
        foe       = MHITYOU;

    return (afoe? pos().distance_from(afoe->pos()) : INFINITE_DISTANCE);

    return (afoe ? pos().distance_from(afoe->pos())
                 : INFINITE_DISTANCE);

    // if we're attacking more than a space away
    if ((x_distance > 1) || (y_distance > 1))

    // If we're attacking more than a space away...
    if (x_distance > 1 || y_distance > 1)

        // if either the x or the y is the same, we should check for

        // If either the x or the y is the same, we should check for

        if (((beam.tx == you.x_pos) || (beam.ty == you.y_pos))
            && (mgrd[x_middle][y_middle] != NON_MONSTER))

        if ((beam.tx == you.x_pos || beam.ty == you.y_pos)
            && mgrd[x_middle][y_middle] != NON_MONSTER)

    hand_half_bonus =
        unarmed_ok
        && !can_do_unarmed
        && !shield
        && weapon
        && !item_cursed( *weapon )
        && hands == HANDS_HALF;

    hand_half_bonus = (unarmed_ok
                       && !can_do_unarmed
                       && !shield
                       && weapon
                       && !item_cursed( *weapon )
                       && hands == HANDS_HALF);

    attacker_invisible = !attacker_visible && see_grid(attacker->pos());
    defender_visible   = defender && defender->visible();
    defender_invisible = !defender_visible && defender
                         && see_grid(defender->pos());
    needs_message      = attacker_visible || defender_visible;

    attacker_invisible = (!attacker_visible && see_grid(attacker->pos()));
    defender_visible   = (defender && defender->visible());
    defender_invisible = (!defender_visible && defender
                          && see_grid(defender->pos()));
    needs_message      = (attacker_visible || defender_visible);

        if (!stop_attack_prompt(def, false, false))
            set_attack_conducts(def, conduct);

        if (stop_attack_prompt(def, false, false))
        {
            cancel_attack = true;
            return (false);
        }

            cancel_attack = true;

            set_attack_conducts(def, conduct);

            int blood =
                _modify_blood_amount(damage_done, attacker->damage_type());

            int blood = _modify_blood_amount(damage_done,
                                             attacker->damage_type());

    // if an enemy attacked a friend, set the pet target if it isn't
    // set already

    // If an enemy attacked a friend, set the pet target if it isn't
    // set already.

            int blood
                   = _modify_blood_amount(damage_done, attacker->damage_type());

            int blood = _modify_blood_amount(damage_done,
                                             attacker->damage_type());

    if (attack && (is_sanctuary(you.x_pos, you.y_pos)
                   || is_sanctuary(defender->x, defender->y)))

    if (!attack)
    {
        // Attack was cancelled or unsuccessful...
        if (attk.cancel_attack)
            you.turn_is_over = false;
        return (false);
    }
    if (is_sanctuary(you.x_pos, you.y_pos)
        || is_sanctuary(defender->x, defender->y))

    return attack;

    return (true);

        return false;

        return (false);

    return true;

    return (true);

    coord_def patrol_point;

    bool is_patrolling() const;

static void set_friendly_foes()

// If allow_patrol is true, patrolling monsters get MHITNOT instead.
static void _set_friendly_foes(bool allow_patrol = false)

        mon->foe = you.pet_target;

        mon->foe = (allow_patrol && mon->is_patrolling() ? MHITNOT
                                                         : you.pet_target);
    }
}
static void _set_allies_patrol_point(bool clear = false)
{
    for (int i = 0; i < MAX_MONSTERS; ++i)
    {
        monsters *mon(&menv[i]);
        if (!mon->alive() || !mons_near(mon) || !mons_friendly(mon))
            continue;
        mon->patrol_point = (clear ? coord_def(0, 0)
                                   : coord_def(mon->x, mon->y));
        if (!clear)
            mon->behaviour = BEH_WANDER;

        mpr(" h - Order allies to stop attacking");

        mpr(" s - Order allies to stop attacking");
        mpr(" w - Order allies to wait here");
        mpr(" f - Order allies to follow you");

    case '!':                  // for players using the old keyset

    case '!':    // for players using the old keyset

    case 'f':
    case 's':
        mons_targd = MHITYOU;
        if (keyn == 'f')
        {
            // Don't reset patrol points for 'Stop fighting!'
            _set_allies_patrol_point(true);
            mpr("Follow me!");
        }
        else
            mpr("Stop fighting!");
        break;
    case 'w':
        mpr("Wait here!");
        mons_targd = MHITNOT;
        _set_allies_patrol_point();
        break;
    case 'p':
        if (you.duration[DUR_BERSERKER])
        {
            canned_msg(MSG_TOO_BERSERK);
            return;
        }
        if (targ_prev)
        {
            mons_targd = you.prev_targ;
            mpr("Attack!");
            break;
        }

    // fall through

        mpr("Attack!");

    case 'p':
        if (you.duration[DUR_BERSERKER])
        {
            canned_msg(MSG_TOO_BERSERK);
            return;
        }

        if (targ_prev)
        {
            mons_targd = you.prev_targ;
            break;
        }
    case 'h':
        mons_targd = MHITYOU;
        break;
    // fall through...

    if (mons_targd != MHITNOT)
    {
        you.pet_target = mons_targd;
        set_friendly_foes();
    }

    you.pet_target = mons_targd;
    // Allow patrolling for "Stop fighting!" and "Wait here!"
    _set_friendly_foes(keyn == 's' || keyn == 'w');
    if (mons_targd != MHITNOT && mons_targd != MHITYOU)
        mpr("Attack!");

    mpr(mons_targd == MHITYOU ? "Come here!" : "Attack!");

// take care of labyrinth, abyss, pandemonium
// returns 1 if we should skip further generation,

// Take care of labyrinth, abyss, pandemonium.
// Returns 1 if we should skip further generation,

    mg.power = level_number;

    mg.power     = level_number;

    mg.flags |= MG_PERMIT_BANDS;

    mg.flags    |= MG_PERMIT_BANDS;

        mg.power = level_number;
        mg.flags |= MG_PERMIT_BANDS;

        mg.power     = level_number;
        mg.flags    |= MG_PERMIT_BANDS;

        mg.cls = lord_type;

        mg.cls       = lord_type;

        mg.pos = coord_def(lordx, lordy);

        mg.pos       = coord_def(lordx, lordy);

                        mgen_data::sleeper_at(
                            pit_list[i].type,
                            coord_def(x, y)));

                        mgen_data::sleeper_at( pit_list[i].type,
                                               coord_def(x, y)));

                    mgen_data::sleeper_at(
                        mons_alloc[random2(10)],
                        coord_def(x, y)));

                    mgen_data::sleeper_at( mons_alloc[random2(10)],
                                           coord_def(x, y) ));

                    mgen_data::sleeper_at(
                        mons_alloc[random2(10)],
                        coord_def(x, y) ));

                    mgen_data::sleeper_at( mons_alloc[random2(10)],
                                           coord_def(x, y) ));

        // should only appear in deep levels, with a guardian

        // Should only appear in deep levels, with a guardian

                          sr.y1 + random2( sr.y2 - sr.y1 )) ));

                          sr.y1 + random2( sr.y2 - sr.y1 )),
                MG_PATROLLING ));

                    one_chance_in(7) ?
                    MONS_KILLER_BEE_LARVA : MONS_KILLER_BEE,

                    one_chance_in(7) ? MONS_KILLER_BEE_LARVA
                                     : MONS_KILLER_BEE,

            coord_def(queenx, queeny )));

            coord_def(queenx, queeny ),
            MG_PATROLLING));

        const bool m_generate_awake = generate_awake || mspec.generate_awake;

        const bool m_generate_awake = (generate_awake || mspec.generate_awake);

        mg.power = monster_level;
        mg.behaviour = m_generate_awake ? BEH_WANDER : BEH_SLEEP;

        mg.power     = monster_level;
        mg.behaviour = (m_generate_awake ? BEH_WANDER : BEH_SLEEP);

        mg.number = mspec.number;
        mg.colour = mspec.colour;
        mg.pos = coord_def(vx, vy);

        mg.number    = mspec.number;
        mg.colour    = mspec.colour;
        mg.pos       = coord_def(vx, vy);

        const monster_type mtype =
            (vgrid == 'H') ? MONS_ORANGE_STATUE : MONS_SILVER_STATUE;

        const monster_type mtype = ((vgrid == 'H') ? MONS_ORANGE_STATUE
                                                   : MONS_SILVER_STATUE);

    mons_place(
        mgen_data::sleeper_at(
            MONS_MINOTAUR,
            end));

    mons_place( mgen_data::sleeper_at(MONS_MINOTAUR, end, MG_PATROLLING) );

            you_attack(mgrd[dx][dy], true);

            you_attack(mgrd[dx][dy], true);

            you_attack( targ_monst, true );

            you_attack( targ_monst, true );