if ( !in_bounds(location) )

    if (!in_bounds(location))

    if ( !roguelike_metric && (location - center).abs() > radius*radius )

    if (!roguelike_metric && (location - center).abs() > radius*radius)

    if ( require_los && !see_grid(location) )

    if (require_los && !see_grid(location))

    if ( exclude_center && location == center )

    if (exclude_center && location == center)

// Returns true if inside the area the player can move and dig (ie exclusive)

// Returns true if inside the area the player can move and dig (ie exclusive).

    if (!in_bounds(x, y))

    if (!inside_level_bounds(x, y))

    // monsters will try to flee out of a sanctuary

    // Monsters will try to flee out of a sanctuary.

    {   // once outside there's a chance they'll regain their courage

    {
        // Once outside there's a chance they'll regain their courage.

            // sometimes we'll just move parallel the x axis

            // Sometimes we'll just move parallel the x axis.

            // sometimes we'll just move parallel the y axis

            // Sometimes we'll just move parallel the y axis.

// $$$ not sure what to say here...
//

            if (tx < 0 || tx > GXM || ty < 0 || ty > GYM)

            if (!inside_level_bounds(tx, ty))

            simple_monster_message(monster, " shoots out a bolt of electricity!");

            simple_monster_message(monster,
                                   " shoots out a bolt of electricity!");

        // Well, I guess you could allow it if the player is torment
        // resistant, but there's a very good reason torment resistant
        // players can't cast Torment themselves, and allowing your
        // allies to cast it would just introduce harmless Torment
        // through the backdoor. Thus, shouldn't happen. (jpeg)

        // the fewer spikes the manticore has left, the less

        // The fewer spikes the manticore has left, the less

        // do the throwing right here, since the beam is so

        // Do the throwing right here, since the beam is so

        // won't sing if either of you silenced, or it's friendly or confused

        // Won't sing if either of you silenced, or it's friendly or confused.

        // reduce probability because of spamminess

        // Reduce probability because of spamminess.

        // a wounded invisible mermaid is less likely to give away her position

        // A wounded invisible mermaid is less likely to give away her position.

                // if you're already beheld by an invisible mermaid she can
                // still prolong the enchantment; otherwise you "resist"

                // If you're already beheld by an invisible mermaid she can
                // still prolong the enchantment; otherwise you "resist".

            // once beheld by a particular monster, cannot resist anymore

            // Once beheld by a particular monster, you cannot resist anymore.

             if (mons_is_confused( monster )
                 || (monster->type == MONS_AIR_ELEMENTAL
                     && monster->has_ench(ENCH_SUBMERGED)))

             if (mons_is_confused(monster)
                 || monster->type == MONS_AIR_ELEMENTAL
                    && monster->has_ench(ENCH_SUBMERGED))

    // bounds check - don't consider moving out of grid!

    // Bounds check - don't consider moving out of grid!

    // non-friendly and non-good neutral monsters won't enter
    // sanctuaries

    // Non-friendly and non-good neutral monsters won't enter sanctuaries.

    // inside a sanctuary don't attack anything!

    // Inside a sanctuary don't attack anything!

    // effectively slows down monster movement across water.

    // Effectively slows down monster movement across water.

        //okmove = DNGN_WATER_STUCK;

        // don't burrow out of bounds

        // Don't burrow out of bounds.
        // XXX: Are these bounds still valid? (jpeg)
        //      We should probably use in_bounds() instead.

        // don't burrow at an angle (legacy behaviour)

        // Don't burrow at an angle (legacy behaviour).

        {

        }

    // Water elementals avoid fire and heat

    // Water elementals avoid fire and heat.

    {

            if (!in_bounds(tx, ty))

            if (!inside_level_bounds(tx, ty))

    }

    if (wontAttack
        || is_good_god(you.religion) && (isNeutral || isHoly)
        || you.religion == GOD_SHINING_ONE && isUnchivalric)

    if (isFriendly)

        snprintf(info, INFO_SIZE, "Really fire through this "
                                  "%s%s%screature?",

        // listed in the form: "your rat", "Blork"
        snprintf(info, INFO_SIZE, "Really fire through %s?",
                 mon->name(DESC_NOCAP_THE).c_str());
        if (!yesno(info, true, 'n'))
            return (true);
    }
    else if (wontAttack
             || is_good_god(you.religion) && (isNeutral || isHoly)
             || you.religion == GOD_SHINING_ONE && isUnchivalric)
    {
        // "Really fire through the helpless neutral holy Daeva?"
        // was: "Really fire through this helpless neutral holy creature?"
        snprintf(info, INFO_SIZE, "Really fire through the "
                                  "%s%s%s%s?",

                                 : "");

                                 : "",
                 mon->name(DESC_PLAIN).c_str());

            // Enchant case -- enchantments always hit, so update target immed.
            if (!mons_atts_aligned(beam.attitude, mons_attitude(mon)))

            if (beam.thrower == KILL_YOU_MISSILE)

                if (beam.thrower == KILL_YOU_MISSILE)

                if (!_beam_is_harmless(beam, mon)
                    && _stop_unchivalric_attack(mon))

                    if (_stop_unchivalric_attack(mon))
                    {
                        beam.fr_count = 1;
                        return (BEAM_STOP);
                    }
                }
                else
                {
                    beam.foe_count += 1;
                    beam.foe_power += mons_power(mons_type);

                    beam.fr_count = 1;
                    return (BEAM_STOP);

            }
            // Enchant case -- enchantments always hit, so update target immed.
            else if (!mons_atts_aligned(beam.attitude, mons_attitude(mon)))
            {
                beam.foe_count += 1;
                beam.foe_power += mons_power(mons_type);

                if (beam.thrower == KILL_YOU_MISSILE)
                {
                    if (!_beam_is_harmless(beam, mon))
                    {
                        snprintf(info, INFO_SIZE, "Really fire through %s?",
                                 mon->name(DESC_NOCAP_THE).c_str());
                        if (!yesno(info, true, 'n'))
                        {
                            beam.fr_count = 1;
                            return (BEAM_STOP);
                        }
                    }
                    // Don't count friends we don't want counted.
                }
                else
                {
                    beam.fr_count += 1;
                    beam.fr_power += mons_power(mons_type);
                }

                beam.fr_count += 1;
                beam.fr_power += mons_power(mons_type);

        // Check only if actual damage, but always count friends for player.
        if (hurt_final > 0 || beam.thrower == KILL_YOU_MISSILE)

        if (beam.thrower == KILL_YOU_MISSILE)
        {
            if (!_beam_is_harmless(beam, mon)
                && _stop_unchivalric_attack(mon))
            {
                beam.fr_count = 1;
                return (BEAM_STOP);
            }
        }
        // Check only if actual damage.
        else if (hurt_final > 0)

                if (beam.thrower == KILL_YOU_MISSILE)
                {
                    if (_stop_unchivalric_attack(mon))
                    {
                        beam.fr_count = 1;
                        return (BEAM_STOP);
                    }
                }
                else
                {
                    // Counting foes is only important for monster tracers.
                    beam.foe_count += 1;
                    beam.foe_power += 2 * hurt_final * mons_power(mons_type)
                                                        / hurt;
                }

                // Counting foes is only important for monster tracers.
                beam.foe_count += 1;
                beam.foe_power += 2 * hurt_final * mons_power(mons_type)
                                                    / hurt;

                if (beam.thrower == KILL_YOU_MISSILE)
                {
                    if (!_beam_is_harmless(beam, mon))
                    {
                        snprintf(info, INFO_SIZE, "Really fire through %s?",
                                 mon->name(DESC_NOCAP_THE).c_str());
                        if (!yesno(info, true, 'n'))
                        {
                            beam.fr_count = 1;
                            return (BEAM_STOP);
                        }
                    }
                    // Don't count friends we don't want counted.
                }
                else
                {
                    beam.fr_count += 1;
                    beam.fr_power += 2 * hurt_final * mons_power(mons_type)
                                                       / hurt;
                }

                beam.fr_count += 1;
                beam.fr_power += 2 * hurt_final * mons_power(mons_type)
                                                   / hurt;