static bool cloud_helper(int (*func)(int, int, int, int, cloud_type,
                                     kill_category),
                         int x, int y, int pow, int spread_rate,
                         cloud_type ctype, kill_category );

static bool _cloud_helper(int (*func)(int, int, int, int, cloud_type,
                                      kill_category),
                          int x, int y, int pow, int spread_rate,
                          cloud_type ctype, kill_category );

/*
 *             BEGIN PUBLIC FUNCTIONS
 */

//
//             BEGIN PUBLIC FUNCTIONS
//

// all this does is merely refresh the internal spell list {dlb}:

// All this does is merely refresh the internal spell list {dlb}:

    if (clouds_left && cloud_helper(func, x, y, pow, spread_rate,
                                    ctype, whose))

    if (clouds_left && _cloud_helper(func, x, y, pow, spread_rate,
                                     ctype, whose))

        if (clouds_left && cloud_helper(func, x + dx, y, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x + dx, y, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x - dx, y, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x - dx, y, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x, y + dy, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x, y + dy, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x, y - dy, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x, y - dy, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x, y + dy, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x, y + dy, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x, y - dy, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x, y - dy, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x + dx, y, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x + dx, y, pow, spread_rate,
                                         ctype, whose))

        if (clouds_left && cloud_helper(func, x - dx, y, pow, spread_rate,
                                        ctype, whose))

        if (clouds_left && _cloud_helper(func, x - dx, y, pow, spread_rate,
                                         ctype, whose))

    // now diagonals; we could randomize dx & dy again here
    if (clouds_left && cloud_helper(func, x + dx, y + dy, pow, spread_rate,
                                    ctype, whose))

    // Mow diagonals; we could randomize dx & dy again here.
    if (clouds_left && _cloud_helper(func, x + dx, y + dy, pow, spread_rate,
                                     ctype, whose))

    if (clouds_left && cloud_helper(func, x - dx, y + dy, pow, spread_rate,
                                    ctype, whose))

    if (clouds_left && _cloud_helper(func, x - dx, y + dy, pow, spread_rate,
                                     ctype, whose))

    if (clouds_left && cloud_helper(func, x + dx, y - dy, pow, spread_rate,
                                    ctype, whose))

    if (clouds_left && _cloud_helper(func, x + dx, y - dy, pow, spread_rate,
                                     ctype, whose))

    if (clouds_left && cloud_helper(func, x - dx, y - dy, pow, spread_rate,
                                    ctype, whose))

    if (clouds_left && _cloud_helper(func, x - dx, y - dy, pow, spread_rate,
                                     ctype, whose))

    if (!(clouds_left && good_squares))

    if (!clouds_left || !good_squares)

static bool cloud_helper(int (*func)(int, int, int, int, cloud_type,
                                     kill_category),
                         int x, int y, int pow, int spread_rate,
                         cloud_type ctype, kill_category whose )

static bool _cloud_helper(int (*func)(int, int, int, int, cloud_type,
                                      kill_category),
                          int x, int y, int pow, int spread_rate,
                          cloud_type ctype, kill_category whose )

    if ( power == -1 )

    if (power == -1)

    for ( unsigned int i = 0; i < ARRAYSZ(breakpoints); ++i )
        if ( power > breakpoints[i] )

    for (unsigned int i = 0; i < ARRAYSZ(breakpoints); ++i)
        if (power > breakpoints[i])

    return result + 1;

    return (result + 1);

static int which_spellbook( void )

static int _which_spellbook( void )

}                               // end which_spellbook()

}

        book = which_spellbook();

        book = _which_spellbook();

static int make_a_rot_cloud(int x, int y, int pow, cloud_type ctype);
static int quadrant_blink(int x, int y, int pow, int garbage);

static int _make_a_rot_cloud(int x, int y, int pow, cloud_type ctype);
static int _quadrant_blink(int x, int y, int pow, int garbage);

static int shatter_monsters(int x, int y, int pow, int garbage)

static int _shatter_monsters(int x, int y, int pow, int garbage)

static int shatter_items(int x, int y, int pow, int garbage)

static int _shatter_items(int x, int y, int pow, int garbage)

static int shatter_walls(int x, int y, int pow, int garbage)

static int _shatter_walls(int x, int y, int pow, int garbage)

    apply_area_within_radius(shatter_items, you.x_pos, you.y_pos, pow, rad, 0);
    apply_area_within_radius(shatter_monsters, you.x_pos, you.y_pos, pow, rad, 0);
    int dest = apply_area_within_radius( shatter_walls, you.x_pos, you.y_pos,

    apply_area_within_radius(_shatter_items, you.x_pos, you.y_pos,
                             pow, rad, 0);
    apply_area_within_radius(_shatter_monsters, you.x_pos, you.y_pos,
                             pow, rad, 0);
    int dest = apply_area_within_radius( _shatter_walls, you.x_pos, you.y_pos,

}                               // end cast_detect_secret_doors()

}

static int sleep_monsters(int x, int y, int pow, int garbage)

static int _sleep_monsters(int x, int y, int pow, int garbage)

    apply_area_visible(sleep_monsters, pow);

    apply_area_visible(_sleep_monsters, pow);

static bool is_domesticated_animal(int type)

static bool _is_domesticated_animal(int type)

static int tame_beast_monsters(int x, int y, int pow, int garbage)

static int _tame_beast_monsters(int x, int y, int pow, int garbage)

    if (!is_domesticated_animal(monster->type) || mons_friendly(monster)

    if (!_is_domesticated_animal(monster->type) || mons_friendly(monster)

    apply_area_visible(tame_beast_monsters, pow);
}                               // end cast_tame_beasts()

    apply_area_visible(_tame_beast_monsters, pow);
}

static int ignite_poison_objects(int x, int y, int pow, int garbage)

static int _ignite_poison_objects(int x, int y, int pow, int garbage)

static int ignite_poison_clouds( int x, int y, int pow, int garbage )

static int _ignite_poison_clouds( int x, int y, int pow, int garbage )

static int ignite_poison_monsters(int x, int y, int pow, int garbage)

static int _ignite_poison_monsters(int x, int y, int pow, int garbage)

    beam.flavour = BEAM_FIRE;   // this is dumb, only used for adjust!

    beam.flavour = BEAM_FIRE;   // This is dumb, only used for adjust!

    dice_def  dam_dice( 0, 5 + pow / 7 );  // dice added below if applicable

    dice_def  dam_dice( 0, 5 + pow / 7 );  // Dice added below if applicable.

    // Monsters which have poison corpses or poisonous attacks:

    // Monsters which have poison corpses or poisonous attacks.

    // first check for player poison:

    // First check for player poison.

    // strength is now the sum of both poison types (although only
    // one should actually be present at a given time):

    // Strength is now the sum of both poison types
    // (although only one should actually be present at a given time).

    // temp weapon of venom => temp fire brand

    // Temp weapon of venom => temp fire brand.

            {                   // burn poison ammo

            {
                // Burn poison ammo.

                acount += you.inv[item].quantity;

                acount  += you.inv[item].quantity;

    // player is poisonous

    // Player is poisonous.

    // player is poisoned

    // Player is poisoned.

    apply_area_visible(ignite_poison_clouds, pow);
    apply_area_visible(ignite_poison_objects, pow);
    apply_area_visible(ignite_poison_monsters, pow);

    apply_area_visible(_ignite_poison_clouds, pow);
    apply_area_visible(_ignite_poison_objects, pow);
    apply_area_visible(_ignite_poison_monsters, pow);

}                               // end cast_silence()

}

static int discharge_monsters( int x, int y, int pow, int garbage )

static int _discharge_monsters( int x, int y, int pow, int garbage )

        damage += apply_random_around_square( discharge_monsters, x, y,

        damage += apply_random_around_square( _discharge_monsters, x, y,

}                               // end discharge_monsters()

}

    dam = apply_random_around_square( discharge_monsters, you.x_pos, you.y_pos,

    dam = apply_random_around_square( _discharge_monsters, you.x_pos, you.y_pos,

}                               // end cast_discharge()

}

// This function should be currently unused (the effect is too powerful)
static int distortion_monsters(int x, int y, int pow, int message)

// This function should be currently unused (the effect is too powerful).
static int _distortion_monsters(int x, int y, int pow, int message)

}                               // end distortion_monsters()

}

    apply_one_neighbouring_square( distortion_monsters, pow );

    apply_one_neighbouring_square( _distortion_monsters, pow );

static int spell_swap_func(int x, int y, int pow, int message)

static int _spell_swap_func(int x, int y, int pow, int message)

    apply_one_neighbouring_square( spell_swap_func, pow );

    apply_one_neighbouring_square( _spell_swap_func, pow );

static int make_a_rot_cloud(int x, int y, int pow, cloud_type ctype)

static int _make_a_rot_cloud(int x, int y, int pow, cloud_type ctype)

}                               // end make_a_rot_cloud()

}

}                               // end make_a_normal_cloud()

}

static int passwall(int x, int y, int pow, int garbage)

static int _passwall(int x, int y, int pow, int garbage)

    // allow statues as entry points?

    // Irony: you can start on a secret door but not a door.
    // Worked stone walls are out, they're not diggable and
    // are used for impassable walls... I'm not sure we should
    // even allow statues (should be contiguous rock). -- bwr
    // XXX: Allow statues as entry points?

        // Irony: you can start on a secret door but not a door.
        // Worked stone walls are out, they're not diggable and
        // are used for impassable walls... I'm not sure we should
        // even allow statues (should be contiguous rock) -- bwr

    apply_one_neighbouring_square(passwall, pow);
}                               // end cast_passwall()

    apply_one_neighbouring_square(_passwall, pow);
}

static int intoxicate_monsters(int x, int y, int pow, int garbage)

static int _intoxicate_monsters(int x, int y, int pow, int garbage)

    if (mon == NON_MONSTER)
        return 0;
    if (mons_intel(menv[mon].type) < I_NORMAL)
        return 0;
    if (mons_holiness(&menv[mon]) != MH_NATURAL)
        return 0;
    if (mons_res_poison(&menv[mon]) > 0)

    if (mon == NON_MONSTER
        || mons_intel(menv[mon].type) < I_NORMAL
        || mons_holiness(&menv[mon]) != MH_NATURAL
        || mons_res_poison(&menv[mon]) > 0)
    {

    }

    apply_area_visible(intoxicate_monsters, pow);

    apply_area_visible(_intoxicate_monsters, pow);

        return (false);               // already glowing or invisible

        return (false);               // Already glowing or invisible.

    // this enchantment overrides invisibility (neat)

    // This enchantment overrides invisibility (neat).

            simple_monster_message( &menv[mon], " is limned in light." );

            simple_monster_message( &menv[mon], " is lined in light." );

}                               // end backlight_monsters()

}

static int rot_living(int x, int y, int pow, int message)

static int _rot_living(int x, int y, int pow, int message)

}                               // end rot_living()

}

static int rot_undead(int x, int y, int pow, int garbage)

static int _rot_undead(int x, int y, int pow, int garbage)

        return 0;               // immune (no flesh) or already rotting

        return 0;               // Immune (no flesh) or already rotting.

static int rot_corpses(int x, int y, int pow, int garbage)

static int _rot_corpses(int x, int y, int pow, int garbage)

    return make_a_rot_cloud(x, y, pow, CLOUD_MIASMA);

    return _make_a_rot_cloud(x, y, pow, CLOUD_MIASMA);

    apply_area_visible(rot_living, pow);
    apply_area_visible(rot_undead, pow);
    apply_area_visible(rot_corpses, pow);

    apply_area_visible(_rot_living, pow);
    apply_area_visible(_rot_undead, pow);
    apply_area_visible(_rot_corpses, pow);

static int snake_charm_monsters(int x, int y, int pow, int message)

static int _snake_charm_monsters(int x, int y, int pow, int message)

    apply_one_neighbouring_square(snake_charm_monsters, pow);

    apply_one_neighbouring_square(_snake_charm_monsters, pow);

    //FIXME: if (player typed '>' to attack floor) goto do_terrain;

    //FIXME: If (player typed '>' to attack floor) goto do_terrain;

        case MONS_CLAY_GOLEM:   // assume baked clay and not wet loam

        case MONS_CLAY_GOLEM:   // Assume baked clay and not wet loam.

        // Doors always blow up, stone arches never do (would cause problems)

        // Doors always blow up, stone arches never do (would cause problems).

    case DNGN_STONE_ARCH:       // floor -- small explosion

    case DNGN_STONE_ARCH:          // Floor -- small explosion.

        // look up the damage base

        // Look up the base damage.

            speed = property( wpn, PWPN_SPEED );

            speed  = property( wpn, PWPN_SPEED );

    // apply monster's AC

    // Apply monster's AC.

    // Inflict the damage

    // Inflict the damage.

}                               // end cast_far_strike()

}

    // mass of one unit

    // Mass of one unit.

    // assume we can pull everything

    // Assume we can pull everything.

    // item has mass: might not move all of them

    // Item has mass: might not move all of them.

        // most units our power level will allow

        // Most units our power level will allow.

        // if we apport a net, free the monster under it

        // If we apport a net, free the monster under it.

}                               // end cast_condensation_shield()

}

static int quadrant_blink(int x, int y, int pow, int garbage)

static int _quadrant_blink(int x, int y, int pow, int garbage)

        // find a space near our target...  First try to find a random
        // square not adjacent to the player, then one adjacent if
        // that fails.
        if ( !random_near_space(ox, oy, tx, ty) &&
             !random_near_space(ox, oy, tx, ty, true))

        // Find a space near our target...
        // First try to find a random square not adjacent to the player,
        // then one adjacent if that fails.
        if (!random_near_space(ox, oy, tx, ty)
            && !random_near_space(ox, oy, tx, ty, true))
        {

        }

        // which is close enough, and also far enough from us
        if ( distance(ox, oy, tx, ty) > 10 &&
             distance(you.x_pos, you.y_pos, tx, ty) < 8 )

        // ... which is close enough, and also far enough from us.
        if (distance(ox, oy, tx, ty) > 10
            && distance(you.x_pos, you.y_pos, tx, ty) < 8)
        {

        }

    return apply_one_neighbouring_square(quadrant_blink, pow);

    return apply_one_neighbouring_square(_quadrant_blink, pow);

    if (you.is_undead)

    if (you.is_undead
        && (you.species != SP_VAMPIRE || you.hunger_state < HS_SATIATED))

}                               // end detect_traps()

}

}                               // end detect_items()

}

static void fuzz_detect_creatures(int pow, int *fuzz_radius, int *fuzz_chance)

static void _fuzz_detect_creatures(int pow, int *fuzz_radius, int *fuzz_chance)

static bool mark_detected_creature(int gridx, int gridy, const monsters *mon,
                                   int fuzz_chance, int fuzz_radius)

static bool _mark_detected_creature(int gridx, int gridy, const monsters *mon,
                                    int fuzz_chance, int fuzz_radius)

        fuzz_detect_creatures(pow, &fuzz_radius, &fuzz_chance);

        _fuzz_detect_creatures(pow, &fuzz_radius, &fuzz_chance);

                mark_detected_creature(i, j, mon, fuzz_chance, fuzz_radius);

                _mark_detected_creature(i, j, mon, fuzz_chance, fuzz_radius);

static void record_monster_by_name(counted_monster_list &list,
                                   const monsters *mons)

static void _record_monster_by_name(counted_monster_list &list,
                                    const monsters *mons)

static int monster_count(const counted_monster_list &list)

static int _monster_count(const counted_monster_list &list)

static std::string describe_monsters(const counted_monster_list &list)

static std::string _describe_monsters(const counted_monster_list &list)

                    record_monster_by_name(affected_monsters, monster);

                    _record_monster_by_name(affected_monsters, monster);

                         describe_monsters(affected_monsters).c_str(),
                         monster_count(affected_monsters) == 1? "is" : "are");

                         _describe_monsters(affected_monsters).c_str(),
                         _monster_count(affected_monsters) == 1? "is" : "are");

    // place items

    // Place items.

    // place monsters

    // Place monsters.

}                               // end check_doors()

}

            // Only one out of four doors are candidates for hiding {gdl}:

            // Only one out of four doors are candidates for hiding. {gdl}

                // if door is attached to more than one wall, hide it {dlb}:

                // If door is attached to more than one wall, hide it. {dlb}

}                               // end hide_doors()

}

// Places a randomized ellipse with centre (x,y) and half axes a and b

// Places a randomized ellipse with centre (x,y) and half axes a and b.

// count how many neighbours of grd[x][y] are the feature feat.

// Count how many neighbours of grd[x][y] are the feature feat.

    for ( int idelta = -1; idelta <= 1; ++idelta )
        for ( int jdelta = -1; jdelta <= 1; ++jdelta )

    for (int idelta = -1; idelta <= 1; ++idelta)
        for (int jdelta = -1; jdelta <= 1; ++jdelta)

// yes, yes, this can probably use travel to avoid duplicating code.

// Yes, yes, this can probably use travel to avoid duplicating code.

    for ( int i = margin; i < GXM - margin; ++i )
        for ( int j = margin; j < GYM - margin; ++j )

    for (int i = margin; i < GXM - margin; ++i)
        for (int j = margin; j < GYM - margin; ++j)

    for ( int i = margin; i < GXM - margin; ++i )
        for ( int j = margin; j < GYM - margin; ++j )
            if ( !taken[i][j] )

    for (int i = margin; i < GXM - margin; ++i)
        for (int j = margin; j < GYM - margin; ++j)
            if (!taken[i][j])

                // calculate the distance from the centers of
                // previous islands

                // Calculate the distance from the centers of
                // previous islands.

}                               // end prepare_swamp()

}

// stamp a box.  can avoid a possible type, and walls and floors can
// be different (or not stamped at all)

// Stamp a box. Can avoid a possible type, and walls and floors can
// be different (or not stamped at all).

    // check for avoidance

    // Check for avoidance.

        return false;

        return (false);

    // draw walls

    // Draw walls.

    // draw floor

    // Draw floor.

    return true;

    return (true);

        // dungeon but could be in Pandemonium

        // dungeon but could be in Pandemonium.

                // makes these things less likely as you find more

                // Makes these things less likely as you find more.

    // must be normal dungeon

    // Must be normal dungeon.

// returns 1 if we should dispense with city building,

// Returns 1 if we should dispense with city building,

    // Can't have vaults on you.where_are_you != BRANCH_MAIN_DUNGEON levels

    // Can't have vaults on you.where_are_you != BRANCH_MAIN_DUNGEON levels.

        //

// returns 1 if we should skip extras(), otherwise 0

// Returns 1 if we should skip extras(), otherwise 0.

    //mv: it's better to be here so other dungeon features
    // are not overriden by water

    //mv: It's better to be here so other dungeon features are not overridden
    //    by water.

        return true;

        return (true);

        return true;

        return (true);

    // No corridor found.

    // No corridor (found).

    }                           // end "for i"
}                               // end place_traps()

    }
}

            // place a stair

            // Place a stair.

    // check left and right for possible doors

    // Check left and right for possible doors.

        return false;

        return (false);

        return false;

        return (false);

        return false;

        return (false);

    return true;
}                               //end make_room()

    return (true);
}

// Fills a special room with bees

// Fills a special room with bees.

    // must not be completely isolated:

    // Must not be completely isolated.

/*
 * Places a vault somewhere in an already built level if possible.
 * Returns true if the vault was successfully placed.
 */

// Places a vault somewhere in an already built level if possible.
// Returns true if the vault was successfully placed.

    // Don't place LAVA pools in crypt.. use shallow water instead.

    // Don't place LAVA pools in crypt... use shallow water instead.

}                               // end pick_an_altar()

}

        if ( numgood < 5*5 || numfloors == 0 )

        if (numgood < 5*5 || numfloors == 0)

        if ( mon_there )

        if (mon_there)

}                               // end place_altar()

}

}                               // end bigger_room()

}

}                               // end plan_main()

}

}                               // end plan_2()

}

}                               // end plan_2()

}

}                               // end plan_3()

}

}                               // end plan_4()

}

}                               // end labyrinth_level()

}

            return true;

            return (true);

            return false;

            return (false);

        // count # of doors we HAD to place

        // Count # of doors we HAD to place.

    // simplifies logic of innermost loop {dlb}

    // Simplifies logic of innermost loop. {dlb}

}                               // end city_level()

}

    // I guess no diamond rooms in either of these places {dlb}:

    // I guess no diamond rooms in either of these places. {dlb}

}                               // end chequerboard()

}

    if ( found )

    if (found)

static void describe_feature(int mx, int my, bool oos);
static void describe_cell(int mx, int my);

static void _describe_feature(int mx, int my, bool oos);
static void _describe_cell(int mx, int my);

static bool find_object(  int x, int y, int mode, bool need_path, int range );
static bool find_monster( int x, int y, int mode, bool need_path, int range );
static bool find_feature( int x, int y, int mode, bool need_path, int range );

static bool _find_object(  int x, int y, int mode, bool need_path, int range );
static bool _find_monster( int x, int y, int mode, bool need_path, int range );
static bool _find_feature( int x, int y, int mode, bool need_path, int range );

static char find_square_wrapper( int tx, int ty,
                                 FixedVector<char, 2> &mfp, char direction,
                                 bool (*targ)(int, int, int, bool, int),
                                 bool need_path = false, int mode = TARG_ANY,
                                 int range = -1, bool wrap = false,
                                 int los = LOS_ANY);

static char _find_square_wrapper( int tx, int ty,
                                  FixedVector<char, 2> &mfp, char direction,
                                  bool (*targ)(int, int, int, bool, int),
                                  bool need_path = false, int mode = TARG_ANY,
                                  int range = -1, bool wrap = false,
                                  int los = LOS_ANY);

static char find_square( int xps, int yps,
                         FixedVector<char, 2> &mfp, int direction,
                         bool (*targ)(int, int, int, bool, int),
                         bool need_path, int mode = TARG_ANY, int range = -1,
                         bool wrap = false, int los = LOS_ANY);

static char _find_square( int xps, int yps,
                          FixedVector<char, 2> &mfp, int direction,
                          bool (*targ)(int, int, int, bool, int),
                          bool need_path, int mode = TARG_ANY, int range = -1,
                          bool wrap = false, int los = LOS_ANY);

static int targeting_cmd_to_compass( command_type command );
static void describe_oos_square(int x, int y);
static void extend_move_to_edge(dist &moves);

static int  _targeting_cmd_to_compass( command_type command );
static void _describe_oos_square(int x, int y);
static void _extend_move_to_edge(dist &moves);

        const int i = targeting_cmd_to_compass(key_command);

        const int i = _targeting_cmd_to_compass(key_command);

static int targeting_cmd_to_compass( command_type command )

static int _targeting_cmd_to_compass( command_type command )

static int targeting_cmd_to_feature( command_type command )

static int _targeting_cmd_to_feature( command_type command )

            i = targeting_cmd_to_compass(key_command);

            i = _targeting_cmd_to_compass(key_command);

            i = targeting_cmd_to_compass(key_command);

            i = _targeting_cmd_to_compass(key_command);

            const int thing_to_find = targeting_cmd_to_feature(key_command);
            if (find_square_wrapper(moves.tx, moves.ty, objfind_pos, 1,
                                    find_feature, needs_path, thing_to_find,
                                    range, true, Options.target_los_first ?

            const int thing_to_find = _targeting_cmd_to_feature(key_command);
            if (_find_square_wrapper(moves.tx, moves.ty, objfind_pos, 1,
                                     _find_feature, needs_path, thing_to_find,
                                     range, true, Options.target_los_first ?

            if (find_square_wrapper( moves.tx, moves.ty, objfind_pos, dir,
                                     find_object, needs_path, TARG_ANY, range,
                                     true, Options.target_los_first ?
                                         (dir == 1? LOS_FLIPVH : LOS_FLIPHV)
                                          : LOS_ANY))

            if (_find_square_wrapper( moves.tx, moves.ty, objfind_pos, dir,
                                      _find_object, needs_path, TARG_ANY, range,
                                      true, Options.target_los_first ?
                                          (dir == 1? LOS_FLIPVH : LOS_FLIPHV)
                                           : LOS_ANY))

            if (find_square_wrapper( moves.tx, moves.ty, monsfind_pos, dir,
                                     find_monster, needs_path, mode, range,
                                     Options.target_wrap))

            if (_find_square_wrapper( moves.tx, moves.ty, monsfind_pos, dir,
                                      _find_monster, needs_path, mode, range,
                                      Options.target_wrap))

        skip_iter = false;      // only skip one iteration at most

        skip_iter = false;      // Only skip one iteration at most.

    extend_move_to_edge(moves);

    _extend_move_to_edge(moves);

        describe_oos_square(c.x, c.y);

        _describe_oos_square(c.x, c.y);

        describe_cell(c.x, c.y);

        _describe_cell(c.x, c.y);

        // First priority: monsters

        // First priority: monsters.

        // Second priority: objects

        // Second priority: objects.

        // Third priority: features

        // Third priority: features.

static void extend_move_to_edge(dist &moves)

static void _extend_move_to_edge(dist &moves)

    // now the tricky bit - extend the target x,y out to map edge.

    // Now the tricky bit - extend the target x,y out to map edge.

static void describe_oos_square(int x, int y)

static void _describe_oos_square(int x, int y)

    describe_feature(x, y, true);

    _describe_feature(x, y, true);

static bool find_monster( int x, int y, int mode, bool need_path,
                          int range = -1)

static bool _find_monster( int x, int y, int mode, bool need_path,
                           int range = -1)

static bool find_feature( int x, int y, int mode,
                          bool /* need_path */, int /* range */)

static bool _find_feature( int x, int y, int mode,
                           bool /* need_path */, int /* range */)

static bool find_object(int x, int y, int mode,
                        bool /* need_path */, int /* range */)

static bool _find_object(int x, int y, int mode,
                         bool /* need_path */, int /* range */)

static int next_los(int dir, int los, bool wrap)

static int _next_los(int dir, int los, bool wrap)

static char find_square( int xps, int yps,
                         FixedVector<char, 2> &mfp, int direction,
                         bool (*find_targ)( int x, int y, int mode,
                                            bool need_path, int range ),
                         bool need_path, int mode, int range, bool wrap,
                         int los )

static char _find_square( int xps, int yps,
                          FixedVector<char, 2> &mfp, int direction,
                          bool (*find_targ)( int x, int y, int mode,
                                             bool need_path, int range ),
                          bool need_path, int mode, int range, bool wrap,
                          int los )

            return find_square(ctrx, ctry, mfp, direction, find_targ,
                               need_path, mode, range, false,
                               next_los(direction, los, wrap));

            return _find_square(ctrx, ctry, mfp, direction, find_targ,
                                need_path, mode, range, false,
                                _next_los(direction, los, wrap));

            return find_square(minx, maxy, mfp, direction, find_targ,
                               need_path, mode, range, false,
                               next_los(direction, los, wrap));

            return _find_square(minx, maxy, mfp, direction, find_targ,
                                need_path, mode, range, false,
                                _next_los(direction, los, wrap));

        find_square(ctrx, ctry, mfp, direction, find_targ, need_path, mode,
                    range, false, next_los(direction, los, wrap))
      : find_square(minx, maxy, mfp, direction, find_targ, need_path, mode,
                    range, false, next_los(direction, los, wrap)));

        _find_square(ctrx, ctry, mfp, direction, find_targ, need_path, mode,
                     range, false, _next_los(direction, los, wrap))
      : _find_square(minx, maxy, mfp, direction, find_targ, need_path, mode,
                     range, false, _next_los(direction, los, wrap)));

static char find_square_wrapper( int tx, int ty,
                                 FixedVector<char, 2> &mfp, char direction,
                                 bool (*find_targ)( int x, int y, int mode,
                                                    bool need_path, int range ),
                                 bool need_path, int mode, int range, bool wrap,
                                 int los )

static char _find_square_wrapper( int tx, int ty,
                                  FixedVector<char, 2> &mfp, char direction,
                                  bool (*find_targ)(int x, int y, int mode,
                                                    bool need_path, int range),
                                  bool need_path, int mode, int range, bool wrap,
                                  int los )

    const char r =  find_square(grid2viewX(tx), grid2viewY(ty), mfp,
                                direction, find_targ, need_path, mode, range,
                                wrap, los);

    const char r =  _find_square(grid2viewX(tx), grid2viewY(ty), mfp,
                                 direction, find_targ, need_path, mode, range,
                                 wrap, los);

static void describe_feature(int mx, int my, bool oos)

static void _describe_feature(int mx, int my, bool oos)

    // water is not terribly important if you don't mind it

    // Water is not terribly important if you don't mind it-

static std::string feature_do_grammar(description_level_type dtype,
                                      bool add_stop,
                                      bool force_article,
                                      std::string desc)

static std::string _feature_do_grammar(description_level_type dtype,
                                       bool add_stop,
                                       bool force_article,
                                       std::string desc)

    return feature_do_grammar(dtype, add_stop, grid_is_trap(grid), desc);

    return _feature_do_grammar(dtype, add_stop, grid_is_trap(grid), desc);

static std::string marker_feature_description(const coord_def &p)

static std::string _marker_feature_description(const coord_def &p)

// information? (Yes, this is entirely subjective. JPEG)
static bool interesting_feature(dungeon_feature_type feat)

// information? (Yes, this is entirely subjective. --jpeg)
static bool _interesting_feature(dungeon_feature_type feat)

        return feature_do_grammar(dtype, add_stop, false, desc);

        return _feature_do_grammar(dtype, add_stop, false, desc);

        return (feature_do_grammar(

        return (_feature_do_grammar(

                    marker_feature_description(coord_def(mx, my))));

                    _marker_feature_description(coord_def(mx, my))));

static std::string describe_mons_enchantment(const monsters &mons,
                                             const mon_enchant &ench,
                                             bool paralysed)

static std::string _describe_mons_enchantment(const monsters &mons,
                                              const mon_enchant &ench,
                                              bool paralysed)

    } // end switch

    }

static std::string describe_monster_weapon(const monsters *mons)

static std::string _describe_monster_weapon(const monsters *mons)

static std::string stair_destination_description(const coord_def &pos)

static std::string _stair_destination_description(const coord_def &pos)

static void describe_monster(const monsters *mon)

static void _describe_monster(const monsters *mon)

         tmp = describe_mons_enchantment(*mon, e->second, paralysed);

         tmp = _describe_mons_enchantment(*mon, e->second, paralysed);

        weap = describe_monster_weapon(mon);

        weap = _describe_monster_weapon(mon);

static void describe_cell(int mx, int my)

static void _describe_cell(int mx, int my)

        describe_monster(&menv[i]);

        _describe_monster(&menv[i]);

        stair_destination_description(coord_def(mx, my));

        _stair_destination_description(coord_def(mx, my));

        if (interesting_feature(feat))

        if (_interesting_feature(feat))

static bool compare_card_names(card_type a, card_type b)

static bool _compare_card_names(card_type a, card_type b)

static std::string describe_deck( const item_def &item )

static std::string _describe_deck( const item_def &item )

                  compare_card_names);

                  _compare_card_names);

                  compare_card_names);

                  _compare_card_names);

            description << describe_deck( item );

            description << _describe_deck( item );

static std::string get_feature_description_wide(int feat)

static std::string _get_feature_description_wide(int feat)

    desc += get_feature_description_wide(grd[x][y]);

    desc += _get_feature_description_wide(grd[x][y]);

static bool show_item_description(const item_def &item)

static bool _show_item_description(const item_def &item)

static bool describe_spells(const item_def &item)

static bool _describe_spells(const item_def &item)

        const bool spells_shown = show_item_description(item);

        const bool spells_shown = _show_item_description(item);

            if (describe_spells(item))

            if (_describe_spells(item))

    if ( !long_descrip.empty() )

    if (!long_descrip.empty())

            "Casting it may therefore be unwise. "

                       "Casting it may therefore be unwise. "

            "Instead, go fix it. ";

                       "Instead, go fix it. ";

        "Please file a bug report.";
#endif // DEBUG

                       "Please file a bug report.";
#endif

}                               // end describe_spell()

}

static std::string describe_draconian_role(const monsters *mon)

static std::string _describe_draconian_role(const monsters *mon)

static std::string describe_draconian_colour(int species)

static std::string _describe_draconian_colour(int species)

static std::string describe_draconian(const monsters *mon)

static std::string _describe_draconian(const monsters *mon)

        if (describe_draconian_colour(subsp) != "")
            description += "  " + describe_draconian_colour(subsp);

        const std::string drac_col = _describe_draconian_colour(subsp);
        if (!drac_col.empty())
            description += "  " + drac_col;

        if (describe_draconian_role(mon) != "")
            description += "  " + describe_draconian_role(mon);

        const std::string drac_role = _describe_draconian_role(mon);
        if (!drac_role.empty())
            description += "  " + drac_role;

        description << describe_draconian( &mons );

        description << _describe_draconian( &mons );

static bool print_god_abil_desc( int god, int numpower )

static bool _print_god_abil_desc( int god, int numpower )

    // if no message then no power

    // If no message then no power.

        buf << pmsg;            // complete sentence given

        buf << pmsg;            // Complete sentence given.

    // this might be ABIL_NON_ABILITY for passive abilities

    // This might be ABIL_NON_ABILITY for passive abilities.

    if ( abil != ABIL_NON_ABILITY )

    if (abil != ABIL_NON_ABILITY)

static std::string describe_favour_generic(god_type which_god)

static std::string _describe_favour_generic(god_type which_god)

    return (which_god == GOD_XOM) ?
            describe_xom_favour() : describe_favour_generic(which_god);

    return (which_god == GOD_XOM) ? describe_xom_favour()
                                  : _describe_favour_generic(which_god);

static std::string religion_help( god_type god )

static std::string _religion_help( god_type god )

        {

        }

    cprintf( "%s", god_name(which_god, true).c_str()); //print long god's name

    cprintf( "%s", god_name(which_god, true).c_str()); // Print long god's name.

    //mv: print god's description

    //mv: Print god's description.

    // title only shown for our own god

    // Title only shown for our own god.

            for ( int i = 0; i < MAX_GOD_ABILITIES; ++i )
                if ( you.piety >= piety_breakpoint(i) )
                    if (print_god_abil_desc(which_god, i))
                        have_any = true;

            for (int i = 0; i < MAX_GOD_ABILITIES; ++i)
                if (you.piety >= piety_breakpoint(i)
                    && _print_god_abil_desc(which_god, i))
                {
                    have_any = true;
                }

        if ( !have_any )

        if (!have_any)

    // only give this additional information for worshippers
    if ( which_god == you.religion )

    // Only give this additional information for worshippers.
    if (which_god == you.religion)

        cprintf(get_linebreak_string(religion_help(which_god),

        cprintf(get_linebreak_string(_religion_help(which_god),

static void xom_check_corpse_waste();
static void armour_wear_effects(const int item_inv_slot);
static void handle_run_delays(const delay_queue_item &delay);
static void handle_macro_delay();
static void finish_delay(const delay_queue_item &delay);

static void _xom_check_corpse_waste();
static void _armour_wear_effects(const int item_inv_slot);
static void _handle_run_delays(const delay_queue_item &delay);
static void _handle_macro_delay();
static void _finish_delay(const delay_queue_item &delay);

static bool recite_mons_useless(const monsters *mon)

static bool _recite_mons_useless(const monsters *mon)

static int recite_to_monsters(int x, int y, int pow, int unused)

static int _recite_to_monsters(int x, int y, int pow, int unused)

    if (recite_mons_useless(mons))

    if (_recite_mons_useless(mons))

static bool is_parent_delay(delay_type delay)

static bool _is_parent_delay(delay_type delay)

static int push_delay(const delay_queue_item &delay)

static int _push_delay(const delay_queue_item &delay)

            i != you.delay_queue.end();
            ++i)

         i != you.delay_queue.end(); ++i)

        if (is_parent_delay( i->type ))

        if (_is_parent_delay( i->type ))

static void pop_delay()

static void _pop_delay()

static void clear_pending_delays()

static void _clear_pending_delays()

        if (push_delay(delay) == 0)
            finish_delay(delay);

        if (_push_delay(delay) == 0)
            _finish_delay(delay);

    push_delay( delay );

    _push_delay( delay );

    clear_pending_delays();

    _clear_pending_delays();

        pop_delay();

        _pop_delay();

        pop_delay();

        _pop_delay();

        pop_delay();

        _pop_delay();

        pop_delay();

        _pop_delay();

        pop_delay();

        _pop_delay();

        pop_delay();

        _pop_delay();