void set_envmap_col( int x, int y, int colour, int flags );
void set_envmap_col( int x, int y, int colour );

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

static int get_viewobj_flags(int viewobj);

}
void set_envmap_glyph(int x, int y, int chr, int col, int object)
{
    set_envmap_char(x, y, chr);
    set_envmap_col(x, y, col, get_viewobj_flags(object));

}
void set_envmap_col( int x, int y, int colour )
{
    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;
}
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;
}
bool is_envmap_item(int x, int y)
{
    return (env.map_col[x - 1][y - 1].flags & MC_ITEM);
}
bool is_envmap_mons(int x, int y)
{
    return (env.map_col[x - 1][y - 1].flags & MC_MONS);

int get_envmap_col(int x, int y)
{
    return (env.map_col[x - 1][y - 1].colour);
}

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

            env.map_col[i][j].clear();

}
static int get_viewobj_flags(int object)
{
    // Check for monster glyphs.
    if (object >= DNGN_START_OF_MONSTERS)
        return (MC_MONS);
    // Check for item glyphs.
    if (object >= DNGN_ITEM_ORB && object < DNGN_CLOUD)
        return (MC_ITEM);
    // We don't care to look further; we could check for
    // clouds here as well.
    return (0);

    const int map_value = (unsigned char) env.map[x][y];

    // XXX: Yeah, this is ugly, but until we have stored layers in the
    // map we can't tell if we've seen a square, detected it, or just
    // detected the item or monster on top... giving colour here will
    // result in detect creature/item detecting features like stairs. -- bwr
    if (map_value != get_sightmap_char(grid_value))
    {
        // If there's an item on this square, change colour to indicate
        // that, iff the item's glyph matches map_value. XXX: Potentially
        // abusable? -- ds 
        int item = igrd[x + 1][y + 1];
        if (item_colour && item != NON_ITEM 
                && map_value == 
                        get_sightmap_char(get_item_dngn_code(mitm[item])))
        {
            unsigned ic = mitm[item].colour;
            if (mitm[item].link != NON_ITEM )
                ic |= COLFLAG_ITEM_HEAP;

            // If the item colour is the background colour, tweak it to WHITE
            // instead to catch the player's eye.
            return fix_colour( ic == tc? WHITE : ic );
        }
    }

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

            unsigned short envc = env.map[x][y] & MAP_CHARACTER_MASK;

            unsigned short envc = get_envmap_char(x, y);

            const int item = igrd[x + 1][y + 1];
            if (item != NON_ITEM 
                    && envc == 
                        get_sightmap_char(get_item_dngn_code(mitm[item])))

            if (is_envmap_item(x, y))

                    set_envmap_char( gx, gy, ch );

                    set_envmap_glyph( gx, gy, ch, colour, object );

                            set_envmap_char( gx, gy, buffy[bufcount] );

                            set_envmap_glyph( gx, gy, ch, colour, object );

                            set_envmap_char( gx, gy, ch );

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

void tag_init(long largest_tag = 50000);

void tag_init(long largest_tag = 100000);

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

            if (minorVersion >= 11)
            {
                env.map_col[i][j].colour = unmarshallShort(th);
                env.map_col[i][j].flags  = unmarshallShort(th);
            }
            else
                env.map_col[i][j].clear();

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

            {

                env.map_col[i][j].clear();
            }

    // 0.11 env colours moved into env.mapcol

    write_tagged_file( saveFile, SAVE_MAJOR_VERSION, 10, TAGTYPE_LEVEL );

    write_tagged_file( saveFile, SAVE_MAJOR_VERSION, 11, TAGTYPE_LEVEL );

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

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

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

            env.map_col[i][j].clear();

            env.map_col[i][j].clear();