void get_item_glyph(const item_def *item, unsigned short *glych,

void get_item_glyph(const item_def *item, unsigned *glych,

void get_mons_glyph(const monsters *mons, unsigned short *glych,

void get_mons_glyph(const monsters *mons, unsigned *glych,

void get_item_symbol(unsigned int object, unsigned short *ch,

void get_item_symbol(unsigned int object, unsigned *ch,

void set_envmap_char( int x, int y, unsigned char chr );

void set_envmap_obj( int x, int y, int object );

int get_envmap_obj(int x, int y);

unsigned char get_sightmap_char(int feature);
unsigned char get_magicmap_char(int feature);

unsigned get_sightmap_char(int feature);
unsigned get_magicmap_char(int feature);

#define MAP_MAGIC_MAPPED_FLAG   0x0100
#define MAP_SEEN_FLAG           0x0200
#define MAP_CHANGED_FLAG        0x0400
#define MAP_DETECTED_MONSTER    0x0800
#define MAP_DETECTED_ITEM       0x1000
#define MAP_GRID_KNOWN          0xFF00
#define MAP_CHARACTER_MASK      0x00ff

#define MAP_MAGIC_MAPPED_FLAG   0x01
#define MAP_SEEN_FLAG           0x02
#define MAP_CHANGED_FLAG        0x04
#define MAP_DETECTED_MONSTER    0x08
#define MAP_DETECTED_ITEM       0x10
#define MAP_GRID_KNOWN          0xFF

// Flags that define what the player remembers on this square.
#define MC_ITEM             0x01
#define MC_MONS             0x02

#define MC_ITEM    0x01
#define MC_MONS    0x02

#ifdef UNICODE_GLYPHS
typedef unsigned int screen_buffer_t;
#else

#endif

FixedArray < unsigned int, 20, 19 > Show_Backup;

FixedArray < unsigned int, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER > Show_Backup;

                                    bool travel_colour = false );

                                 bool travel_colour = false );

static void get_symbol( int x, int y,
                        int object, unsigned *ch, 
                        unsigned short *colour,
                        bool magic_mapped = false );
static unsigned get_symbol(int object, unsigned short *colour = NULL,
                           bool magic_mapped = false);

unsigned map_cell::glyph() const
{
    if (!object)
        return (' ');
    return get_symbol(object, NULL, !(flags & MAP_SEEN_FLAG));
}
bool map_cell::known() const
{
    return (object && (flags & (MAP_SEEN_FLAG | MAP_MAGIC_MAPPED_FLAG)));
}
bool map_cell::seen() const
{
    return (object && (flags & MAP_SEEN_FLAG));
}

unsigned get_envmap_char(int x, int y)

inline unsigned get_envmap_char(int x, int y)
{
    return env.map[x][y].glyph();
}
int get_envmap_obj(int x, int y)

    return static_cast<unsigned char>(
            env.map[x - 1][y - 1] & MAP_CHARACTER_MASK);

    return (env.map[x][y].object);

        env.map[x - 1][y - 1] |= MAP_DETECTED_ITEM;

        env.map[x][y].flags |= MAP_DETECTED_ITEM;

        env.map[x - 1][y - 1] &= ~MAP_DETECTED_ITEM;

        env.map[x][y].flags &= ~MAP_DETECTED_ITEM;

    return (env.map[x - 1][y - 1] & MAP_DETECTED_ITEM);

    return (env.map[x][y].flags & MAP_DETECTED_ITEM);

        env.map[x - 1][y - 1] |= MAP_DETECTED_MONSTER;

        env.map[x][y].flags |= MAP_DETECTED_MONSTER;

        env.map[x - 1][y - 1] &= ~MAP_DETECTED_MONSTER;

        env.map[x][y].flags &= ~MAP_DETECTED_MONSTER;

    return (env.map[x - 1][y - 1] & MAP_DETECTED_MONSTER);

    return (env.map[x][y].flags & MAP_DETECTED_MONSTER);

void set_envmap_glyph(int x, int y, int chr, int col, int object)

void set_envmap_glyph(int x, int y, int object, int col)

    set_envmap_char(x, y, chr);
    set_envmap_col(x, y, col, get_viewobj_flags(object));

    map_cell &c = env.map[x][y];
    c.object = object;
    c.colour = col;

void set_envmap_char( int x, int y, unsigned char chr )

void set_envmap_obj( int x, int y, int obj )

    env.map[x - 1][y - 1] &= (~MAP_CHARACTER_MASK);       // clear old first
    env.map[x - 1][y - 1] |= chr;

    env.map[x][y].object = obj;

{
    env.map_col[x - 1][y - 1].colour = colour;
    env.map_col[x - 1][y - 1].flags  = 0;
}
void set_envmap_col( int x, int y, int colour, int flags )

    env.map_col[x - 1][y - 1].colour = colour;
    env.map_col[x - 1][y - 1].flags  = flags;

    env.map[x][y].colour = colour;

inline void set_envmap_item(int x, int y, bool isitem)
{
    if (isitem)
        env.map_col[x - 1][y - 1].flags |= MC_ITEM;
    else
        env.map_col[x - 1][y - 1].flags &= ~MC_ITEM;
}
inline void set_envmap_mons(int x, int y, bool ismons)
{
    if (ismons)
        env.map_col[x - 1][y - 1].flags |= MC_MONS;
    else
        env.map_col[x - 1][y - 1].flags &= ~MC_MONS;
}

    return (env.map_col[x - 1][y - 1].flags & MC_ITEM);

    return (get_viewobj_flags(env.map[x][y].object) & MC_ITEM);

    return (env.map_col[x - 1][y - 1].flags & MC_MONS);

    return (get_viewobj_flags(env.map[x][y].object) & MC_MONS);

    return (env.map_col[x - 1][y - 1].colour);

    return (env.map[x][y].colour);

    return (env.map[x - 1][y - 1] & (MAP_MAGIC_MAPPED_FLAG | MAP_SEEN_FLAG));

    return (env.map[x][y].flags
            & (MAP_MAGIC_MAPPED_FLAG | MAP_SEEN_FLAG));

    return (env.map[x - 1][y - 1] & MAP_SEEN_FLAG);

    return (env.map[x][y].flags & MAP_SEEN_FLAG);

    return (env.map[x - 1][y - 1] & MAP_CHANGED_FLAG);

    return (env.map[x][y].flags & MAP_CHANGED_FLAG);

    env.map[x - 1][y - 1] |= MAP_CHANGED_FLAG;

    env.map[x][y].flags |= MAP_CHANGED_FLAG;

    env.map[x - 1][y - 1] &= (~MAP_CHANGED_FLAG);
    env.map[x - 1][y - 1] |= MAP_MAGIC_MAPPED_FLAG;

    env.map[x][y].flags &= (~MAP_CHANGED_FLAG);
    env.map[x][y].flags |= MAP_MAGIC_MAPPED_FLAG;

    env.map[x - 1][y - 1] &= (~MAP_CHANGED_FLAG);
    env.map[x - 1][y - 1] |= MAP_SEEN_FLAG;

    env.map[x][y].flags &= (~MAP_CHANGED_FLAG);
    env.map[x][y].flags |= MAP_SEEN_FLAG;

    env.map[x - 1][y - 1] = 0;
    env.map_col[x - 1][y - 1].clear();

    env.map[x][y].clear();

}
static unsigned get_symbol(int object, unsigned short *colour,
                           bool magic_mapped)
{
    unsigned ch;
    get_symbol(0, 0, object, &ch, NULL, magic_mapped);
    return (ch);

                        unsigned int object, unsigned short *ch, 
                        unsigned short *colour )

                        int object, unsigned *ch, 
                        unsigned short *colour,
                        bool magic_mapped )

    ASSERT( colour != NULL );

        const int colmask = *colour & COLFLAG_MASK;
        // Don't clobber with BLACK, because the colour should be already set.
        if (Feature[object].colour != BLACK)
            *colour = Feature[object].colour | colmask;

        if (colour)
        {
            const int colmask = *colour & COLFLAG_MASK;
            // Don't clobber with BLACK, because the colour should be
            // already set.
            if (Feature[object].colour != BLACK)
                *colour = Feature[object].colour | colmask;
        }

        if (Feature[object].notable)

        if ((x || y) && Feature[object].notable)

    *colour = real_colour(*colour);

    if (colour)
        *colour = real_colour(*colour);

void get_item_symbol(unsigned int object, unsigned short *ch,

void get_item_symbol(unsigned int object, unsigned *ch,

unsigned char get_sightmap_char( int feature )

unsigned get_sightmap_char( int feature )

unsigned char get_magicmap_char( int feature )

unsigned get_magicmap_char( int feature )

    if (is_waypoint(x + 1, y + 1))

    if (is_waypoint(x, y))

    short dist = travel_point_distance[x + 1][y + 1];

    short dist = travel_point_distance[x][y];

    const unsigned short map_flags = env.map[x][y];

    const unsigned short map_flags = env.map[x][y].flags;

    // XXX: Yes, the map array and the grid array are off by one. -- bwr
    const int grid_value = grd[x + 1][y + 1];

    const int grid_value = grd[x][y];

    if (item_colour && is_envmap_item(x + 1, y + 1))
        return get_envmap_col(x + 1, y + 1);

    if (item_colour && is_envmap_item(x, y))
        return get_envmap_col(x, y);

        is_terrain_seen(x + 1, y + 1)? Feature[grid_value].seen_colour 

        is_terrain_seen(x, y)? Feature[grid_value].seen_colour 

        && is_stair(grid_value) && igrd[x + 1][y + 1] != NON_ITEM)

        && is_stair(grid_value) && igrd[x][y] != NON_ITEM)

            unsigned short envc = get_envmap_char(x, y);

            unsigned envc = get_envmap_char(x, y);

            set_envmap_char(x, y,
                    is_terrain_seen(x, y)? get_sightmap_char(grd[x][y]) :
                    is_terrain_known(x, y)? get_magicmap_char(grd[x][y]) :
                                            0);

            set_envmap_obj(x, y, is_terrain_known(x, y)? grd[x][y] : 0);

            set_envmap_detected_item(x, y, false);

void get_item_glyph( const item_def *item, unsigned short *glych,

void get_item_glyph( const item_def *item, unsigned *glych,

void get_mons_glyph( const monsters *mons, unsigned short *glych,

void get_mons_glyph( const monsters *mons, unsigned *glych,

    unsigned char envfeat = (unsigned char) env.map[x - 1][y - 1];
    if (!envfeat)

    if (!env.map[x][y].object)

        return envfeat == feature;

        return get_envmap_char(x, y) == (unsigned) feature;

                if (x < 0 || y < 0 || x >= GXM || y >= GYM)

                if (!in_bounds(x, y))

                if (is_feature(feature, x + 1, y + 1))

                if (is_feature(feature, x, y + 1))

    if (Options.char_set != CSET_ASCII) 

    if (Options.char_set != CSET_ASCII && Options.char_set != CSET_UNICODE)

            if (!in_bounds(c + coord_def(1, 1)))

            if (!in_bounds(c))

                bufcount2 += 2;
                goto print_it;

            else
            {
                colour = colour_code_map(c.x, c.y,
                                         Options.item_colour, 
                                         travel_mode && Options.travel_colour);

            colour = colour_code_map(c.x, c.y,
                            Options.item_colour, 
                            travel_mode && Options.travel_colour);
            buffer2[bufcount2 + 1] = colour;
            buffer2[bufcount2] = (unsigned char) env.map(c);

                buffer2[bufcount2 + 1] = colour;
                buffer2[bufcount2] = env.map(c).glyph();

            if (c.x + 1 == you.x_pos && c.y + 1 == you.y_pos)
            {
                // [dshaligram] Draw the @ symbol on the level-map. It's no
                // longer saved into the env.map, so we need to draw it 
                // directly.
                buffer2[bufcount2 + 1] = WHITE;
                buffer2[bufcount2]     = you.symbol;
            }

                if (c == you.pos())
                {
                    // [dshaligram] Draw the @ symbol on the level-map. It's no
                    // longer saved into the env.map, so we need to draw it 
                    // directly.
                    buffer2[bufcount2 + 1] = WHITE;
                    buffer2[bufcount2]     = you.symbol;
                }

            // If we've a waypoint on the current square, *and* the
            // square is a normal floor square with nothing on it,
            // show the waypoint number.
            if (Options.show_waypoints)
            {
                // XXX: This is a horrible hack.
                screen_buffer_t &bc = buffer2[bufcount2];
                const coord_def gridc = c + coord_def(1, 1);
                
                unsigned char ch = is_waypoint(gridc.x, gridc.y);
                if (ch && (bc == get_sightmap_char(DNGN_FLOOR) ||
                           bc == get_magicmap_char(DNGN_FLOOR)))
                    bc = ch;

                // If we've a waypoint on the current square, *and* the
                // square is a normal floor square with nothing on it,
                // show the waypoint number.
                if (Options.show_waypoints)
                {
                    // XXX: This is a horrible hack.
                    screen_buffer_t &bc = buffer2[bufcount2];
                    unsigned char ch = is_waypoint(c.x, c.y);
                    if (ch && (bc == get_sightmap_char(DNGN_FLOOR) ||
                               bc == get_magicmap_char(DNGN_FLOOR)))
                        bc = ch;
                }

        print_it:

            int ch = buffer2[bufcount2 - 2];

            unsigned ch = buffer2[bufcount2 - 2];

            putch(ch);

            putwch(ch);

    update_screen();

            if (env.map[i][j])

            if (env.map[i][j].known())

    int curs_x = you.x_pos - start_x;
    int curs_y = you.y_pos - screen_y + half_screen;

    int curs_x = you.x_pos - start_x + 1;
    int curs_y = you.y_pos - screen_y + half_screen + 1;

        getty = unmangle_direction_keys(getchm(KC_LEVELMAP), KC_LEVELMAP);

        getty = unmangle_direction_keys(getchm(KC_LEVELMAP), KC_LEVELMAP,
                                        false, false);

            break;
        case '!':
            mprf("Terrain seen: %s",
                 is_terrain_seen(start_x + curs_x - 1,
                                 start_y + curs_y - 1)? "yes" : "no");
            more();

            int x = start_x + curs_x, y = start_y + curs_y;

            int x = start_x + curs_x - 1, y = start_y + curs_y - 1;

        if (curs_x + move_x < 1 || curs_x + move_x > 80)

        if (curs_x + move_x < 1 || curs_x + move_x > crawl_view.termsz.x)

                if (!get_envmap_char(i, j))
                {
                    set_envmap_char(i, j, get_magicmap_char(grd[i][j]));

                if (!get_envmap_obj(i, j))
                    set_envmap_obj(i, j, grd[i][j]);

#ifdef WIZARD
                    if (map_radius == 1000 && you.wizard)
                        set_envmap_char(i, j, get_sightmap_char(grd[i][j]));
#endif
                }

static const unsigned char table[ NUM_CSET ][ NUM_DCHAR_TYPES ] = 

static const unsigned table[ NUM_CSET ][ NUM_DCHAR_TYPES ] = 

    },
    // CSET_UNICODE
    {
        0x2592, 0x2591, 0xB7, 0x25E6, '\'', 0x25FC, '^', '>', '<',
        '_', 0x22C2, 0x2320, 0x2248, '8', '~', '~',
        '0', ')', '[', '/', '%', '?', '=', '!', '(',
        '+', '|', '}', '%', '$', '"', '#',

    unsigned short  ch;

    unsigned        ch;

    FixedVector<unsigned char, NUM_DCHAR_TYPES> char_table_bk;

    FixedVector<unsigned, NUM_DCHAR_TYPES> char_table_bk;

                unsigned short glych, glycol = 0;

                unsigned glych;
                unsigned short glycol = 0;

    for (count_x = 0; count_x < 18; count_x++)

    for (count_x = 0; count_x < ENV_SHOW_DIAMETER; count_x++)

        for (count_y = 0; count_y < 18; count_y++)

        for (count_y = 0; count_y < ENV_SHOW_DIAMETER; count_y++)

        for (count_y = 1; count_y <= crawl_view.viewsz.y; count_y++)

        for (count_y = crawl_view.viewp.y; count_y <= crawl_view.viewsz.y;
             count_y++)

            for (count_x = 1; count_x <= crawl_view.viewsz.x; count_x++)

            for (count_x = crawl_view.viewp.x; count_x <= crawl_view.viewsz.x;
                 count_x++)

                const int gx = view2gridX(count_x);
                const int gy = view2gridY(count_y);

                const coord_def gc(view2grid(coord_def(count_x, count_y)));
                const coord_def ep = view2show(grid2view(gc));

                if (Options.tutorial_left && in_bounds(gx, gy)
                    && crawl_view.in_grid_los(coord_def(gx, gy)))

                if (Options.tutorial_left && in_bounds(gc)
                    && crawl_view.in_grid_los(gc))

                    const int ex = gx - you.x_pos + 9;
                    const int ey = gy - you.y_pos + 9;
                    const int object = env.show[ex][ey];

                    const int object = env.show(ep);

                        if (is_feature('>',gx,gy))
                            learned_something_new(TUT_SEEN_STAIRS,gx,gy);
                        else if (is_feature('_',gx,gy))
                            learned_something_new(TUT_SEEN_ALTAR,gx,gy);
                        else if (grd[gx][gy] == DNGN_CLOSED_DOOR
                                 && see_grid( gx, gy ))
                            learned_something_new(TUT_SEEN_DOOR,gx,gy);
                        else if (grd[gx][gy] == DNGN_ENTER_SHOP
                                 && see_grid( gx, gy ))
                            learned_something_new(TUT_SEEN_SHOP,gx,gy);

                        if (is_feature('>', gc.x, gc.y))
                            learned_something_new(TUT_SEEN_STAIRS, gc.x, gc.y);
                        else if (is_feature('_', gc.x, gc.y))
                            learned_something_new(TUT_SEEN_ALTAR, gc.x, gc.y);
                        else if (grd(gc) == DNGN_CLOSED_DOOR
                                 && see_grid( gc.x, gc.y ))
                            learned_something_new(TUT_SEEN_DOOR, gc.x, gc.y);
                        else if (grd(gc) == DNGN_ENTER_SHOP
                                 && see_grid( gc.x, gc.y ))
                            learned_something_new(TUT_SEEN_SHOP, gc.x, gc.y);

                if (!map_bounds( gx, gy ))

                if (!map_bounds(gc))

                else if (!crawl_view.in_grid_los(coord_def(gx, gy)))

                else if (!crawl_view.in_grid_los(gc))

                    buffy[bufcount] = get_envmap_char( gx, gy );

                    buffy[bufcount] = get_envmap_char( gc.x, gc.y );

                            colour_code_map(gx - 1, gy - 1, 
                                            Options.item_colour);

                            colour_code_map(gc.x, gc.y, Options.item_colour);

                else if (gx == you.x_pos && gy == you.y_pos)

                else if (gc == you.pos())

                    const int ex = gx - you.x_pos + 9;
                    const int ey = gy - you.y_pos + 9;
                    int             object = env.show[ex][ey];
                    unsigned short  colour = env.show_col[ex][ey];
                    unsigned short  ch;
                    get_symbol( gx, gy, object, &ch, &colour );

                    int             object = env.show(ep);
                    unsigned short  colour = env.show_col(ep);
                    unsigned        ch;
                    get_symbol( gc.x, gc.y, object, &ch, &colour );

                        set_envmap_glyph( gx, gy, ch, colour, object );
                        set_terrain_seen( gx, gy );
                        set_envmap_detected_mons(gx, gy, false);
                        set_envmap_detected_item(gx, gy, false);

                        set_envmap_glyph( gc.x, gc.y, object, colour );
                        set_terrain_seen( gc.x, gc.y );
                        set_envmap_detected_mons(gc.x, gc.y, false);
                        set_envmap_detected_item(gc.x, gc.y, false);

                        if (grd[gx][gy] == DNGN_DEEP_WATER)

                        if (grd(gc) == DNGN_DEEP_WATER)

                    // Note: env.show is set for grids in LoS
                    // get env coords
                    const int ex = gx - you.x_pos + 9;
                    const int ey = gy - you.y_pos + 9;
                    int             object = env.show[ex][ey];
                    unsigned short  colour = env.show_col[ex][ey];
                    unsigned short  ch;

                    int             object = env.show(ep);
                    unsigned short  colour = env.show_col(ep);
                    unsigned        ch;

                        object = grid_secret_door_appearance( gx, gy );

                        object = grid_secret_door_appearance( gc.x, gc.y );

                    get_symbol( gx, gy, object, &ch, &colour );

                    get_symbol( gc.x, gc.y, object, &ch, &colour );

                            set_envmap_glyph( gx, gy, ch, colour, object );
                            set_terrain_seen( gx, gy );
                            set_envmap_detected_mons(gx, gy, false);
                            set_envmap_detected_item(gx, gy, false);

                            set_envmap_glyph( gc.x, gc.y, object, colour );
                            set_terrain_seen( gc.x, gc.y );
                            set_envmap_detected_mons(gc.x, gc.y, false);
                            set_envmap_detected_item(gc.x, gc.y, false);

                            && Show_Backup[ex][ey]
                            && is_terrain_seen( gx, gy ))

                            && Show_Backup(ep)
                            && is_terrain_seen( gc.x, gc.y ))

                            get_symbol( gx, gy,
                                        Show_Backup[ex][ey], &ch, &colour );
                            set_envmap_glyph( gx, gy, ch, colour, 
                                              Show_Backup[ex][ey] );

                            get_symbol( gc.x, gc.y,
                                        Show_Backup(ep), &ch, &colour );
                            set_envmap_glyph( gc.x, gc.y, Show_Backup(ep),
                                              colour );

                            buffy[bufcount] = get_envmap_char( gx, gy );

                            buffy[bufcount] = get_envmap_char( gc.x, gc.y );

                                    colour_code_map(gx - 1, gy - 1,

                                    colour_code_map(gc.x, gc.y,

                    putch( buffy[bufcount] );

                    putwch( buffy[bufcount] );

        update_screen();

    unsigned short ch, col;

    unsigned ch;
    unsigned short col;

    if (!Options.tutorial_events[TUT_SEEN_FIRST_OBJECT] || Options.tut_just_triggered)

    if (!Options.tutorial_events[TUT_SEEN_FIRST_OBJECT]
        || Options.tut_just_triggered)
    {

    }

    unsigned short ch, col;

    unsigned ch;
    unsigned short col;

    unsigned short ch, colour;

    unsigned ch;
    unsigned short colour;

bool is_player_mapped(unsigned char envch);

bool is_player_mapped(int grid_x, int grid_y);

static FixedArray< unsigned short, GXM, GYM >  mapshadow;

static FixedArray< map_cell, GXM, GYM >  mapshadow;

bool is_player_mapped(int grid_x, int grid_y)

bool is_player_seen(int grid_x, int grid_y)

    return (is_player_mapped( env.map[grid_x - 1][grid_y - 1] ));
}
// Determines whether the player has seen this square, given the user-visible
// character. 
//
// The player is assumed to have seen the square if:
// a. The square is mapped (the env map char is not zero)
// b. The square was *not* magic-mapped.
//
// FIXME: There's better ways of doing this with the new view.cc.
bool is_player_mapped(unsigned char envch)
{
    // Note that we're relying here on mapch(DNGN_FLOOR) != mapch2(DNGN_FLOOR)
    // and that no *other* dungeon feature renders as mapch(DNGN_FLOOR).
    // The check for a ~ is to ensure explore stops for items turned up by
    // detect items.
    return envch && envch != get_magicmap_char(DNGN_FLOOR) && envch != '~';

    return (is_terrain_seen(grid_x, grid_y));

// Copies FixedArray src to FixedArray dest. 
//
inline void copy(const FixedArray<unsigned short, GXM, GYM> &src, 
                 FixedArray<unsigned short, GXM, GYM> &dest)
{
    dest = src;
}

    if (x <= 0 || x >= GXM || y <= 0 || y >= GYM) return;
    if (!env.map[x - 1][y - 1]) return;

    if (!in_bounds(x, y))
        return;
    
    if (!is_terrain_known(x, y))
        return;

        const int c = get_envmap_char(x, y);

        const int c = get_envmap_obj(x, y);

        return (c != get_sightmap_char(secret_door)
                && c != get_magicmap_char(secret_door));

        return (c != secret_door);

    const coord_def pos(x + 1, y + 1);

    const coord_def pos(x, y);

            if (!is_player_mapped( get_envmap_char(ax, ay) ))

            if (!is_terrain_seen(ax, ay))

        for (int y = 0; y < GYM - 1; ++y)

        for (int y = 0; y < GYM; ++y)

            for (int x = 0; x < GXM - 1; ++x)

            for (int x = 0; x < GXM; ++x)

                if (!is_player_mapped(mapshadow[x][y])
                    && is_player_mapped((unsigned char) env.map[x][y]))

                if (!mapshadow[x][y].seen() && is_terrain_seen(x, y))

        copy(env.map, mapshadow);

        mapshadow = env.map;

    copy(env.map, mapshadow);

    mapshadow = env.map;

    // These are env map coords, not grid coordinates.
    for (int y = 0; y < GYM - 1; ++y)

    for (int y = 0; y < GYM; ++y)

        for (int x = 0; x < GXM - 1; ++x)

        for (int x = 0; x < GXM; ++x)

            int grid = grd[x + 1][y + 1];
            int envc = env.map[x][y];

            int grid = grd[x][y];
            int envc = env.map[x][y].object;

            if ((x + 1 == you.x_pos && y + 1 == you.y_pos)

            if ((x == you.x_pos && y == you.y_pos)

                        && (is_terrain_seen(x + 1, y + 1)
                            || !is_branch_stair(x + 1, y + 1))))

                        && (is_terrain_seen(x, y)
                            || !is_branch_stair(x, y))))

                const coord_def stair(x + 1, y + 1);

                const coord_def stair(x, y);

            marshallShort(th, env.map[count_x][count_y]);
            marshallShort(th, env.map_col[count_x][count_y].colour);
            marshallShort(th, env.map_col[count_x][count_y].flags);

            marshallShort(th, env.map[count_x][count_y].object);
            marshallShort(th, env.map[count_x][count_y].colour);            
            marshallShort(th, env.map[count_x][count_y].flags);

            
            env.map[i][j] = (unsigned short) unmarshallShort(th);

            if ((env.map[i][j] & 0xFF) == 201)       // what is this??
                env.map[i][j] = (env.map[i][j] & 0xFF00U) | 239;
            env.map_col[i][j].colour = unmarshallShort(th);
            env.map_col[i][j].flags  = unmarshallShort(th);

            env.map[i][j].object = unmarshallShort(th);
            env.map[i][j].colour = unmarshallShort(th);
            env.map[i][j].flags  = unmarshallShort(th);

    crawl_view.init_geometry();

    
    crawl_view.init_geometry();
    if (Options.char_set == CSET_UNICODE && !crawl_state.unicode_ok)
        end(1, false,
            "Unicode glyphs are not available, please change your "
            "char_set option");

                set_envmap_char(etx, ety, get_magicmap_char(grd[etx][ety]));

                set_envmap_obj(etx, ety, grd[etx][ety]);

                set_envmap_char(i, j, get_magicmap_char(DNGN_ITEM_DETECTED));

                set_envmap_obj(i, j, DNGN_ITEM_DETECTED);

    set_envmap_char(gridx, gridy, mons_char(mon->type));

    set_envmap_obj(gridx, gridy, mon->type + DNGN_START_OF_MONSTERS);

                set_envmap_char(you.x_pos, you.y_pos, get_sightmap_char(type));

                set_envmap_obj(you.x_pos, you.y_pos, type);

            {
                env.map[xcount][ycount] = 0;
                env.map_col[xcount][ycount].clear();
            }

                env.map[xcount][ycount].clear();

# Include path for curses or ncurses.
INCLUDES = -I/usr/include/ncurses

# Change this to y if you want to use Unicode glyphs in the map, and you have
# libncursesw available.
UNICODE_GLYPHS = n

ifeq ($(UNICODE_GLYPHS),y)
# Include path for (n)curses with Unicode support.
INCLUDES = -I/usr/include/ncursesw
LIBCURS  = ncursesw
EXTRA_FLAGS += -DUNICODE_GLYPHS
else
# Include path for curses or ncurses (non-Unicode).
INCLUDES = -I/usr/include/ncurses
LIBCURS  = ncurses
endif

LIB = -lncurses -L$(LUASRC) -l$(LUALIB) $(LIBDBM)

LIB = -l$(LIBCURS) -L$(LUASRC) -l$(LUALIB) $(LIBDBM)

void putwch(unsigned c);

void update_screen();

}
void putwch(unsigned c)
{
    putch((char) c);

void update_screen()
{
    bFlush();
}

int putwch(unsigned chr);

#ifdef UNICODE_GLYPHS
#include <locale.h>
#endif

int Character_Set = CHARACTER_SET;

static int Character_Set = CHARACTER_SET;

short FG_COL = WHITE;
short BG_COL = BLACK;

static short FG_COL = WHITE;
static short BG_COL = BLACK;
static int   Current_Colour = COLOR_PAIR(BG_COL * 8 + FG_COL);

#ifdef UNICODE_GLYPHS
    crawl_state.unicode_ok = !!setlocale(LC_ALL, "");
#endif

int putwch(unsigned chr)
{
#ifdef UNICODE_GLYPHS
    if (chr <= 127)
        return (putch(chr));

    wchar_t c = chr;
    return (addnwstr(&c, 1));
#else
    return (putch(static_cast<unsigned char>(chr)));
#endif
}

    attrset( curs_fg_attr(col) );

    attrset( Current_Colour = curs_fg_attr(col) );

    attrset( curs_bg_attr(col) );

    attrset( Current_Colour = curs_bg_attr(col) );

static unsigned oldch, oldmangledch;
static int faked_x = -1, faked_y;

#ifdef UNICODE_GLYPHS
typedef cchar_t char_info;
inline bool operator == (const cchar_t &a, const cchar_t &b)
{
    return (a.attr == b.attr && *a.chars == *b.chars);
}
inline char_info character_at(int y, int x)
{
    cchar_t c;
    mvin_wch(y, x, &c);
    return (c);
}
inline bool valid_char(const cchar_t &c)
{
    return *c.chars;
}
inline void write_char_at(int y, int x, const cchar_t &ch)
{
    move(y, x);
    add_wchnstr(&ch, 1);
}
static void flip_colour(cchar_t &ch)
{
    const unsigned colour = (ch.attr & A_COLOR);
    const int pair        = PAIR_NUMBER(colour);

void fakecursorxy(int x, int y)
{
    if (oldch && faked_x != -1
        && mvinch(faked_y, faked_x) == oldmangledch)

    int fg     = pair & 7;
    int bg     = (pair >> 3) & 7;
    if (pair == 63)

        if (faked_x != x - 1 || faked_y != y - 1)
            mvaddch(faked_y, faked_x, oldch);
        else
            return;

        fg    = COLOR_WHITE;
        bg    = COLOR_BLACK;

    
    const unsigned c      = mvinch(y - 1, x - 1);
    const int ch          = c & A_CHARTEXT;
    const unsigned colour = c & A_COLOR;
    const int pair        = PAIR_NUMBER(colour);

    const int newpair = (fg * 8 + bg);
    ch.attr = COLOR_PAIR(newpair);
}
#else // ! UNICODE_GLYPHS
typedef unsigned char_info;
#define character_at(y,x)    mvinch(y,x)
#define valid_char(x) (x)
#define write_char_at(y,x,c) mvaddch(y, x, c)

    faked_x = x - 1;
    faked_y = y - 1;
    oldch   = c;

#define char_info_character(c) ((c) & A_CHARTEXT)
#define char_info_colour(c)    ((c) & A_COLOR)
static void flip_colour(unsigned &ch)
{
    const unsigned colour = char_info_colour(ch);
    const int pair        = PAIR_NUMBER(colour);

    
    mvaddch( y - 1, x - 1,  oldmangledch = ((ch & 127) | COLOR_PAIR(newpair)) );

    ch = ((ch & 127) | COLOR_PAIR(newpair));
}
#endif
static char_info oldch, oldmangledch;
static int faked_x = -1, faked_y;

void fakecursorxy(int x, int y)
{
    if (valid_char(oldch) && faked_x != -1
        && character_at(faked_y, faked_x) == oldmangledch)
    {
        if (faked_x != x - 1 || faked_y != y - 1)
            write_char_at(faked_y, faked_x, oldch);
        else
            return;
    }
    
    char_info c = character_at(y - 1, x - 1);
    oldch   = c;
    faked_x = x - 1;
    faked_y = y - 1;
    flip_colour(c);
    write_char_at( y - 1, x - 1, oldmangledch = c);

inline void update_screen()
{
}
inline void putwch(unsigned c)
{
    putch(static_cast<char>(c));
}

    view_max_width = VIEW_EX;
    view_max_height = VIEW_EY;

    view_max_width = VIEW_MIN_WIDTH;
    view_max_height = VIEW_MIN_HEIGHT;

static unsigned short read_symbol(std::string s)

static unsigned read_symbol(std::string s)

    if (s.length() > 1 && s[0] == '\\')
        s = s.substr(1);

    if (s[0] == '\\')

    int base = 10;
    if (s.length() > 1 && s[0] == 'x')
    {

    
    int feat = atoi(s.c_str());

        base = 16;
    }
    char *tail;
    int feat = strtol(s.c_str(), &tail, base);

    return static_cast<unsigned short>(feat);

    return static_cast<unsigned>(feat);

        unsigned char symbol = 
            static_cast<unsigned char>(read_symbol(mapping[1]));

        unsigned symbol = 
            static_cast<unsigned>(read_symbol(mapping[1]));

                                     unsigned char symbol)

                                     unsigned symbol)

            else 

            else if (field == "utf" || field == "unicode")
                char_set = CSET_UNICODE;
            else

        else if (cset == "utf" || cset == "unicode")
            cs = CSET_UNICODE;

        if (view_max_width < VIEW_EX)
            view_max_width = VIEW_EX;

        if (view_max_width < VIEW_MIN_WIDTH)
            view_max_width = VIEW_MIN_WIDTH;
        // Allow the view to be one larger than GXM because the view width
        // needs to be odd, and GXM is even.

        if (view_max_height < VIEW_EY)
            view_max_height = VIEW_EY;

        if (view_max_height < VIEW_MIN_HEIGHT)
            view_max_height = VIEW_MIN_HEIGHT;

    unsigned short ch, col;

    unsigned ch;
    unsigned short col;

    unsigned short ch, col;

    unsigned ch;
    unsigned short col;

    for (int i = 0; i < GXM; i++)
    {
        for (int j = 0; j < GYM; j++)
        {
            env.map[i][j] = 0;
            env.map_col[i][j].clear();
        }
    }

    env.map.init(map_cell());

    for (int i = 0; i < GXM; i++)
        for (int j = 0; j < GYM; j++)
            env.cgrid[i][j] = EMPTY_CLOUD;

    env.cgrid.init(EMPTY_CLOUD);

struct map_colour

struct map_cell

    short colour;
    short flags;

    short object;           // The object: monster, item, feature, or cloud.
    unsigned short flags;   // Flags describing the mappedness of this square.
    unsigned short colour;

    operator short () const { return colour; }
    void clear()            { colour = flags = 0; }

    map_cell() : object(0), flags(0), colour(0) { }
    void clear() { flags = object = colour = 0; }
    unsigned glyph() const;
    bool known() const;
    bool seen() const;

    FixedArray< unsigned short, GXM, GYM >    map;    // discovered terrain
    FixedArray< map_colour, GXM, GYM >        map_col; // map colours

    FixedArray< map_cell, GXM, GYM >        map;    // discovered terrain

    bool unicode_ok;        // Is unicode support available?

                   updating_scores(false), shopping(false), seen_hups(0)

        updating_scores(false), shopping(false), seen_hups(0),
        unicode_ok(false)

    unsigned short      symbol;          // symbol used for seen terrain
    unsigned short      magic_symbol;    // symbol used for magic-mapped terrain

    unsigned            symbol;          // symbol used for seen terrain
    unsigned            magic_symbol;    // symbol used for magic-mapped terrain

    FixedVector<unsigned char, NUM_DCHAR_TYPES> char_table;

    FixedVector<unsigned, NUM_DCHAR_TYPES> char_table;

                           unsigned char symbol);

                           unsigned symbol);

    CSET_UNICODE,       // Unicode.

static bool is_mapped(int x, int y)
{
    return (is_player_mapped(x, y));
}

    if (!in_bounds(x, y) || !is_mapped(x, y))

    if (!in_bounds(x, y) || !is_terrain_seen(x, y))

    if (!in_los(x, y) && (!Options.target_oos || !is_mapped(x, y)))

    if (!in_los(x, y) && (!Options.target_oos || !is_terrain_seen(x, y)))

                || (Options.target_oos && is_mapped(x, y) && is_stash(x, y))));

                || (Options.target_oos && is_terrain_seen(x, y)
                    && is_stash(x, y))));

#define X_BOUND_1               BOUNDARY_BORDER

#define X_BOUND_1               (-1 + BOUNDARY_BORDER)

#define Y_BOUND_1               BOUNDARY_BORDER

#define Y_BOUND_1               (-1 + BOUNDARY_BORDER)

#define LOS_SX     8
#define LOS_EX    25
#define LOS_SY     1
#define LOS_EY    17

#define VIEW_SX    1
#define VIEW_EX   33
#define VIEW_SY    1
#define VIEW_EY   17
#define VIEW_WIDTH  (VIEW_EX - VIEW_SX + 1)
#define VIEW_HEIGHT (VIEW_EY - VIEW_SY + 1)
#define VIEW_Y_DIFF  (((VIEW_EX - VIEW_SX + 1) - (VIEW_EY - VIEW_SY + 1)) / 2) 
// View centre must be the same as LOS centre.
// VIEW_CX == 17
#define VIEW_CX   ((VIEW_SX + VIEW_EX) / 2)
// VIEW_CY == 9
#define VIEW_CY   ((VIEW_SY + VIEW_EY) / 2)

#define VIEW_MIN_WIDTH  33
#define VIEW_MIN_HEIGHT 17

    unsigned short ch, colour;

    unsigned ch;
    unsigned short colour;

    env.map.init(0);
    for (int i = 0; i < GXM; i++)
        for (int j = 0; j < GYM; j++)
            env.map_col[i][j].clear();

    env.map.init(map_cell());

    for (i = 0; i < GXM; i++)
    {
        for (j = 0; j < GYM; j++)
        {
            env.map[i][j] = 0;
            env.map_col[i][j].clear();
        }
    }

    env.map.init(map_cell());

// Enable support for Unicode character glyphs. Note that this needs
// to be accompanied by changes to linker and compiler options and may
// not be available on all platforms. In most cases you want to set
// this option from your makefile, not directly in AppHdr.h (See
// INSTALL for more details.)
// 
// #define UNICODE_GLYPHS

char_set = (ascii | ibm | dec)

char_set = (ascii | ibm | dec | unicode)

cset_ascii, cset_ibm, cset_dec, cset_any

cset_ascii, cset_ibm, cset_dec, cset_unicode, cset_any

        Symbols can be specified using a letter, or by a number (decimal code).

        Symbols can be specified using a letter, or by a number (decimal code),
        or a hexadecimal number (prefixed with x):
        

            cset_ibm = wall:219, arch:0
        shows walls as solid blocks and shops and portals as '0'.

            cset_ibm = wall:219, arch:0, wavy:x7E
        shows walls as solid blocks, shops and portals as '0', and water as
        '~'.

            feature = rock wall { , , red }  # shows rock walls in red
            feature = metal wall {#}         # use '#' for metal walls

         * Colour rock walls red:
            feature = rock wall { , , red }
         * Use # for metal walls in all character sets:
            feature = metal wall {#}
        Symbols can be specified as with cset:
            feature = metal wall {#}
            feature = metal wall {35}
            feature = metal wall {x23}
        all do the same thing.

well as sad stories of deceasedcharacters (being 'YAAD' or 'YASD', i.e.

well as sad stories of deceased characters (being 'YAAD' or 'YASD', i.e.

* Unicode characters for the map (Unix only).

If you have ncursesw and the development headers (usually in the
/usr/include/ncursesw directory) you can build Crawl with support for
Unicode display characters in the map by setting UNICODE_GLYPHS = y
in makefile.unix.

Unicode
-------
Modern Unixes may support Unicode terminals (particularly xterms). If
you have a terminal that can display Unicode characters, and an
ncurses library that can handle Unicode (libncursesw, and its devel
headers), you can build Crawl to display Unicode in the map: set
UNICODE_GLYPHS = y in makefile.unix.
NOTE: You may have libncursesw, but not have the header files; check
that you have the header files installed as well, or you'll get a lot
of errors. Crawl expects the ncursesw headers to be in
/usr/include/ncursesw.
After compiling Crawl with Unicode support, you still need to add the
line "char_set = unicode" in your .crawlrc to tell Crawl to use
Unicode.