unsigned grid_character_at(const coord_def &c);

unsigned grid_character_at(const coord_def &c)
{
    unsigned glych;
    unsigned short glycol = 0;
    _get_symbol(c, grd(c), &glych, &glycol );
    return glych;
}

#include "chardump.h"

    //
    // Don't peek inside MMT_OPAQUE vaults (all vaults are opaque by
    // default) because vaults may choose to create isolated regions,
    // or otherwise cause connectivity issues even if the map terrain
    // is travel-passable.

            // [ds] Use dgn_square_is_passable instead of
            // _is_passable_ignore_vault here, for we'll otherwise
            // fail on floorless isolated pocket in vaults (like the
            // altar surrounded by deep water), and trigger the assert
            // downstairs.

                || !_is_passable_ignore_vault(gc))

                || !dgn_square_is_passable(gc))

                               _is_passable_ignore_vault, iswanted))

                               dgn_square_is_passable, iswanted))

#ifdef DEBUG_DIAGNOSTICS
            dump_map("debug.map", true);
#endif

            int tries = 10000;

            while (grd[pos_x][pos_y] != DNGN_FLOOR
                   || (pos_x >= v1x && pos_x <= v2x && pos_y >= v1y
                       && pos_y <= v2y));

            while ((grd[pos_x][pos_y] != DNGN_FLOOR
                    || (!is_layout && pos_x >= v1x && pos_x <= v2x
                        && pos_y >= v1y && pos_y <= v2y))
                   && tries-- > 0);
            if (tries <= 0)
            {
#ifdef DEBUG_DIAGNOSTICS
                dump_map("debug.map", true);
                end(1, false,
                    "Failed to create level: vault stairs for %s "
                    "(layout: %s) failed",
                    place.map.name.c_str(), is_layout? "yes" : "no");
#endif
                pos_x = you.pos().x;
                pos_y = you.pos().y;
            }

    if (niters > 1)
    {
        mesclr();
        mprf("On %s (%d); %d g, %d fail, %d err%s, %d uniq, "
             "%d try, %d (%.2lf%%) vetos",
             level_id::current().describe().c_str(), niters,
             mg_levels_tried, mg_levels_failed, mapgen_errors.size(),
             mapgen_last_error.empty()? ""
             : (" (" + mapgen_last_error + ")").c_str(),
             mapgen_use_count.size(),
             mg_build_attempts, mg_vetoes,
             mg_build_attempts? mg_vetoes * 100.0 / mg_build_attempts : 0.0);
    }

    mesclr();
    mprf("On %s (%d); %d g, %d fail, %d err%s, %d uniq, "
         "%d try, %d (%.2lf%%) vetos",
         level_id::current().describe().c_str(), niters,
         mg_levels_tried, mg_levels_failed, mapgen_errors.size(),
         mapgen_last_error.empty()? ""
         : (" (" + mapgen_last_error + ")").c_str(),
         mapgen_use_count.size(),
         mg_build_attempts, mg_vetoes,
         mg_build_attempts? mg_vetoes * 100.0 / mg_build_attempts : 0.0);

        init_level_connectivity();

    dgn.octa_room(10, 10, gxm - 10, gym - 10, oblique, "floor")

    dgn.octa_room(1, 1, gxm - 2, gym - 2, oblique, "floor")

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

void dump_map(const char* fname, bool debug = false);
void dump_map(FILE *fp, bool debug = false);

void dump_map(FILE *fp)

void dump_map(FILE *fp, bool debug)

    int min_x = GXM-1, max_x = 0, min_y = GYM-1, max_y = 0;

    if (debug)
    {
        // Write the whole map out without checking for mappedness. Handy
        // for debugging level-generation issues.
        for (int y = 0; y < GYM; ++y)
        {
            for (int x = 0; x < GXM; ++x)
                fputc(grid_character_at(coord_def(x,y)), fp);
            fputc('\n', fp);
        }
    }
    else
    {
        int min_x = GXM-1, max_x = 0, min_y = GYM-1, max_y = 0;

    for (int i = X_BOUND_1; i <= X_BOUND_2; i++)
        for (int j = Y_BOUND_1; j <= Y_BOUND_2; j++)
            if (env.map[i][j].known())
            {
                if (i > max_x) max_x = i;
                if (i < min_x) min_x = i;
                if (j > max_y) max_y = j;
                if (j < min_y) min_y = j;
            }

        for (int i = X_BOUND_1; i <= X_BOUND_2; i++)
            for (int j = Y_BOUND_1; j <= Y_BOUND_2; j++)
                if (env.map[i][j].known())
                {
                    if (i > max_x) max_x = i;
                    if (i < min_x) min_x = i;
                    if (j > max_y) max_y = j;
                    if (j < min_y) min_y = j;
                }

    for (int y = min_y; y <= max_y; ++y)
    {
        for (int x = min_x; x <= max_x; ++x)
            fputc( env.map[x][y].glyph(), fp );

        for (int y = min_y; y <= max_y; ++y)
        {
            for (int x = min_x; x <= max_x; ++x)
                fputc( env.map[x][y].glyph(), fp );

        fputc('\n', fp);

            fputc('\n', fp);
        }

void dump_map(const char* fname)

void dump_map(const char* fname, bool debug)

    dump_map(fp);

    dump_map(fp, debug);