if (dgn_map_mask[x][y])

            if (dgn_Map_Mask[x][y])

extern map_mask dgn_map_mask;

extern map_mask dgn_Map_Mask;

// Returns true if the given square is okay for use by any character,
// but always false for squares in non-transparent vaults. This
// function returns sane results only immediately after dungeon generation
// (specifically, saving and restoring a game discards information on the
// vaults used in the current level).
bool dgn_square_is_passable(const coord_def &c);

map_mask dgn_map_mask;
std::vector<vault_placement> level_vaults;

map_mask dgn_Map_Mask;
std::vector<vault_placement> Level_Vaults;
std::string dgn_Build_Method;

    for (int i = 0, size = level_vaults.size(); i < size; ++i)

    for (int i = 0, size = Level_Vaults.size(); i < size; ++i)

            = level_vaults[i].map.welcome_messages;

            = Level_Vaults[i].map.welcome_messages;

    level_vaults.clear();
    dgn_map_mask.init(0);

    Level_Vaults.clear();
    dgn_Map_Mask.init(0);

static inline bool _dgn_grid_is_passable(dungeon_feature_type grid)

bool dgn_square_is_passable(const coord_def &c)

    // 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));
}
static inline bool _dgn_square_is_passable(const coord_def &c)
{
    return (!(dgn_map_mask(c) & MMT_OPAQUE) && _dgn_grid_is_passable(grd(c)));

    return (!(dgn_Map_Mask(c) & MMT_OPAQUE) &&
            is_travelsafe_square(c.x, c.y, false, true));

static void _dgn_fill_zone( const coord_def &c, int zone, point_record &prec,
                            bool (*passable)(const coord_def &)
                                = _dgn_square_is_passable)

static bool _dgn_fill_zone(
    const coord_def &start, int zone,
    point_record &record_point,
    bool (*passable)(const coord_def &) = dgn_square_is_passable,
    bool (*iswanted)(const coord_def &) = NULL)

    bool ret = false;
    std::list<coord_def> points[2];
    int cur = 0;
    

    travel_point_distance[c.x][c.y] = zone;
    for (int yi = -1; yi <= 1; ++yi)
        for (int xi = -1; xi <= 1; ++xi)

    for (points[cur].push_back(start); !points[cur].empty(); )
    {
        for (std::list<coord_def>::const_iterator i = points[cur].begin();
             i != points[cur].end(); ++i)

            if (!xi && !yi)
                continue;

            const coord_def &c(*i);

            const coord_def cp(c.x + xi, c.y + yi);
            if (travel_point_distance[cp.x][cp.y] || !passable(cp))
                continue;

            travel_point_distance[c.x][c.y] = zone;
            if (iswanted && iswanted(c))
                ret = true;
            
            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 (!map_bounds(cp)
                        || travel_point_distance[cp.x][cp.y] || !passable(cp))
                        continue;

            prec(cp);
            _dgn_fill_zone(cp, zone, prec);

                    travel_point_distance[cp.x][cp.y] = zone;
                    record_point(cp);
                    points[!cur].push_back(cp);
                }
            }

        points[cur].clear();
        cur = !cur;
    }
    return (ret);    

static bool _is_exit_stair(const coord_def &c)
{
    return is_travelable_stair(grd(c));
}

//
// If count_stairless is true, returns the number of regions that have no
// stairs in them.

static int _dgn_count_disconnected_zones()

static int _dgn_count_disconnected_zones(bool choose_stairless)

            if (travel_point_distance[x][y]
                || !_dgn_square_is_passable(coord_def(x, y)))

            if (!map_bounds(x, y)
                || travel_point_distance[x][y]
                || !dgn_square_is_passable(coord_def(x, y)))

            _dgn_fill_zone(coord_def(x, y), ++nzones, _dgn_point_record_stub);

            bool found_exit_stair =
                _dgn_fill_zone(coord_def(x, y), ++nzones,
                               _dgn_point_record_stub,
                               dgn_square_is_passable,
                               choose_stairless? _is_exit_stair : NULL);
            // If we want only stairless zones, screen out zones that did
            // have stairs.
            if (choose_stairless && found_exit_stair)
                --nzones;            

                dgn_map_mask[x][y] |= mask;

                dgn_Map_Mask[x][y] |= mask;

                    dgn_map_mask[x][y] |= (short)spec->map_mask.flags_set;
                    dgn_map_mask[x][y] &= ~((short)spec->map_mask.flags_unset);

                    dgn_Map_Mask[x][y] |= (short)spec->map_mask.flags_set;
                    dgn_Map_Mask[x][y] &= ~((short)spec->map_mask.flags_unset);

    coord_def where = ff.find_first_from(c, dgn_map_mask);

    coord_def where = ff.find_first_from(c, dgn_Map_Mask);

    dgn_Build_Method.clear();

                        dgn_map_mask);

                        dgn_Map_Mask);

    if (dgn_level_vetoed)
        return;

    if (!dgn_level_vetoed && dgn_zones && nvaults != level_vaults.size())

    if (dgn_zones && nvaults != Level_Vaults.size())

        const int newzones = _dgn_count_disconnected_zones();

        const int newzones = _dgn_count_disconnected_zones(false);

        for (unsigned i = nvaults; i < level_vaults.size(); ++i)

        for (unsigned i = nvaults; i < Level_Vaults.size(); ++i)

            vlist << level_vaults[i].map.name;

            vlist << Level_Vaults[i].map.name;

            return;

    }    

    }
    // Also check for isolated regions that have no stairs.
    if (you.level_type == LEVEL_DUNGEON
        && !(branches[you.where_are_you].branch_flags & BFLAG_ISLANDED)
        && _dgn_count_disconnected_zones(true) > 0)
    {
        dgn_level_vetoed = true;
#ifdef DEBUG_DIAGNOSTICS
        mprf(MSGCH_DIAGNOSTICS,
             "VETO: %s has isolated areas with no stairs.",
             level_id::current().describe().c_str());
#endif
        return;
    }

    const unsigned nvaults = level_vaults.size();

    const unsigned nvaults = Level_Vaults.size();

    // place shops, if appropriate. This must be protected by the connectivity
    // check.
    if ( level_type == LEVEL_DUNGEON && your_branch().has_shops )
        _place_shops(level_number);
    // any vault-placement activity must happen before this check.

    // place shops, if appropriate
    if ( level_type == LEVEL_DUNGEON && your_branch().has_shops )
        _place_shops(level_number);

        if (level_vaults.empty())

        if (Level_Vaults.empty())

            if (dgn_map_mask[vx][vy])

            if (dgn_Map_Mask[vx][vy])

        dgn_zones = _dgn_count_disconnected_zones();

        dgn_zones = _dgn_count_disconnected_zones(false);

    level_vaults.push_back(place);

    Level_Vaults.push_back(place);

        while (myroom.overlaps(excluded, dgn_map_mask) && overlap_tries-- > 0);

        while (myroom.overlaps(excluded, dgn_Map_Mask) && overlap_tries-- > 0);

        const vault_placement &vp = level_vaults[level_vaults.size() - 1];

        const vault_placement &vp = Level_Vaults[Level_Vaults.size() - 1];

    dgn_zones = _dgn_count_disconnected_zones(false);

        const vault_placement &vp = level_vaults[ level_vaults.size() - 1 ];

        const vault_placement &vp = Level_Vaults[ Level_Vaults.size() - 1 ];

        dgn_zones = _dgn_count_disconnected_zones();

        dgn_zones = _dgn_count_disconnected_zones(false);

    level_vaults.push_back(place);

    Level_Vaults.push_back(place);

    return (!mask || !(dgn_map_mask(c) & mask));

    return (!mask || !(dgn_Map_Mask(c) & mask));

    dgn_Build_Method = "spotty_level";
    

    dgn_Build_Method = "bigger_room";
    

    dgn_Build_Method = "plan_main";
    

    dgn_Build_Method = "plan_1";
    

    dgn_Build_Method = "plan_2";
    

    dgn_Build_Method = "plan_3";
    

    dgn_Build_Method = "plan_4";
    

    dgn_Build_Method = "plan_5";
    

    dgn_Build_Method = "plan_6";
    

    dgn_Build_Method = "octa_room";
    

        const vault_placement &rplace = *(level_vaults.end() - 1);

        const vault_placement &rplace = *(Level_Vaults.end() - 1);

#include "chardump.h"

}
static map_mask mg_MapMask;
static bool _mg_region_flood(const coord_def &c, int region, bool flag)
{
    bool found_exit = false;
    
    mg_MapMask(c) = region;
    if (flag)
    {
        env.map(c).flags = 0;
        set_terrain_mapped(c.x, c.y);
    }
    const dungeon_feature_type ft = grd(c);
    if (is_travelable_stair(ft))
        found_exit = true;
    for (int yi = -1; yi <= 1; ++yi)
        for (int xi = -1; xi <= 1; ++xi)
        {
            if (!xi && !yi)
                continue;
            
            coord_def ci = c + coord_def(xi, yi);
            if (!in_bounds(ci) || mg_MapMask(ci) || !dgn_square_is_passable(ci))
                continue;
            if (_mg_region_flood(ci, region, flag))
                found_exit = true;
        }
    return (found_exit);
}
static bool _mg_is_disconnected_level()
{
    // Don't care about non-Dungeon levels.
    if (you.level_type != LEVEL_DUNGEON
        || (branches[you.where_are_you].branch_flags & BFLAG_ISLANDED))
        return (false);
    
    std::vector<coord_def> region_seeds;
    mg_MapMask.init(0);
    coord_def c;
    int region = 0;
    int good_regions = 0;
    for (c.y = 0; c.y < GYM; ++c.y)
        for (c.x = 0; c.x < GXM; ++c.x)
            if (!mg_MapMask(c) && dgn_square_is_passable(c))
            {
                if (_mg_region_flood(c, ++region, false))
                    ++good_regions;
                else
                    region_seeds.push_back(c);
            }
    mg_MapMask.init(0);
    for (int i = 0, size = region_seeds.size(); i < size; ++i)
        _mg_region_flood(region_seeds[i], 1, true);
    
    return (good_regions < region);

        {

            continue;
        }
        for (int y = 0; y < GYM; ++y)
            for (int x = 0; x < GXM; ++x)
            {
                switch (grd[x][y])
                {
                case DNGN_SECRET_DOOR:
                    grd[x][y] = DNGN_CLOSED_DOOR;
                    break;
                default:
                    break;
                }
            }
        {
            unwind_bool wiz(you.wizard, true);
            magic_mapping(1000, 100, true, true);
        }
        if (_mg_is_disconnected_level())
        {
            extern std::vector<vault_placement> Level_Vaults;
            std::string vaults;
            for (int j = 0, size = Level_Vaults.size(); j < size; ++j)
            {
                if (j && !vaults.empty())
                    vaults += ", ";
                vaults += Level_Vaults[j].map.name;
            }
            if (!vaults.empty())
                vaults = " (" + vaults + ")";
            extern std::string dgn_Build_Method;
            mprf(MSGCH_WARN,
                 "Bad (disconnected) level on %s%s",
                 level_id::current().describe().c_str(),
                 vaults.c_str());
            FILE *fp = fopen("map.dump", "w");
            fprintf(fp, "Bad (disconnected) level (%s) on %s%s.\n\n",
                    dgn_Build_Method.c_str(),
                    level_id::current().describe().c_str(),
                    vaults.c_str());
            // Mapping would only have mapped squares that the player can
            // reach - explicitly map the full level.
            for (int y = 0; y < GYM; ++y)
                for (int x = 0; x < GXM; ++x)
                    set_envmap_obj(x, y, grd[x][y]);
            
            dump_map(fp);
            
            return (false);
        }

static void mg_build_dungeon()

static bool mg_build_dungeon()

            return;

            return (false);

    return (true);

        mg_build_dungeon();

        if (!mg_build_dungeon())
            break;

MONS: red draconian/green draconian/yellow draconian/pale draconian/black draconian/grey draconian/purple draconian
MONS: grey draconian monk/pale draconian knight/green draconian annihilator/purple draconian knight

MONS: red draconian/green draconian/yellow draconian/pale draconian/black draconian/purple draconian
MONS: pale draconian knight/green draconian annihilator/purple draconian knight

#include <cstdio>

void dump_map(const char* fname);
void dump_map(FILE *fp);

static void dump_map(const char* fname)

void dump_map(FILE *fp)

    FILE* fp = fopen(fname, "w");
    if ( !fp )
        return;

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

    for (int i = X_BOUND_1; i <= X_BOUND_2; i++)
        for (int j = Y_BOUND_1; j <= Y_BOUND_2; j++)

    fclose(fp);

void dump_map(const char* fname)
{
    FILE* fp = fopen(fname, "w");
    if ( !fp )
        return;

    dump_map(fp);
    fclose(fp);    
}

    BFLAG_HAS_ORB         = (1 << 3)  // Orb is on the floor in this branch

    BFLAG_HAS_ORB         = (1 << 3), // Orb is on the floor in this branch
    BFLAG_ISLANDED        = (1 << 4)  // May have isolated zones with no stairs.

    { BRANCH_SWAMP, BRANCH_LAIR, 5, 3, 0, 0,

    { BRANCH_SWAMP, BRANCH_LAIR, 5, 3, BFLAG_ISLANDED, 0,

    { BRANCH_SHOALS, BRANCH_LAIR, 5, 4, 0, 0,

    { BRANCH_SHOALS, BRANCH_LAIR, 5, 4, BFLAG_ISLANDED, 0,

    { BRANCH_DIS, BRANCH_VESTIBULE_OF_HELL, 7, -1, 0, 0,

    { BRANCH_DIS, BRANCH_VESTIBULE_OF_HELL, 7, -1, BFLAG_ISLANDED, 0,

    { BRANCH_GEHENNA, BRANCH_VESTIBULE_OF_HELL, 7, -1, 0, 0,

    { BRANCH_GEHENNA, BRANCH_VESTIBULE_OF_HELL, 7, -1, BFLAG_ISLANDED, 0,

    { BRANCH_COCYTUS, BRANCH_VESTIBULE_OF_HELL, 7, -1, 0, 0,

    { BRANCH_COCYTUS, BRANCH_VESTIBULE_OF_HELL, 7, -1, BFLAG_ISLANDED, 0,

    { BRANCH_TARTARUS, BRANCH_VESTIBULE_OF_HELL, 7, -1, 0, 0,

    { BRANCH_TARTARUS, BRANCH_VESTIBULE_OF_HELL, 7, -1, BFLAG_ISLANDED, 0,