const int xmarg =
            Options.scroll_margin_x + LOS_RADIUS <= viewhalfsz.x
            ? Options.scroll_margin_x
            : viewhalfsz.x - LOS_RADIUS;
        const int ymarg =
            Options.scroll_margin_y + LOS_RADIUS <= viewhalfsz.y
            ? Options.scroll_margin_y
            : viewhalfsz.y - LOS_RADIUS;

        const int xmarg = Options.scroll_margin_x + LOS_RADIUS <= viewhalfsz.x
                            ? Options.scroll_margin_x
                            : viewhalfsz.x - LOS_RADIUS;
        const int ymarg = Options.scroll_margin_y + LOS_RADIUS <= viewhalfsz.y
                            ? Options.scroll_margin_y
                            : viewhalfsz.y - LOS_RADIUS;

        // re-check terrain now that be may no longer be flying.

        // Re-check terrain now that be may no longer be flying.

// returns true if we manage to scramble free.

// Returns true if we manage to scramble free.

}                               // end fall_into_a_pool()

}

    // be recalculated on game start

    // be recalculated on game start.

    you.lava_in_sight  = false;
    you.water_in_sight = false;

    you.lava_in_sight  = -1;
    you.water_in_sight = -1;

    // really must be clear

    // Really must be clear.

    // better not be an unsubmerged monster either:

    // Better not be an unsubmerged monster either.

                 // prompt for any trap where you might not have enough hp

                 // Prompt for any trap where you might not have enough hp

    // only consider terrain if player is not levitating

    // Only consider terrain if player is not levitating.

            // have to move now so fall_into_a_pool will work

            // Have to move now so fall_into_a_pool will work.

            // if true, we were shifted and so we're done.

            // If true, we were shifted and so we're done.

            // safer water effects

            // Safer water effects.

            else if ( !player_likes_water() )

            else if (!player_likes_water())

    // move the player to location

    // Move the player to new location.

    // clouds -- do we need this? (always seems to double up with acr.cc call)

    // Clouds -- do we need this? (always seems to double up with acr.cc call)

    // icy shield goes down over lava

    // Icy shield goes down over lava.

    // traps go off:

    // Traps go off.

    lava_in_sight  = false;
    water_in_sight = false;

    lava_in_sight  = -1;
    water_in_sight = -1;

    const bool real_move = c != pos();

    const bool real_move = (c != pos());

        // Reset lava/water nearness check to unknown, so it'll be
        // recalculated for the next monster that tries to reach us.
        you.lava_in_sight = you.water_in_sight = -1;

// Check all grids in LoS and mark lava and/or water as seen if the
// appropriate grids are encountered, so we later only need to do the
// visibility check for monsters that can't pass a feature potentially in
// the way. We don't care about shallow water as  most monsters can safely
// cross that, and fire elementals alone aren't really worth the extra
// hassle. :)
static void _check_lava_water_in_sight()
{
    // Check the player's vision for lava or deep water,
    // to avoid unnecessary pathfinding later.
    you.lava_in_sight = you.water_in_sight = 0;
    coord_def gp;
    for (gp.y = (you.y_pos - 8); (gp.y <= you.y_pos + 8); gp.y++)
        for (gp.x = (you.x_pos - 8); (gp.x <= you.x_pos + 8); gp.x++)
        {
            if (!in_bounds(gp))
                continue;
            const coord_def ep = gp - you.pos() + coord_def(9, 9);
            if (env.show(ep))
            {
                dungeon_feature_type feat = grd[gp.x][gp.y];
                if (feat == DNGN_LAVA)
                {
                    you.lava_in_sight = 1;
                    if (you.water_in_sight > 0)
                        break;
                }
                else if (feat == DNGN_DEEP_WATER)
                {
                    you.water_in_sight = 1;
                    if (you.lava_in_sight > 0)
                        break;
                }
            }
        }
}

            if (you.water_in_sight && !amphibious && mons_amphibious(m))

            if (you.water_in_sight > 0 && !amphibious && mons_amphibious(m))

                // pathfinding.

                // pathfinding, and it's also not necessary if the monster
                // is already adjacent to you.

                    && mons_has_los_ability(mon->type))

                        && mons_has_los_ability(mon->type)
                    || grid_distance(mon->x, mon->y, you.x_pos, you.y_pos) == 1)

                    // If we don't already know whether there's water or lava
                    // in LoS of the player, find out now.
                    if (you.lava_in_sight == -1 || you.water_in_sight == -1)
                        _check_lava_water_in_sight();

                        if (you.lava_in_sight && habit != HT_LAVA
                            || you.water_in_sight && habit != HT_WATER
                               && !mons_amphibious(mon))

                        if (you.lava_in_sight > 0 && habit != HT_LAVA
                            || you.water_in_sight > 0 && habit != HT_WATER
                               && can_move != DNGN_DEEP_WATER)

                                     : env.cloud[targ_cloud_num].type;

                                      : env.cloud[targ_cloud_num].type;

    int okmove = DNGN_SHALLOW_WATER; // what does this actually do?

    if (mons_flies(monster) != FL_NONE
        || habitat != HT_LAND
        || mons_amphibious(monster))
    {
        okmove = DNGN_MINMOVE;
    }

        || (grd(newpos) == DNGN_SECRET_DOOR
            && (mons_intel(monster_index(monster)) == I_HIGH
                || mons_intel(monster_index(monster)) == I_NORMAL)))

        || grd(newpos) == DNGN_SECRET_DOOR
           && mons_intel(monster_index(monster)) >= I_NORMAL)

        if (alt && (!weap || !is_range_weapon(*alt)))

        // Switch to the alternate weapon if it's not a ranged weapon, too,
        // or switch away from our main weapon if it's a ranged weapon.
        if (alt && !is_range_weapon(*alt) || weap && !alt)

  bool lava_in_sight;       // Is there lava in LoS?
  bool water_in_sight;      // Is there deep water in LoS?

  int lava_in_sight;       // Is there lava in LoS?
  int water_in_sight;      // Is there deep water in LoS?

// Used to divide a given potion into one of four categories:
//   0 : unknown potion
//   1 : always beneficial
//   2 : always bad
//   3 : depends on species etc.
static int l_item_potion_type(lua_State *ls)
{
    LUA_ITEM(item, 1);
    int val = 99;

    if (item && item->base_type == OBJ_POTIONS)
    {
       if (!item_type_known(*item))
       {
          val = 0;
       }
       else
       {
          switch(item->sub_type)
          {
            // good potions:
            case POT_HEALING:
            case POT_HEAL_WOUNDS:
            case POT_SPEED:
            case POT_MIGHT:
            case POT_LEVITATION:
            case POT_INVISIBILITY:
            case POT_EXPERIENCE:
            case POT_MAGIC:
            case POT_RESTORE_ABILITIES:
            case POT_RESISTANCE:
                 val = 1;
                 break;
            // bad potions:
            case POT_POISON:
            case POT_STRONG_POISON:
            case POT_SLOWING:
            case POT_PARALYSIS:
            case POT_CONFUSION:
            case POT_DEGENERATION:
            case POT_DECAY:
            case POT_MUTATION:
                 val = 2;
                 break;
            // Need more refined handling:
            // for eating habits
            case POT_BLOOD:
            case POT_BLOOD_COAGULATED:
            case POT_WATER:
            case POT_PORRIDGE:
            // for undead
            case POT_BERSERK_RAGE:
            case POT_GAIN_STRENGTH:
            case POT_GAIN_DEXTERITY:
            case POT_GAIN_INTELLIGENCE:
            case POT_CURE_MUTATION:
            default:
                 val = 3;
          }
       }
    }
    lua_pushnumber(ls, val);
    return (1);
}

    { "potion_type",       l_item_potion_type },

static void _check_lava_water_in_sight()
{
    // Check the player's vision for lava or deep water,
    // to avoid unnecessary pathfinding later.
    you.lava_in_sight = you.water_in_sight = false;
    coord_def gp;
    for (gp.y = (you.y_pos - 8); (gp.y <= you.y_pos + 8); gp.y++)
        for (gp.x = (you.x_pos - 8); (gp.x <= you.x_pos + 8); gp.x++)
        {
            if (!in_bounds(gp))
                continue;

            const coord_def ep = gp - you.pos() + coord_def(9, 9);
            if (env.show(ep))
            {
                dungeon_feature_type feat = grd[gp.x][gp.y];
                if (feat == DNGN_LAVA)
                    you.lava_in_sight = true;
                else if (feat == DNGN_DEEP_WATER)
                    you.water_in_sight = true;
                if (you.lava_in_sight && you.water_in_sight)
                    break;
            }
        }
}

            if ( 2*you.hp < you.hp_max
                 || 2*you.magic_points < you.max_magic_points )

            if (2 * you.hp < you.hp_max
                || 2 * you.magic_points < you.max_magic_points)

    if ( you.cannot_act() )

    if (you.cannot_act())

    if (!you.turn_is_over)
        _check_lava_water_in_sight();

    // too annoying for regular diagnostics

    // Too annoying for regular diagnostics.

    // set up the Lua interpreter for the dungeon builder.

    // Set up the Lua interpreter for the dungeon builder.

    // Reset lava/water nearness check to unknown, so it'll be
    // recalculated for the next monster that tries to reach us.
    you.lava_in_sight = you.water_in_sight = -1;

 *  Summary:    Misc functions (most of which don't appear to be related to priests).

 *  Summary:    Misc abyss specific functions.