bool is_travelsafe_square(int x, int y, bool ignore_hostile = false,
                          bool ignore_terrain_knowledge = false);

    virtual ~travel_pathfind();

private:

protected:

    bool path_flood(const coord_def &c, const coord_def &dc);

    virtual bool path_flood(const coord_def &c, const coord_def &dc);

    void good_square(const coord_def &c);

private:

protected:

private:

protected:

}
inline bool is_trap(unsigned char grid)
{
    return (grid == DNGN_TRAP_MECHANICAL || grid == DNGN_TRAP_MAGICAL
              || grid == DNGN_TRAP_III);

    return is_trap( grd[x][y] );

    return grid_is_trap( grd[x][y] );

            is_trap(feature) ? 3 : 1);

            grid_is_trap(feature) ? 3 : 1);

static bool is_travel_ok(int x, int y, bool ignore_hostile)

bool is_travelsafe_square(int x, int y, bool ignore_hostile,
                          bool ignore_terrain_knowledge)

    if (!is_terrain_known(x, y))

    if (!ignore_terrain_knowledge && !is_terrain_known(x, y))

{
}
travel_pathfind::~travel_pathfind()

        && !is_travel_ok(start.x, start.y, false)

        && !is_travelsafe_square(start.x, start.y, false)

        && is_travel_ok(c.x, c.y, ignore_hostile))

        && is_travelsafe_square(c.x, c.y, ignore_hostile))

    if (dc != dest && !is_travel_ok(dc.x, dc.y, ignore_hostile)) 

    if (dc != dest && !is_travelsafe_square(dc.x, dc.y, ignore_hostile)) 

void travel_pathfind::good_square(const coord_def &c)
{
    if (!point_distance[c.x][c.y])
    {
        // This point is going to be on the agenda for the next
        // iteration
        circumference[!circ_index][next_iter_points++] = c;
        point_distance[c.x][c.y] = traveled_distance;
    }
}

        && is_travel_ok(x, y, false)

        && is_travelsafe_square(x, y, false)

bool grid_is_trap(int grid);

}
bool grid_is_trap(int grid)
{
    return (grid == DNGN_TRAP_MECHANICAL || grid == DNGN_TRAP_MAGICAL
              || grid == DNGN_TRAP_III);

void builder(int level_number, char level_type);

void builder(int level_number, int level_type);

#include "travel.h"

static void build_dungeon_level(int level_number, int level_type);
static bool valid_dungeon_level(int level_number, int level_type);

static std::vector<vault_placement> level_vaults;

void builder(int level_number, char level_type)

void builder(int level_number, int level_type)
{
    do
        build_dungeon_level(level_number, level_type);
    while (!valid_dungeon_level(level_number, level_type));
}
static coord_def find_level_feature(int feat)
{
    for (int y = 1; y < GYM; ++y)
    {
        for (int x = 1; x < GXM; ++x)
        {
            if (grd[x][y] == feat)
                return coord_def(x, y);
        }
    }
    return coord_def(0, 0);
}
class feature_find : public travel_pathfind
{
public:
    feature_find();
    void add_feat(int feat);
    coord_def find_first_from(const coord_def &c);
    bool did_leave_vault() const { return left_vault; }
    
protected:
    bool path_flood(const coord_def &c, const coord_def &dc);
protected:
    bool needed_features[NUM_FEATURES];
    bool left_vault;
    dgn_region_list vaults;
};
feature_find::feature_find()
    : travel_pathfind(), needed_features(), left_vault(false), vaults()
{
    memset(needed_features, false, sizeof needed_features);
}
void feature_find::add_feat(int feat)
{
    if (feat >= 0 && feat < NUM_FEATURES)
        needed_features[feat] = true;
}
coord_def feature_find::find_first_from(const coord_def &c)
{
    set_floodseed(c);
    for (int i = 0, size = level_vaults.size(); i < size; ++i)
    {
        const vault_placement &p = level_vaults[i];
        vaults.push_back( dgn_region(p.x, p.y, p.width, p.height) );
    }
    
    return pathfind(RMODE_EXPLORE);
}
bool feature_find::path_flood(const coord_def &c, const coord_def &dc)
{
    if (!in_bounds(dc))
        return (false);
    
    const int grid = grd(dc);
    if (needed_features[ grid ])
    {
        unexplored_place = dc;
        unexplored_dist  = traveled_distance;
        return (true);
    }
    if (!is_travelsafe_square(dc.x, dc.y, false, true)
        && grid != DNGN_SECRET_DOOR
        && !grid_is_trap(grid))
    {
        return (false);
    }
    if (unforbidden(dc, vaults))
        left_vault = true;
    good_square(dc);
    
    return (false);
}
static bool has_connected_downstairs_from(const coord_def &c)
{
    feature_find ff;
    ff.add_feat(DNGN_STONE_STAIRS_DOWN_I);
    ff.add_feat(DNGN_STONE_STAIRS_DOWN_II);
    ff.add_feat(DNGN_STONE_STAIRS_DOWN_III);
    ff.add_feat(DNGN_ROCK_STAIRS_DOWN);
    coord_def where = ff.find_first_from(c);
    return (where.x || !ff.did_leave_vault());
}
static bool is_level_stair_connected()

    coord_def up = find_level_feature(DNGN_STONE_STAIRS_UP_I);
    if (up.x && up.y)
        return has_connected_downstairs_from(up);
    return (false);
}
static bool valid_dungeon_level(int level_number, int level_type)
{
    if (level_number == 0 && level_type == LEVEL_DUNGEON)
        return is_level_stair_connected();
    return (true);
}
static void build_dungeon_level(int level_number, int level_type)
{

    level_vaults.clear();

    level_vaults.push_back(place);

    level_vaults.push_back(place);

FLAGS: no_rotate

FLAGS: no_rotate