void losight(FixedArray<unsigned int, 19, 19>& sh, FixedArray<unsigned char, 80, 70>& gr, int x_p, int y_p);

void losight(FixedArray<unsigned int, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER>& sh,
             FixedArray<dungeon_feature_type, GXM, GYM>& gr,
             int x_p, int y_p);

            seen_notable_thing( object, x, y );

            seen_notable_thing( static_cast<dungeon_feature_type>(object),
                                x, y );

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

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

                                     : Feature[grid_value].map_colour;

        : Feature[grid_value].map_colour;

             FixedArray < unsigned char, 80, 70 > &gr, int x_p, int y_p)

             FixedArray < dungeon_feature_type, 80, 70 > &gr, int x_p, int y_p)

    void found_feature(const coord_def &pos, int grid);

    void found_feature(const coord_def &pos, dungeon_feature_type grid);

    std::string cleaned_feature_description(int feature) const;

    std::string cleaned_feature_description(dungeon_feature_type feature) const;

inline int feature_traverse_cost(unsigned char feature)

inline int feature_traverse_cost(dungeon_feature_type feature)

bool is_altar(unsigned char grid)

bool is_altar(dungeon_feature_type grid)

inline bool is_player_altar(unsigned char grid)

inline bool is_player_altar(dungeon_feature_type grid)

// Travel uses this to check if the square the player is about to move to is
// safe.

    if (is_trap(x, y)
#ifdef CLUA_BINDINGS
        && !clua.callbooleanfn(false, "ch_cross_trap", 
                               "s", trap_name(x, y))
#endif
        )
        return (false);
    

    const int feature = grd(c);

    const dungeon_feature_type feature = grd(c);

std::string explore_discoveries::cleaned_feature_description(int grid) const

std::string explore_discoveries::cleaned_feature_description(
    dungeon_feature_type grid) const

void explore_discoveries::found_feature(const coord_def &pos, int grid)

void explore_discoveries::found_feature(const coord_def &pos,
                                        dungeon_feature_type grid)

            grd[i][j] = unmarshallByte(th);
            

            grd[i][j] =
                static_cast<dungeon_feature_type>(
                    static_cast<unsigned char>(unmarshallByte(th)) );

        env.trap[i].type = unmarshallByte(th);

        env.trap[i].type =
            static_cast<trap_type>(
                static_cast<unsigned char>(unmarshallByte(th)) );

bool see_grid(unsigned char grx, unsigned char gry);

// answers the question: "Is a grid within character's line of sight?"
bool see_grid(unsigned char grx, unsigned char gry)
{
    if (grx > you.x_pos - 9 && grx < you.x_pos + 9
                        && gry > you.y_pos - 9 && gry < you.y_pos + 9)
    {
        if (env.show[grx - you.x_pos + 9][gry - you.y_pos + 9] != 0)
            return true;
        // rare case: can player see self?  (of course!)
        if (grx == you.x_pos && gry == you.y_pos)
            return true;
    }
    return false;
}                               // end see_grid()

    static bool is_boring_feature(dungeon_feature_type feat);

    std::string feature_description() const;

        return items.empty() && enabled;

        return enabled && items.empty() && feat == DNGN_FLOOR;

    dungeon_feature_type feat;
    trap_type trap;
    

#include "direct.h"

#include "view.h"

#define ST_MINOR_VER ((unsigned char) 6)

#define ST_MINOR_VER ((unsigned char) 7)

bool Stash::is_boring_feature(dungeon_feature_type feat)
{
    switch (feat)
    {
    // Discard spammy dungeon features.
    case DNGN_SHALLOW_WATER: case DNGN_DEEP_WATER:
    case DNGN_LAVA: case DNGN_OPEN_DOOR: case DNGN_STONE_STAIRS_DOWN_I:
    case DNGN_STONE_STAIRS_DOWN_II: case DNGN_STONE_STAIRS_DOWN_III:
    case DNGN_STONE_STAIRS_UP_I: case DNGN_STONE_STAIRS_UP_II:
    case DNGN_STONE_STAIRS_UP_III: case DNGN_ROCK_STAIRS_DOWN:
    case DNGN_ROCK_STAIRS_UP: case DNGN_ENTER_SHOP:
    case DNGN_UNDISCOVERED_TRAP:
        return (true);
    default:
        return (grid_is_solid(feat));
    }
}

    feat = grd[x][y];
    trap = NUM_TRAPS;
    if (is_boring_feature(feat))
        feat = DNGN_FLOOR;
    if (grid_is_trap(feat))
        trap = trap_type_at_xy(x, y);
    

        // note item when first entering field of vision
        // (only works with stashes enabled)        
//        learned_something_new(TUT_SEEN_FIRST_OBJECT, x, y);
//        learned_something_new(TUT_SEEN_FIRST_OBJECT, item);
                tutorial_first_item(item);

        tutorial_first_item(item);

}
std::string Stash::feature_description() const
{
    if (feat == DNGN_FLOOR)
        return ("");
    return (::feature_description(feat, trap));

    if (!enabled || items.empty()) return false;

    if (!enabled || (items.empty() && feat == DNGN_FLOOR))
        return false;

    if (!res.matches && feat != DNGN_FLOOR)
    {
        const std::string fdesc = feature_description();
        if (!fdesc.empty() && search.matches(fdesc))
        {
            res.match = fdesc;
            res.matches = 1;
        }
    }
    

    writeByte(file, feat);
    writeByte(file, trap);

    feat =
        static_cast<dungeon_feature_type>(
            static_cast<unsigned char>( readByte(file) ));
    trap =
        static_cast<trap_type>(
            static_cast<unsigned char>( readByte(file) ));
        

    if (items.empty() && visited) return false;

    if (items.empty() && visited)
        return false;

        Stash newStash(x, y);
        if (!newStash.empty())
            stashes[ newStash.abs_pos() ] = newStash;

        Stash new_stash(x, y);
        if (!new_stash.empty())
            stashes[ new_stash.abs_pos() ] = new_stash;

    for (int cy = 1; cy <= 17; ++cy)

    for (int cy = crawl_view.glos1.y; cy <= crawl_view.glos2.y; ++cy)

        for (int cx = 9; cx <= 25; ++cx)

        for (int cx = crawl_view.glos1.x; cx <= crawl_view.glos2.x; ++cx)

            int x = you.x_pos + cx - 17, y = you.y_pos + cy - 9;
            if (x < 0 || x >= GXM || y < 0 || y >= GYM)

            if (!in_bounds(cx, cy) || !see_grid(cx, cy))

            if (!env.show[cx - 8][cy] && !(cx == 17 && cy == 9))
                continue;
            if ((!lev || !lev->update_stash(x, y))
                    && mode == ST_AGGRESSIVE 
                    && igrd[x][y] != NON_ITEM)

            const dungeon_feature_type grid = grd[cx][cy];
            if ((!lev || !lev->update_stash(cx, cy))
                && mode == ST_AGGRESSIVE 
                && (igrd[cx][cy] != NON_ITEM
                    || !Stash::is_boring_feature(grid)))

                lev->add_stash(x, y);

                lev->add_stash(cx, cy);

            if (grd[x][y] == DNGN_ENTER_SHOP)
                get_shop(x, y);

            if (grid == DNGN_ENTER_SHOP)
                get_shop(cx, cy);

    get_matching_features(search, results);

    const int grid = grd[ you.x_pos ][ you.y_pos ];

    const dungeon_feature_type grid = grd[ you.x_pos ][ you.y_pos ];

    const int old_grid = (from_above) ? static_cast<int>(DNGN_FLOOR) 

    const dungeon_feature_type old_grid = (from_above) ? DNGN_FLOOR

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

    const dungeon_feature_type new_grid = grd[x][y];

                const int type = trap_category( env.trap[id].type );

                const dungeon_feature_type type =
                    trap_category( env.trap[id].type );

void seen_notable_thing( int which_thing, int x, int y );

void seen_notable_thing( dungeon_feature_type which_thing, int x, int y );

void get_matching_features(
    const base_pattern &pattern, std::vector<stash_search_result> &results);

void seen_notable_thing( int which_thing, int x, int y )

void seen_notable_thing( dungeon_feature_type which_thing, int x, int y )

static int portal_to_feature(portal_type p)

static dungeon_feature_type portal_to_feature(portal_type p)

}
static void get_matching_altars(
    const base_pattern &pattern, std::vector<stash_search_result> &results)
{
    for ( altar_map_type::const_iterator na_iter = altars_present.begin();
          na_iter != altars_present.end(); ++na_iter )
    {
        const std::string adesc =
            altar_description(na_iter->second);
        
        if (pattern.matches(place_desc(na_iter->first) + adesc))
        {
            stash_search_result sr;
            sr.pos   = na_iter->first;
            sr.match = adesc;
            results.push_back(sr);
        }
    }
}
static void get_matching_portals(
    const base_pattern &pattern, std::vector<stash_search_result> &results)
{
    for ( portal_map_type::const_iterator pl_iter = portals_present.begin();
          pl_iter != portals_present.end(); ++pl_iter )
    {
        const std::string desc =
            portal_description(pl_iter->second);
        
        if (pattern.matches(place_desc(pl_iter->first) + desc + " [portal]"))
        {
            stash_search_result sr;
            sr.pos   = pl_iter->first;
            sr.match = desc;
            results.push_back(sr);
        }
    }

void get_matching_features(
    const base_pattern &pattern, std::vector<stash_search_result> &results)
{
    if (!pattern.valid())
        return;
    get_matching_altars(pattern, results);
    get_matching_portals(pattern, results);
}

    default:
        break;

int monster_habitat(int which_class);

dungeon_feature_type monster_habitat(int which_class);

int monster_habitat(int which_class)

dungeon_feature_type monster_habitat(int which_class)

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

    const dungeon_feature_type grid = grd[x][y];

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

    const dungeon_feature_type grid = grd[x][y];

unsigned char trap_category(unsigned char trap_type);

dungeon_feature_type trap_category(trap_type type);

bool grid_is_wall(int grid);
bool grid_is_opaque(int grid);
bool grid_is_solid(int grid);

int trap_at_xy(int x, int y);
trap_type trap_type_at_xy(int x, int y);
bool grid_is_wall(dungeon_feature_type grid);
bool grid_is_opaque(dungeon_feature_type grid);
bool grid_is_solid(dungeon_feature_type grid);

bool grid_is_trap(int grid);

bool grid_is_trap(dungeon_feature_type grid);

bool grid_is_water(int grid);
bool grid_is_watery( int grid );
god_type grid_altar_god( unsigned char grid );
int altar_for_god( god_type god );
bool grid_is_branch_stairs( unsigned char grid );

bool grid_is_water(dungeon_feature_type grid);
bool grid_is_watery(dungeon_feature_type grid);
god_type grid_altar_god( dungeon_feature_type grid );
dungeon_feature_type altar_for_god( god_type god );
bool grid_is_branch_stairs( dungeon_feature_type grid );

bool grid_destroys_items( int grid );

bool grid_destroys_items( dungeon_feature_type grid );

const char *grid_item_destruction_message( unsigned char grid );

const char *grid_item_destruction_message( dungeon_feature_type grid );

bool grid_is_wall( int grid )

bool grid_is_wall( dungeon_feature_type grid )

bool grid_is_opaque( int grid )

bool grid_is_opaque( dungeon_feature_type grid )

bool grid_is_solid( int grid )

bool grid_is_solid( dungeon_feature_type grid )

bool grid_is_trap(int grid)

bool grid_is_trap(dungeon_feature_type grid)

bool grid_is_water( int grid )

bool grid_is_water( dungeon_feature_type grid )

bool grid_is_watery( int grid )

bool grid_is_watery( dungeon_feature_type grid )

bool grid_destroys_items( int grid )

bool grid_destroys_items( dungeon_feature_type grid )

god_type grid_altar_god( unsigned char grid )

god_type grid_altar_god( dungeon_feature_type grid )

int altar_for_god( god_type god )

dungeon_feature_type altar_for_god( god_type god )

    return (DNGN_ALTAR_ZIN + god - 1);

    return static_cast<dungeon_feature_type>(DNGN_ALTAR_ZIN + god - 1);

bool grid_is_branch_stairs( unsigned char grid )

bool grid_is_branch_stairs( dungeon_feature_type grid )

            const int targ = grd[gx + dx][gy + dy];

            const dungeon_feature_type targ = grd[gx + dx][gy + dy];

const char *grid_item_destruction_message( unsigned char grid )

const char *grid_item_destruction_message( dungeon_feature_type grid )

unsigned char trap_category(unsigned char trap_type)

dungeon_feature_type trap_category(trap_type type)

    switch (trap_type)

    switch (type)

trap_type trap_type_at_xy(int x, int y)
{
    const int idx = trap_at_xy(x, y);
    return (idx == -1? NUM_TRAPS : env.trap[idx].type);
}

            int grid = grd[x][y];

            const dungeon_feature_type grid = grd[x][y];

    const unsigned char my_grid = grd[you.x_pos][you.y_pos];

    const dungeon_feature_type my_grid = grd[you.x_pos][you.y_pos];

                                grd[cx][cy]--;

                                grd[cx][cy] =
                                    static_cast<dungeon_feature_type>(
                                        grd[cx][cy] - 1);

        break;
    default:

    default:
        break;

    unsigned char       type;

    trap_type        type;

    FixedArray< unsigned char, GXM, GYM >    grid;  // terrain grid

    FixedArray<dungeon_feature_type, GXM, GYM> grid;  // terrain grid

                         unsigned char spec_type);

                         trap_type spec_type);

static bool find_in_area(int sx, int sy, int ex, int ey, unsigned char feature);

static bool find_in_area(int sx, int sy, int ex, int ey,
                         dungeon_feature_type feature);

    unsigned char floor=0, unsigned char wall=0, unsigned char avoid=0);
static void replace_area(int sx, int sy, int ex, int ey, unsigned char replace,
    unsigned char feature);

                     dungeon_feature_type floor=DNGN_UNSEEN,
                     dungeon_feature_type wall=DNGN_UNSEEN,
                     dungeon_feature_type avoid=DNGN_UNSEEN);
static void replace_area(int sx, int sy, int ex, int ey,
                         dungeon_feature_type replace,
                         dungeon_feature_type feature);

static void place_specific_stair(int stair, const std::string &tag = "", int dl = 0);

static void place_specific_stair(dungeon_feature_type stair,
                                 const std::string &tag = "",
                                 int dl = 0);

static void make_trail(int xs, int xr, int ys, int yr,int corrlength, int intersect_chance,
    int no_corr, unsigned char begin, unsigned char end=0);

static void make_trail(int xs, int xr, int ys, int yr,int corrlength,
                       int intersect_chance,
                       int no_corr, dungeon_feature_type begin,
                       dungeon_feature_type end=DNGN_UNSEEN);

static void place_pool(unsigned char pool_type, unsigned char pool_x1,

static void place_pool(dungeon_feature_type pool_type, unsigned char pool_x1,

static void many_pools(unsigned char pool_type);

static void many_pools(dungeon_feature_type pool_type);

static void build_river(unsigned char river_type); //mv
static void build_lake(unsigned char lake_type); //mv

static void build_river(dungeon_feature_type river_type); //mv
static void build_lake(dungeon_feature_type lake_type); //mv

                   char forbid_y2, unsigned char force_wall);

                   char forbid_y2, dungeon_feature_type force_wall);

static bool octa_room(spec_room &sr, int oblique_max, unsigned char type_floor);

static bool octa_room(spec_room &sr, int oblique_max,
                      dungeon_feature_type type_floor);

static void box_room(int bx1, int bx2, int by1, int by2, int wall_type);

static void box_room(int bx1, int bx2, int by1, int by2,
                     dungeon_feature_type wall_type);

static void chequerboard(spec_room &sr, unsigned char target,
                         unsigned char floor1, unsigned char floor2);

static void chequerboard(spec_room &sr, dungeon_feature_type target,
                         dungeon_feature_type floor1,
                         dungeon_feature_type floor2);

    const int grid = grd(dc);

    const dungeon_feature_type grid = grd(dc);

        unsigned char vault_wall = DNGN_METAL_WALL;

        dungeon_feature_type vault_wall = DNGN_METAL_WALL;

static void place_ellipse(int x, int y, int a, int b, int feat, int margin)

static void place_ellipse(int x, int y, int a, int b,
                          dungeon_feature_type feat, int margin)

                            int oldfeat, int newfeat)

                            dungeon_feature_type oldfeat,
                            dungeon_feature_type newfeat)

            grd[x][y] = DNGN_STONE_STAIRS_DOWN_I + i;

            grd[x][y] =
                static_cast<dungeon_feature_type>(
                    DNGN_STONE_STAIRS_DOWN_I + i );

            grd[x][y] = DNGN_STONE_STAIRS_UP_I + i;

            grd[x][y] =
                static_cast<dungeon_feature_type>(
                    DNGN_STONE_STAIRS_UP_I + i);

static bool find_in_area(int sx, int sy, int ex, int ey, unsigned char feature)

static bool find_in_area(int sx, int sy, int ex, int ey,
                         dungeon_feature_type feature)

    unsigned char floor, unsigned char wall, unsigned char avoid)

                     dungeon_feature_type floor,
                     dungeon_feature_type wall,
                     dungeon_feature_type avoid)

    int river_type = one_chance_in( 5 + level_number ) ? DNGN_SHALLOW_WATER 
                                                       : DNGN_DEEP_WATER;

    dungeon_feature_type river_type =
        one_chance_in( 5 + level_number ) ? DNGN_SHALLOW_WATER 
        : DNGN_DEEP_WATER;

static int random_trap_for_level(int level_number)

static trap_type random_trap_for_level(int level_number)

    int trap_type = TRAP_DART;

    trap_type type = TRAP_DART;

        trap_type = TRAP_NEEDLE;

        type = TRAP_NEEDLE;

        trap_type = TRAP_SPEAR;

        type = TRAP_SPEAR;

        trap_type = TRAP_AXE;

        type = TRAP_AXE;

    if (trap_type == TRAP_DART?

    if (type == TRAP_DART?

        trap_type = TRAP_ARROW;

        type = TRAP_ARROW;

        trap_type = TRAP_BOLT;

        type = TRAP_BOLT;

        trap_type = TRAP_BLADE;

        type = TRAP_BLADE;

        trap_type = TRAP_ZOT;

        type = TRAP_ZOT;

        trap_type = TRAP_TELEPORT;

        type = TRAP_TELEPORT;

        trap_type = TRAP_AMNESIA;

        type = TRAP_AMNESIA;

    return (trap_type);

    return (type);

        unsigned char &trap_type = env.trap[i].type;

        trap_type &trap_type = env.trap[i].type;

static void place_specific_feature(int feat)

static void place_specific_feature(dungeon_feature_type feat)

static void place_specific_stair(int stair, const std::string &tag, int dlevel)

static void place_specific_stair(dungeon_feature_type stair,
                                 const std::string &tag,
                                 int dlevel)

                       int intersect_chance, int no_corr, unsigned char begin, 
                       unsigned char end)

                       int intersect_chance, int no_corr,
                       dungeon_feature_type begin, 
                       dungeon_feature_type end)

    if (begin != 0)

    if (begin != DNGN_UNSEEN)

    if (end != 0)

    if (end != DNGN_UNSEEN)

            grd[vx][vy] = vgrid[vy - v1y][vx - v1x];

            grd[vx][vy] =
                static_cast<dungeon_feature_type>(
                    vgrid[vy - v1y][vx - v1x] );

            const int stair = j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                                   : DNGN_STONE_STAIRS_UP_I);

            const dungeon_feature_type stair =
                static_cast<dungeon_feature_type>(
                    j + ((i == 0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I));

            const int habitat = monster_habitat(mid);

            const dungeon_feature_type habitat = monster_habitat(mid);

            grd[vx][vy] = f.feat;

            grd[vx][vy] = static_cast<dungeon_feature_type>( f.feat );

            const int trap =

            const trap_type trap =

                : f.trap;

                : static_cast<trap_type>(f.trap);

    const int grid =

    const dungeon_feature_type grid =

                   (vgrid == 'B') ? (DNGN_ALTAR_ZIN + altar_count) :// see below

                   (vgrid == 'B') ?
                   static_cast<dungeon_feature_type>(
                       DNGN_ALTAR_ZIN + altar_count) :// see below

                    grd[vx][vy] = rune_subst;

                    grd[vx][vy] = static_cast<dungeon_feature_type>(rune_subst);

static void replace_area(int sx, int sy, int ex, int ey, unsigned char replace,
    unsigned char feature)

static void replace_area(
    int sx, int sy, int ex, int ey, dungeon_feature_type replace,
    dungeon_feature_type feature)

static void place_pool(unsigned char pool_type, unsigned char pool_x1,

static void place_pool(dungeon_feature_type pool_type, unsigned char pool_x1,

static void many_pools(unsigned char pool_type)

static void many_pools(dungeon_feature_type pool_type)

            grd[j][k] = i;

            grd[j][k] = static_cast<dungeon_feature_type>(i);

            place_specific_stair( j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                              : DNGN_STONE_STAIRS_UP_I) );

            place_specific_stair(
                static_cast<dungeon_feature_type>(
                    j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I) ) );

    unsigned char special_grid = (one_chance_in(3) ? DNGN_METAL_WALL
                                                   : DNGN_STONE_WALL);

    dungeon_feature_type special_grid = (one_chance_in(3) ? DNGN_METAL_WALL
                                         : DNGN_STONE_WALL);

                 (force_plan == 4) ? plan_4(0, 0, 0, 0, 99) :

                 (force_plan == 4) ? plan_4(0, 0, 0, 0, NUM_FEATURES) :

                place_specific_stair( j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                                  : DNGN_STONE_STAIRS_UP_I) );

                place_specific_stair(
                    static_cast<dungeon_feature_type>(
                        j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                             : DNGN_STONE_STAIRS_UP_I) ) );

            unsigned char floor_type = ((temp_rand > 1) ? DNGN_FLOOR :   // 5/7
                                        (temp_rand > 0) ? DNGN_DEEP_WATER// 1/7
                                                        : DNGN_LAVA);    // 1/7

            dungeon_feature_type floor_type =
                ((temp_rand > 1) ? DNGN_FLOOR :   // 5/7
                 (temp_rand > 0) ? DNGN_DEEP_WATER// 1/7
                                 : DNGN_LAVA);    // 1/7

                            char forbid_y2, unsigned char force_wall)

                   char forbid_y2, dungeon_feature_type force_wall)

    unsigned char drawing = DNGN_ROCK_WALL;

    dungeon_feature_type drawing = DNGN_ROCK_WALL;

    if (force_wall != 99)

    if (force_wall != NUM_FEATURES)

        if (force_wall == 99)

        if (force_wall == NUM_FEATURES)

        unsigned char feature = DNGN_FLOOR;

        dungeon_feature_type feature = DNGN_FLOOR;

static bool octa_room(spec_room &sr, int oblique_max, unsigned char type_floor)

static bool octa_room(spec_room &sr, int oblique_max,
                      dungeon_feature_type type_floor)

    unsigned char wall_xform = ((random2(50) > 10) ? DNGN_STONE_WALL   // 78.0%
                                                   : DNGN_METAL_WALL); // 22.0%

    dungeon_feature_type wall_xform =
        ((random2(50) > 10) ? DNGN_STONE_WALL   // 78.0%
         : DNGN_METAL_WALL); // 22.0%

static void box_room(int bx1, int bx2, int by1, int by2, int wall_type)

static void box_room(int bx1, int bx2, int by1, int by2,
                     dungeon_feature_type wall_type)

    int wall_type;          // remember, can have many wall types in one level
    int wall_type_room;     // simplifies logic of innermost loop {dlb}

    // remember, can have many wall types in one level
    dungeon_feature_type wall_type;
    // simplifies logic of innermost loop {dlb}
    dungeon_feature_type wall_type_room;

            place_specific_stair( j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                              : DNGN_STONE_STAIRS_UP_I) );

            place_specific_stair(
                static_cast<dungeon_feature_type>(
                    j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I) ) );

    char type_floor = DNGN_DEEP_WATER;

    dungeon_feature_type type_floor = DNGN_DEEP_WATER;

    unsigned char type_floor = DNGN_FLOOR;
    unsigned char type_2 = DNGN_FLOOR;

    dungeon_feature_type type_floor = DNGN_FLOOR;
    dungeon_feature_type type_2 = DNGN_FLOOR;

        type_2 = DNGN_ROCK_WALL + random2(4);

        type_2 = static_cast<dungeon_feature_type>(DNGN_ROCK_WALL + random2(4));

static void chequerboard( spec_room &sr, unsigned char target,
                          unsigned char floor1, unsigned char floor2 )

static void chequerboard( spec_room &sr, dungeon_feature_type target,
                          dungeon_feature_type floor1,
                          dungeon_feature_type floor2 )

                    grd[pos[0]][pos[1]] = 103;

                    grd[pos[0]][pos[1]] = DNGN_GRANITE_STATUE;

            place_specific_stair(j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                                             : DNGN_STONE_STAIRS_UP_I));

            place_specific_stair(
                static_cast<dungeon_feature_type>(
                    j + ((i==0) ? DNGN_STONE_STAIRS_DOWN_I
                         : DNGN_STONE_STAIRS_UP_I)));

                         unsigned char spec_type)

                         trap_type spec_type)

        spec_type = random2(NUM_TRAPS);

        spec_type = static_cast<trap_type>( random2(NUM_TRAPS) );

static void build_river( unsigned char river_type ) //mv

static void build_river( dungeon_feature_type river_type ) //mv

static void build_lake(unsigned char lake_type) //mv

static void build_lake(dungeon_feature_type lake_type) //mv

std::string feature_description(int grid);

std::string feature_description(dungeon_feature_type grid,
                                trap_type tr = NUM_TRAPS);

            std::string fdesc = feature_description(i);

            std::string fdesc =
                feature_description(static_cast<dungeon_feature_type>(i));

std::string feature_description(int grid)

std::string feature_description(dungeon_feature_type grid,
                                trap_type trap)

    if (grid_is_trap(grid) && trap != NUM_TRAPS)
    {
        switch (trap)
        {
        case TRAP_DART:
            return ("A dart trap.");
        case TRAP_ARROW:
            return ("An arrow trap.");
        case TRAP_SPEAR:
            return ("A spear trap.");
        case TRAP_AXE:
            return ("An axe trap.");
        case TRAP_TELEPORT:
            return ("A teleportation trap.");
        case TRAP_AMNESIA:
            return ("An amnesia trap.");
        case TRAP_BLADE:
            return ("A blade trap.");
        case TRAP_BOLT:
            return ("A bolt trap.");
        case TRAP_ZOT:
            return ("A Zot trap.");
        case TRAP_NEEDLE:
            return ("A needle trap.");
        default:
            error_message_to_player();
            return ("An undefined trap.");
        }
    }
    

    const int grid = grd[mx][my];

    const dungeon_feature_type grid = grd[mx][my];

    {
        int trf;
        for (trf = 0; trf < MAX_TRAPS; trf++)
        {
            if (env.trap[trf].x == mx
                && env.trap[trf].y == my)
            {
                break;
            }
            if (trf == MAX_TRAPS - 1)
            {
                mpr("Error - couldn't find that trap.");
                error_message_to_player();
                break;
            }
        }
        switch (env.trap[trf].type)
        {
        case TRAP_DART:
            return ("A dart trap.");
        case TRAP_ARROW:
            return ("An arrow trap.");
        case TRAP_SPEAR:
            return ("A spear trap.");
        case TRAP_AXE:
            return ("An axe trap.");
        case TRAP_TELEPORT:
            return ("A teleportation trap.");
        case TRAP_AMNESIA:
            return ("An amnesia trap.");
        case TRAP_BLADE:
            return ("A blade trap.");
        case TRAP_BOLT:
            return ("A bolt trap.");
        case TRAP_ZOT:
            return ("A Zot trap.");
        case TRAP_NEEDLE:
            return ("A needle trap.");
        default:
            error_message_to_player();
            return ("An undefined trap.");
        }
    }

        return feature_description(grid, trap_type_at_xy(mx, my));

#include "view.h"

            dvar1 = 179 + you.religion;

            const dungeon_feature_type altar =
                static_cast<dungeon_feature_type>(
                    DNGN_ALTAR_ZIN + you.religion - 1 );

            grd[you.x_pos][you.y_pos] = dvar1;

            grd[you.x_pos][you.y_pos] = altar;

        grd[you.x_pos][you.y_pos] = 179 + god;

        grd[you.x_pos][you.y_pos] =
            static_cast<dungeon_feature_type>( DNGN_ALTAR_ZIN + god - 1 );

static void middle_input();

            grd[you.x_pos][you.y_pos] = atoi(specs);

            grd[you.x_pos][you.y_pos] =
                static_cast<dungeon_feature_type>( atoi(specs) );

    middle_input();

    if (Options.stash_tracking)
        stashes.update_visible_stashes(
            Options.stash_tracking == STM_ALL? 
            StashTracker::ST_AGGRESSIVE :
            StashTracker::ST_PASSIVE);

static void middle_input()
{
    if (Options.stash_tracking)
        stashes.update_visible_stashes(
            Options.stash_tracking == STM_ALL? 
            StashTracker::ST_AGGRESSIVE :
            StashTracker::ST_PASSIVE);
}

    const unsigned char targ_grid  =  grd[ targ_x ][ targ_y ];

    const dungeon_feature_type targ_grid  =  grd[ targ_x ][ targ_y ];

    FixedVector < unsigned char, 5 > replaced;

    FixedVector<dungeon_feature_type, 5> replaced;

                    grd[i][j] = DNGN_ALTAR_ZIN + random2(12);

                    grd[i][j] =
                        static_cast<dungeon_feature_type>(
                            DNGN_ALTAR_ZIN + random2(12) );