if (!left_vault && vaults && !(*vaults)(dc))

    if (!left_vault && vaults && !(*vaults)[dc.x][dc.y])

#include <sstream>

static void reset_level();

static void dgn_fill_zone(const coord_def &c, int zone);    

// Places where monsters should not be randomly generated.

// A mask of vaults and vault-specific flags.

static bool use_random_maps = true;
static bool dgn_check_connectivity = false;
static int  dgn_zones = 0;

#ifdef DEBUG_DIAGNOSTICS
        mapgen_report_map_build_start();
#endif
        

        
        reset_level();
        // If we're getting low on available retries, disable random vaults
        // and minivaults (special levels will still be placed).
        if (tries < 5)
            use_random_maps = false;
        

#ifdef DEBUG_DIAGNOSTICS
        if (dgn_level_vetoed)
            mapgen_report_map_veto();
#endif

}
static inline bool dgn_grid_is_isolating(const dungeon_feature_type grid)
{
    // Rock wall check is superfluous, but is the most common case.
    return (grid == DNGN_ROCK_WALL
            || (grid_is_solid(grid) && grid != DNGN_CLOSED_DOOR
                && grid != DNGN_SECRET_DOOR));
}
// Counts the number of mutually unreachable areas in the map,
// excluding isolated zones within vaults (we assume the vault author
// knows what she's doing). This is an easy way to check whether a map
// has isolated parts of the level that were not formerly isolated.
//
// All squares within vaults are treated as non-reachable, to simplify
// life, because vaults may change the level layout and isolate
// different areas without changing the number of isolated areas.
// Here's a before and after example of such a vault that would cause
// problems if we considered floor in the vault as non-isolating (the
// vault is represented as V for walls and o for floor squares in the
// vault).
//
// Before:
// 
//   xxxxx    xxxxx
//   x<..x    x.2.x
//   x.1.x    xxxxx  3 isolated zones
//   x>..x    x.3.x
//   xxxxx    xxxxx
//   
// After:
// 
//   xxxxx    xxxxx
//   x<1.x    x.2.x
//   VVVVVVVVVVoooV  3 isolated zones, but the isolated zones are different.
//   x>3.x    x...x
//   xxxxx    xxxxx
//
static int dgn_count_disconnected_zones()
{
    memset(travel_point_distance, 0, sizeof(travel_distance_grid_t));
    int nzones = 0;
    for (int y = 0; y < GYM; ++y)
    {
        for (int x = 0; x < GXM; ++x)
        {
            if (travel_point_distance[x][y] || dgn_map_mask[x][y])
                continue;
            if (dgn_grid_is_isolating(grd[x][y]))
                continue;
            dgn_fill_zone(coord_def(x, y), ++nzones);
        }
    }
    return (nzones);

static void dgn_fill_zone(const coord_def &c, int zone)
{
    // No bounds checks, assuming the level has at least one layer of
    // rock border.
    travel_point_distance[c.x][c.y] = zone;
    for (int yi = -1; yi <= 1; ++yi)
    {
        for (int xi = -1; xi <= 1; ++xi)
        {
            if (!xi && !yi)
                continue;
            const coord_def cp(c.x + xi, c.y + yi);
            if (travel_point_distance[cp.x][cp.y]
                || dgn_map_mask(cp)
                || dgn_grid_is_isolating(grd(cp)))
            {
                continue;
            }
            dgn_fill_zone(cp, zone);
        }
    }
}

    use_random_maps  = true;
    dgn_check_connectivity = false;

static void dgn_verify_connectivity(unsigned nvaults)
{
    // After placing vaults, make sure parts of the level have not been
    // disconnected.
    if (!dgn_level_vetoed && dgn_zones && nvaults != level_vaults.size())
    {
        const int newzones = dgn_count_disconnected_zones();
        if (newzones > dgn_zones)
        {
            dgn_level_vetoed = true;
#ifdef DEBUG_DIAGNOSTICS
            std::ostringstream vlist;
            for (unsigned i = nvaults; i < level_vaults.size(); ++i)
            {
                if (i > nvaults)
                    vlist << ", ";
                vlist << level_vaults[i].map.name;
            }
            mprf(MSGCH_DIAGNOSTICS,
                 "VETO: %s broken by [%s] (had %d zones, "
                 "now have %d zones.",
                 level_id::current().describe().c_str(),
                 vlist.str().c_str(), dgn_zones, newzones);
#endif
        }
    }    
}

    reset_level();

    // Try to place minivaults that really badly want to be placed. Still
    // no guarantees, seeing this is a minivault.
    if (!player_in_branch(BRANCH_SHOALS))
        place_special_minivaults(level_number, level_type);

    place_branch_entrances( level_number, level_type );
    place_extra_vaults();

    if (!player_in_branch( BRANCH_ECUMENICAL_TEMPLE ))
        place_traps(level_number);

    const unsigned nvaults = level_vaults.size();
    // Any further vaults must make sure not to disrupt level layout.
    dgn_check_connectivity = true;
    
    // Try to place minivaults that really badly want to be placed. Still
    // no guarantees, seeing this is a minivault.
    if (!player_in_branch(BRANCH_SHOALS))
        place_special_minivaults(level_number, level_type);
    place_branch_entrances( level_number, level_type );
    place_extra_vaults();
    dgn_verify_connectivity(nvaults);
    
    if (dgn_level_vetoed)
        return;
    
    if (!player_in_branch( BRANCH_ECUMENICAL_TEMPLE ))
        place_traps(level_number);
    

    if (minivault_chance && one_chance_in(minivault_chance))

    if (use_random_maps && minivault_chance && one_chance_in(minivault_chance))

        && use_random_maps

        && use_random_maps

    if (dgn_check_connectivity && !dgn_zones)
        dgn_zones = dgn_count_disconnected_zones();
    

    if (dgn_check_connectivity && !dgn_zones)
        dgn_zones = dgn_count_disconnected_zones();
    

void mapgen_report_map_build_start();
void mapgen_report_map_veto();

static std::map< level_id, std::pair<int,int> > mapgen_map_builds;

static int mg_build_attempts = 0, mg_vetoes = 0;
void mapgen_report_map_build_start()
{
    mg_build_attempts++;
    mapgen_map_builds[level_id::current()].first++;
}
void mapgen_report_map_veto()
{
    mg_vetoes++;
    mapgen_map_builds[level_id::current()].second++;    
}

    mprf("On %s (%d); %d levels, %d failed, %d errors%s, %d maps",

    mprf("On %s (%d); %d g, %d fail, %d err%s, %d uniq, "
         "%d try, %d (%.2lf%%) vetos",

         mapgen_use_count.size());

         mapgen_use_count.size(),
         mg_build_attempts, mg_vetoes,
         mg_build_attempts? mg_vetoes * 100.0 / mg_build_attempts : 0.0);

    if (mg_vetoes)
    {
        fprintf(outf, "\n\nMost vetoed levels:\n");
        std::multimap<int, level_id> sortedvetos;
        for (std::map< level_id, std::pair<int, int> >::const_iterator
                 i = mapgen_map_builds.begin(); i != mapgen_map_builds.end();
             ++i)
        {
            if (!i->second.second)
                continue;
            sortedvetos.insert(
                std::pair<int, level_id>( i->second.second, i->first ));
        }

        int count = 0;
        for (std::multimap<int, level_id>::reverse_iterator
                 i = sortedvetos.rbegin(); i != sortedvetos.rend(); ++i)
        {
            const int vetoes = i->first;
            const int tries  = mapgen_map_builds[i->second].first;
            fprintf(outf, "%3d) %s (%d of %d vetoed, %.2f%%)\n",
                    ++count, i->second.describe().c_str(),
                    vetoes, tries, vetoes * 100.0 / tries);
        }
    }