inline bool see_grid(const coord_def &p) { return see_grid(p.x, p.y); }

        if ((you.your_level || stair_direction(feat) == CMD_GO_DOWNSTAIRS)

        if ((you.your_level || grid_stair_direction(feat) == CMD_GO_DOWNSTAIRS)

        case DNGN_ENTER_BAZAAR:
        case DNGN_EXIT_BAZAAR:

        case DNGN_ENTER_BAZAAR:
        case DNGN_EXIT_BAZAAR:
            Feature[i].symbol = Options.char_table[ DCHAR_ARCH ];
            Feature[i].colour = EC_SHIMMER_BLUE;
            Feature[i].notable = true;
            Feature[i].map_colour = LIGHTGREY;
            Feature[i].seen_colour = EC_SHIMMER_BLUE;
            break;            

command_type stair_direction(dungeon_feature_type stair_feat);

    if (you.level_type == LEVEL_LABYRINTH || you.level_type == LEVEL_ABYSS
            || you.level_type == LEVEL_PANDEMONIUM)

    if (!can_travel_interlevel())

    traversable_terrain[DNGN_ENTER_BAZAAR] =
    traversable_terrain[DNGN_EXIT_BAZAAR] =

command_type stair_direction(dungeon_feature_type stair)
{
    return ((stair < DNGN_STONE_STAIRS_UP_I
                || stair > DNGN_ROCK_STAIRS_UP)
                && (stair < DNGN_RETURN_FROM_ORCISH_MINES 
                || stair > DNGN_RETURN_RESERVED_4))
        ? CMD_GO_DOWNSTAIRS : CMD_GO_UPSTAIRS;
}

    return stair_direction(grd[you.x_pos][you.y_pos]);

    return grid_stair_direction(grd[you.x_pos][you.y_pos]);

    else if (branch == "Bzr")
        return (level_id(LEVEL_BAZAAR));

    if (you.level_type == LEVEL_LABYRINTH || you.level_type == LEVEL_ABYSS
            || you.level_type == LEVEL_PANDEMONIUM)

    if (!can_travel_interlevel())

    return ((id.level_type == LEVEL_DUNGEON
             && can_travel_interlevel())
            || (id.level_type == LEVEL_PANDEMONIUM
                && you.level_type == LEVEL_PANDEMONIUM));

    return ((id.level_type == LEVEL_DUNGEON && can_travel_interlevel())
            || (id.level_type == you.level_type && player_in_mappable_area()));

    return (player_in_mappable_area() && you.level_type != LEVEL_PANDEMONIUM);

    return (you.level_type == LEVEL_DUNGEON);

#include "mapmark.h"

    marshallByte(th, 5);
    for (int i = 0; i < 5; i++)

    marshallByte(th, MAX_SHOPS);
    for (int i = 0; i < MAX_SHOPS; i++)

    ASSERT(num_shops <= MAX_SHOPS);

    env.clear_markers();

    env_clear_markers();

            env.add_marker(mark);

            env_add_marker(mark);

int random_range(int low, int high, int nrolls);

bool silenced(char x, char y);

bool silenced(int x, int y);
inline bool silenced(const coord_def &p) { return silenced(p.x, p.y); }

bool player_can_hear(char x, char y);

bool player_can_hear(int x, int y);
inline bool player_can_hear(const coord_def &p)
{
    return player_can_hear(p.x, p.y);
}

int random_range(int low, int high, int nrolls)
{
    ASSERT(nrolls > 0);
    int sum = 0;
    for (int i = 0; i < nrolls; ++i)
        sum += random_range(low, high);
    return (sum / nrolls);
}

bool silenced(char x, char y)

bool silenced(int x, int y)

bool player_can_hear(char x, char y)

bool player_can_hear(int x, int y)

        break;
    case EC_SHIMMER_BLUE:
        ret = random_choose_weighted(80, BLUE, 20, LIGHTBLUE, 5, CYAN, 0);

//////////////////////////////////////////////////////////////////////////
// crawl_environment
void crawl_environment::add_marker(map_marker *marker)
{
    markers.insert(dgn_pos_marker(marker->pos, marker));
}
void crawl_environment::remove_marker(map_marker *marker)
{
    std::pair<dgn_marker_map::iterator, dgn_marker_map::iterator>
        els = markers.equal_range(marker->pos);
    for (dgn_marker_map::iterator i = els.first; i != els.second; ++i)
    {
        if (i->second == marker)
        {
            markers.erase(i);
            break;
        }
    }
    delete marker;
}
void crawl_environment::remove_markers_at(const coord_def &c)
{
    std::pair<dgn_marker_map::iterator, dgn_marker_map::iterator>
        els = markers.equal_range(c);
    for (dgn_marker_map::iterator i = els.first; i != els.second; )
    {
        dgn_marker_map::iterator todel = i++;
        delete todel->second;
        markers.erase(todel);
    }
}
map_marker *crawl_environment::find_marker(const coord_def &c,
                                           map_marker_type type) const
{
    std::pair<dgn_marker_map::const_iterator, dgn_marker_map::const_iterator>
        els = markers.equal_range(c);
    for (dgn_marker_map::const_iterator i = els.first; i != els.second; ++i)
        if (type == MAT_ANY || i->second->get_type() == type)
            return (i->second);
    return (NULL);
}
std::vector<map_marker*> crawl_environment::get_markers(const coord_def &c)
    const
{
    std::pair<dgn_marker_map::const_iterator, dgn_marker_map::const_iterator>
        els = markers.equal_range(c);
    std::vector<map_marker*> rmarkers;
    for (dgn_marker_map::const_iterator i = els.first; i != els.second; ++i)
        rmarkers.push_back(i->second);
    return (rmarkers);
}
void crawl_environment::clear_markers()
{
    for (dgn_marker_map::iterator i = markers.begin(); i != markers.end(); ++i)
        delete i->second;
    markers.clear();
}

    stashes.remove_level( level_id(LEVEL_BAZAAR) );

                && you.char_direction != DIR_ASCENDING)

                && you.char_direction != GDT_ASCENDING)

std::string shop_name(int sx, int sy, bool add_stop);

}
std::string shop_name(int sx, int sy, bool add_stop)
{
    std::string name(shop_name(sx, sy));
    if (add_stop)
        name += ".";
    return (name);

    char_direction = DIR_DESCENDING;

    char_direction = GDT_DESCENDING;

    unlink( make_filename( you.your_name, 0, BRANCH_MAIN_DUNGEON,
                           LEVEL_BAZAAR, false ).c_str() );

    if (you.char_direction == DIR_ASCENDING && mon_type == RANDOM_MONSTER

    if (you.char_direction == GDT_ASCENDING && mon_type == RANDOM_MONSTER

    if (you.char_direction == DIR_ASCENDING && you.level_type == LEVEL_DUNGEON)

    if (you.char_direction == GDT_ASCENDING && you.level_type == LEVEL_DUNGEON)

bool grid_is_rock_stair(dungeon_feature_type grid);

command_type grid_stair_direction(dungeon_feature_type grid);
bool grid_sealable_portal(dungeon_feature_type grid);

bool level_type_exits_up(level_area_type type);
bool level_type_exits_down(level_area_type type);

// Terrain changed under 'pos', perform necessary effects.
void dungeon_terrain_changed(const coord_def &pos);

#include "dgnevent.h"

#include "mapmark.h"

#include "mstuff2.h"

        return (true);
    default:
        return (false);
    }
}
bool grid_is_rock_stair(dungeon_feature_type grid)
{
    switch (grid)
    {
    case DNGN_ROCK_STAIRS_UP:
    case DNGN_ROCK_STAIRS_DOWN:

    }
}
bool grid_sealable_portal(dungeon_feature_type grid)
{
    switch (grid)
    {
    case DNGN_ENTER_HELL:
    case DNGN_ENTER_ABYSS:
    case DNGN_ENTER_PANDEMONIUM:
    case DNGN_ENTER_LABYRINTH:
    case DNGN_ENTER_BAZAAR:
        return (true);
    default:
        return (false);
    }
}
command_type grid_stair_direction(dungeon_feature_type grid)
{
    switch (grid)
    {
    case DNGN_STONE_STAIRS_UP_I:
    case DNGN_STONE_STAIRS_UP_II:
    case DNGN_STONE_STAIRS_UP_III:
    case DNGN_ROCK_STAIRS_UP:
    case DNGN_RETURN_FROM_ORCISH_MINES:
    case DNGN_RETURN_FROM_HIVE:
    case DNGN_RETURN_FROM_LAIR:
    case DNGN_RETURN_FROM_SLIME_PITS:
    case DNGN_RETURN_FROM_VAULTS:
    case DNGN_RETURN_FROM_CRYPT:
    case DNGN_RETURN_FROM_HALL_OF_BLADES:
    case DNGN_RETURN_FROM_ZOT:
    case DNGN_RETURN_FROM_TEMPLE:
    case DNGN_RETURN_FROM_SNAKE_PIT:
    case DNGN_RETURN_FROM_ELVEN_HALLS:
    case DNGN_RETURN_FROM_TOMB:
    case DNGN_RETURN_FROM_SWAMP:
    case DNGN_RETURN_FROM_SHOALS:
    case DNGN_RETURN_RESERVED_2:
    case DNGN_RETURN_RESERVED_3:
    case DNGN_RETURN_RESERVED_4:
    case DNGN_ENTER_SHOP:
    case DNGN_EXIT_HELL:
    case DNGN_EXIT_BAZAAR:
        return (CMD_GO_UPSTAIRS);
        
    case DNGN_ENTER_BAZAAR:
    case DNGN_ENTER_HELL:
    case DNGN_ENTER_LABYRINTH:
    case DNGN_STONE_STAIRS_DOWN_I:
    case DNGN_STONE_STAIRS_DOWN_II:
    case DNGN_STONE_STAIRS_DOWN_III:
    case DNGN_ROCK_STAIRS_DOWN:
    case DNGN_ENTER_DIS:
    case DNGN_ENTER_GEHENNA:
    case DNGN_ENTER_COCYTUS:
    case DNGN_ENTER_TARTARUS:
    case DNGN_ENTER_ABYSS:
    case DNGN_EXIT_ABYSS:
    case DNGN_ENTER_PANDEMONIUM:
    case DNGN_EXIT_PANDEMONIUM:
    case DNGN_TRANSIT_PANDEMONIUM:
    case DNGN_ENTER_ORCISH_MINES:
    case DNGN_ENTER_HIVE:
    case DNGN_ENTER_LAIR:
    case DNGN_ENTER_SLIME_PITS:
    case DNGN_ENTER_VAULTS:
    case DNGN_ENTER_CRYPT:
    case DNGN_ENTER_HALL_OF_BLADES:
    case DNGN_ENTER_ZOT:
    case DNGN_ENTER_TEMPLE:
    case DNGN_ENTER_SNAKE_PIT:
    case DNGN_ENTER_ELVEN_HALLS:
    case DNGN_ENTER_TOMB:
    case DNGN_ENTER_SWAMP:
    case DNGN_ENTER_SHOALS:
    case DNGN_ENTER_RESERVED_2:
    case DNGN_ENTER_RESERVED_3:
    case DNGN_ENTER_RESERVED_4:
        return (CMD_GO_DOWNSTAIRS);
        
    default:
        return (CMD_NO_CMD);

         :                          "You hear an empty echo.";

         :                          "You hear a crunching noise.";
}
// Returns true if exits from this type of level involve going upstairs.
bool level_type_exits_up(level_area_type type)
{
    return (type == LEVEL_LABYRINTH || type == LEVEL_BAZAAR);
}
bool level_type_exits_down(level_area_type type)
{
    return (type == LEVEL_PANDEMONIUM || type == LEVEL_ABYSS);

static bool dgn_shift_item_around(const coord_def &pos, item_def &item)
{
    std::list<coord_def> points;
    for (int yi = -1; yi <= 1; ++yi)
    {
        for (int xi = -1; xi <= 1; ++xi)
        {
            if (!xi && !yi)
                continue;
            const coord_def np(pos.x + xi, pos.y + yi);
            if (!in_bounds(np) || travel_point_distance[np.x][np.y])
                continue;
            travel_point_distance[np.x][np.y] = 1;
            const dungeon_feature_type feat = grd(np);
            if (!grid_is_solid(feat) && !grid_destroys_items(feat))
            {
                int index = item.index();
                move_item_to_grid(&index, np.x, np.y);
                return (true);
            }
            points.push_back(np);
        }
    }
    for (std::list<coord_def>::iterator i = points.begin(); i != points.end();
         ++i)
    {
        if (dgn_shift_item_around(*i, item))
            return (true);
    }
    return (false);
}
// Moves an item on the floor to the nearest adjacent floor-space.
static bool dgn_shift_item(const coord_def &pos, item_def &item)
{
    memset(travel_point_distance, 0, sizeof(travel_distance_grid_t));
    travel_point_distance[pos.x][pos.y] = 0;
    return (dgn_shift_item_around(pos, item));
}
static void dgn_check_terrain_items(const coord_def &pos)
{
    const dungeon_feature_type grid = grd(pos);
    if (grid_is_solid(grid) || grid_destroys_items(grid))
    {
        int item = igrd(pos);
        bool did_destroy = false;
        while (item != NON_ITEM)
        {
            const int curr = item;
            item = mitm[item].link;
            // Game-critical item.
            if (true || item_is_critical(mitm[curr]))
                dgn_shift_item(pos, mitm[curr]);
            else
            {
                destroy_item(curr);
                did_destroy = true;
            }
        }
        if (did_destroy && player_can_hear(pos))
            mprf(MSGCH_SOUND, grid_item_destruction_message(grid));
    }
}
static void dgn_check_terrain_monsters(const coord_def &pos)
{
    const int mindex = mgrd(pos);
    if (mindex != NON_MONSTER)
    {
        monsters *mons = &menv[mindex];
        if (grid_is_solid(grd(pos)))
            monster_teleport(mons, true, false);
        else
            mons_check_pool(mons, KILL_MISC, -1);
    }
}
void dungeon_terrain_changed(const coord_def &pos)
{
    dgn_check_terrain_items(pos);
    if (pos == you.pos())
    {
        if (!grid_is_solid(grd(pos)))
        {
            if (!you.flies())
                move_player_to_grid(pos.x, pos.y, false, true, false);
        }
        else
            you_teleport_now(true, false);
    }
    dgn_check_terrain_monsters(pos);
}

    if ((stair_find < DNGN_STONE_STAIRS_UP_I
            || stair_find > DNGN_ROCK_STAIRS_UP)
        && (stair_find < DNGN_RETURN_FROM_ORCISH_MINES || stair_find >= 150))

    if (grid_stair_direction(stair_find) != CMD_GO_UPSTAIRS)

    const bool collect_travel_data = you.level_type != LEVEL_LABYRINTH 
        && you.level_type != LEVEL_ABYSS 
        && you.level_type != LEVEL_PANDEMONIUM;

    const bool collect_travel_data = can_travel_interlevel();

    if (you.level_type == LEVEL_LABYRINTH)

    if (level_type_exits_up(you.level_type))

        if (you.level_type != LEVEL_PANDEMONIUM &&
                you.level_type != LEVEL_ABYSS &&
                you.level_type != LEVEL_LABYRINTH)

        if (can_travel_interlevel())

    char old_level_type = you.level_type;

    const level_area_type old_level_type = you.level_type;

    bool leave_abyss_pan = false;

    if ((stair_find < DNGN_ENTER_LABYRINTH
            || stair_find > DNGN_ROCK_STAIRS_DOWN)
        && stair_find != DNGN_ENTER_HELL
        && ((stair_find < DNGN_ENTER_DIS
                || stair_find > DNGN_TRANSIT_PANDEMONIUM)
            && stair_find != DNGN_STONE_ARCH)
        && !(stair_find >= DNGN_ENTER_ORCISH_MINES
            && stair_find < DNGN_RETURN_FROM_ORCISH_MINES))

    if (grid_stair_direction(stair_find) != CMD_GO_DOWNSTAIRS)

    if (you.level_type == LEVEL_LABYRINTH)

    if (level_type_exits_up(you.level_type))

    bool collect_travel_data = you.level_type != LEVEL_LABYRINTH 
                    && you.level_type != LEVEL_ABYSS
                && you.level_type != LEVEL_PANDEMONIUM;

    bool collect_travel_data = can_travel_interlevel();

    if (stair_find == DNGN_ENTER_LABYRINTH)

    if (stair_find == DNGN_ENTER_LABYRINTH || stair_find == DNGN_ENTER_BAZAAR)

        unnotice_labyrinth_portal();
        you.level_type = LEVEL_LABYRINTH;

        if (stair_find == DNGN_ENTER_LABYRINTH)
            unnotice_labyrinth_portal();

        // remove any markers that were going to expire this labyrinth.
        if (map_marker *marker = env_find_marker(you.pos(), MAT_TIMED_FEATURE))
            dynamic_cast<map_timed_feature_marker*>(marker)->timeout(false);

    if (stair_find == DNGN_ENTER_LABYRINTH)
    {
        you.level_type = LEVEL_LABYRINTH;
    }

    else if (stair_find == DNGN_ENTER_BAZAAR)
    {
        you.level_type = LEVEL_BAZAAR;
    }

    if (you.level_type == LEVEL_LABYRINTH ||
        you.level_type == LEVEL_ABYSS ||
        you.level_type == LEVEL_PANDEMONIUM)

    if (you.level_type != LEVEL_DUNGEON)

        leave_abyss_pan = true;

    case LEVEL_BAZAAR:
        mpr("You enter an inter-dimensional bazaar!");
        break;

    if (level_type_exits_up(you.level_type))
        you.your_level++;
    else if (level_type_exits_down(you.level_type)
             && !level_type_exits_down(old_level_type))
        you.your_level--;
    

    case LEVEL_LABYRINTH:
        you.your_level++;
        break;

        if (old_level_type != LEVEL_PANDEMONIUM)
            you.your_level--;   // Linley-suggested addition 17jan2000 {dlb}

            // Linley-suggested addition 17jan2000 {dlb}
            if (old_level_type != LEVEL_ABYSS)
                you.your_level--;

        if (you.level_type != LEVEL_PANDEMONIUM &&
                you.level_type != LEVEL_ABYSS &&
                you.level_type != LEVEL_LABYRINTH)

        if (can_travel_interlevel())

    if (you.level_type == LEVEL_BAZAAR)
        return "- a Bazaar";

    if (level_type == LEVEL_ABYSS || level_type == LEVEL_PANDEMONIUM
            || level_type == LEVEL_LABYRINTH)

    if (level_type != LEVEL_DUNGEON)

        case LEVEL_BAZAAR:
            return ( long_name ? "a Bazaar" : "Bzr" );

    dungeon_events.fire_event(DET_TURN_ELAPSED);

    if (nseeds > 100)

    if (nseeds > 50)

const int              MAP_CACHE_VERSION = 1006;

const int              MAP_CACHE_VERSION = 1007;

#ifndef __MAPMARK_H__
#define __MAPMARK_H__
#include "dungeon.h"
#include "dgnevent.h"
//////////////////////////////////////////////////////////////////////////
// Map markers
// Can't change this order without breaking saves.
enum map_marker_type
{
    MAT_FEATURE,              // Stock marker.
    MAT_TIMED_FEATURE,
    NUM_MAP_MARKER_TYPES,
    MAT_ANY
};
class map_marker
{
public:
    map_marker(map_marker_type type, const coord_def &pos);
    virtual ~map_marker();
    map_marker_type get_type() const { return type; }
    virtual void activate();
    virtual void write(tagHeader &) const;
    virtual void read(tagHeader &);
    virtual std::string describe() const = 0;
    
    static map_marker *read_marker(tagHeader&);
    static map_marker *parse_marker(const std::string &text)
        throw (std::string);
public:
    coord_def pos;
protected:
    map_marker_type type;
    typedef map_marker *(*marker_reader)(tagHeader &, map_marker_type);
    typedef map_marker *(*marker_parser)(const std::string &);
    static marker_reader readers[NUM_MAP_MARKER_TYPES];
    static marker_parser parsers[NUM_MAP_MARKER_TYPES];
};
class map_feature_marker : public map_marker
{
public:
    map_feature_marker(const coord_def &pos = coord_def(0, 0),
                       dungeon_feature_type feat = DNGN_UNSEEN);
    map_feature_marker(const map_feature_marker &other);
    void write(tagHeader &) const;
    void read(tagHeader &);
    std::string describe() const;
    static map_marker *read(tagHeader &, map_marker_type);
    static map_marker *parse(const std::string &s) throw (std::string);
    
public:
    dungeon_feature_type feat;
};
class map_timed_feature_marker : public map_feature_marker, dgn_event_listener
{
public:
    map_timed_feature_marker(const coord_def &pos = coord_def(),
                             int duration_turns = 0,
                             dungeon_feature_type feat = DNGN_FLOOR);
    void activate();
    void write(tagHeader &) const;
    void read(tagHeader &);
    std::string describe() const;
    void notify_dgn_event(const dgn_event &e);
    // Expires this marker *now* and cleans it up.
    void timeout(bool verbose);
    
    static map_marker *read(tagHeader &, map_marker_type);
    static map_marker *parse(const std::string &s) throw (std::string);
private:
    const char *bell_urgency(int ticks) const; 
    const char *noise_maker(int ticks) const;
   
public:
    // Ticks are a tenth of a turn.
    int duration_ticks;
    int warn_threshold;
};
void env_activate_markers();
void env_add_marker(map_marker *);
void env_remove_marker(map_marker *);
void env_remove_markers_at(const coord_def &c, map_marker_type);
map_marker *env_find_marker(const coord_def &c, map_marker_type);
std::vector<map_marker*> env_get_markers(const coord_def &c);
void env_clear_markers();
#endif

/*
 *  File:       mapmark.cc
 *  Summary:    Level markers (annotations).
 *
 *  Modified for Crawl Reference by $Author: dshaligram $ on $Date: 2007-07-20T11:40:25.964128Z $
 *  
 */
#include "AppHdr.h"
#include "mapmark.h"
#include "direct.h"
#include "libutil.h"
#include "luadgn.h"
#include "stuff.h"
#include "tags.h"
#include "view.h"
////////////////////////////////////////////////////////////////////////
// Dungeon markers
map_marker::marker_reader map_marker::readers[NUM_MAP_MARKER_TYPES] =
{
    &map_feature_marker::read,
    &map_timed_feature_marker::read,
};
map_marker::marker_parser map_marker::parsers[NUM_MAP_MARKER_TYPES] =
{
    &map_feature_marker::parse,
    &map_timed_feature_marker::parse,
};
map_marker::map_marker(map_marker_type t, const coord_def &p)
    : pos(p), type(t)
{
}
map_marker::~map_marker()
{
}
void map_marker::activate()
{
}
void map_marker::write(tagHeader &outf) const
{
    marshallShort(outf, type);
    marshallCoord(outf, pos);
}
void map_marker::read(tagHeader &inf)
{
    // Don't read type! The type has to be read by someone who knows how
    // to look up the unmarshall function.
    unmarshallCoord(inf, pos);
}
map_marker *map_marker::read_marker(tagHeader &inf)
{
    const map_marker_type type =
        static_cast<map_marker_type>(unmarshallShort(inf));
    return readers[type]? (*readers[type])(inf, type) : NULL;
}
map_marker *map_marker::parse_marker(const std::string &s) throw (std::string)
{
    for (int i = 0; i < NUM_MAP_MARKER_TYPES; ++i)
    {
        if (parsers[i])
        {
            if (map_marker *m = parsers[i](s))
                return (m);
        }
    }
    return (NULL);
}
////////////////////////////////////////////////////////////////////////////
// map_feature_marker
map_feature_marker::map_feature_marker(
    const coord_def &p,
    dungeon_feature_type _feat)
    : map_marker(MAT_FEATURE, p), feat(_feat)
{
}
map_feature_marker::map_feature_marker(
    const map_feature_marker &other)
    : map_marker(MAT_FEATURE, other.pos), feat(other.feat)
{
}
void map_feature_marker::write(tagHeader &outf) const
{
    this->map_marker::write(outf);
    marshallShort(outf, feat);
}
void map_feature_marker::read(tagHeader &inf)
{
    map_marker::read(inf);
    feat = static_cast<dungeon_feature_type>(unmarshallShort(inf));
}
map_marker *map_feature_marker::read(tagHeader &inf, map_marker_type)
{
    map_marker *mapf = new map_feature_marker();
    mapf->read(inf);
    return (mapf);
}
map_marker *map_feature_marker::parse(const std::string &s) throw (std::string)
{
    if (s.find("feat:") != 0)
        return (NULL);
    std::string raw = s;
    strip_tag(raw, "feat:", true);
    const dungeon_feature_type ft = dungeon_feature_by_name(raw);
    if (ft == DNGN_UNSEEN)
        throw make_stringf("Bad feature marker: %s (unknown feature '%s')",
                           s.c_str(), raw.c_str());
    return new map_feature_marker(coord_def(0, 0), ft);
}
std::string map_feature_marker::describe() const
{
    return make_stringf("feature (%s)", dungeon_feature_name(feat));
}
////////////////////////////////////////////////////////////////////////////
// map_feature_marker
map_timed_feature_marker::map_timed_feature_marker(
    const coord_def &_pos,
    int duration_turns,
    dungeon_feature_type _feat)
    : map_feature_marker(_pos, _feat), duration_ticks(duration_turns * 10),
      warn_threshold(-1000)
{
    type = MAT_TIMED_FEATURE;
}
void map_timed_feature_marker::activate()
{
    dungeon_events.register_listener(DET_TURN_ELAPSED, this);
    if (player_can_hear(pos))
    {
        const dungeon_feature_type ft = grd(pos);
        switch (ft)
        {
        case DNGN_ENTER_BAZAAR:
            mprf(MSGCH_SOUND, "You %shear coins being counted.",
                 duration_ticks < 1000? "can faintly " : "");
            break;
        case DNGN_ENTER_LABYRINTH:
            mprf(MSGCH_SOUND, "You hear a faint echoing snort.");
            break;
        default:
            break;
        }
    }
}
void map_timed_feature_marker::write(tagHeader &th) const
{
    map_feature_marker::write(th);
    marshallShort(th, duration_ticks);
    marshallShort(th, warn_threshold);
}
void map_timed_feature_marker::read(tagHeader &th)
{
    map_feature_marker::read(th);
    duration_ticks = unmarshallShort(th);
    warn_threshold = unmarshallShort(th);
}
std::string map_timed_feature_marker::describe() const
{
    return make_stringf("timer: %d ticks (%s)",
                        duration_ticks, dungeon_feature_name(feat));
}
const char *map_timed_feature_marker::bell_urgency(int ticks) const
{
    if (ticks > 5000)
        return "stately ";
    else if (ticks > 4000)
        return "";
    else if (ticks > 2500)
        return "brisk ";
    else if (ticks > 1500)
        return "urgent ";
    else if (ticks > 0)
        return "frantic ";
    else
        return "last, dying notes of the ";
}
const char *map_timed_feature_marker::noise_maker(int ticks) const
{
    switch (grd(pos))
    {
    case DNGN_ENTER_LABYRINTH:
        return (ticks > 0? "tolling of a bell" : "bell");
    case DNGN_ENTER_BAZAAR:
        return (ticks > 0? "ticking of an ancient clock" : "clock");
    default:
        return (ticks > 0?
                "trickling of a stream filled with giant, killer bugs."
                : "stream");
    }
}
void map_timed_feature_marker::notify_dgn_event(const dgn_event &e)
{
    if (!e.elapsed_ticks || e.type != DET_TURN_ELAPSED)
        return;
    if (warn_threshold == -1000)
        warn_threshold = std::max(50, duration_ticks - 500);
    
    duration_ticks -= e.elapsed_ticks;
    if (duration_ticks < warn_threshold || duration_ticks <= 0)
    {
        if (duration_ticks > 900)
            warn_threshold = duration_ticks - 500;
        else
            warn_threshold = duration_ticks - 250;
        if (duration_ticks > 0 && player_can_hear(pos))
            mprf(MSGCH_SOUND, "You hear the %s%s.",
                 bell_urgency(duration_ticks),
                 noise_maker(duration_ticks));
        if (duration_ticks <= 0)
            timeout(true);
    }
}
void map_timed_feature_marker::timeout(bool verbose)
{
    if (verbose)
    {
        if (see_grid(pos))
            mprf("%s disappears!",
                 feature_description(grd(pos), NUM_TRAPS, false,
                                     DESC_CAP_THE, false).c_str());
        else
            mpr("The walls and floor vibrate strangely for a moment.");
    }
    // And it's gone forever.
    grd(pos) = feat;
    dungeon_terrain_changed(pos);
    // Stop listening for further ticks.
    dungeon_events.remove_listener(this);
    // Kill this marker.
    env_remove_marker(this);
}
map_marker *map_timed_feature_marker::read(tagHeader &th, map_marker_type)
{
    map_marker *mt = new map_timed_feature_marker();
    mt->read(th);
    return (mt);
}
map_marker *map_timed_feature_marker::parse(const std::string &s)
    throw (std::string)
{
    if (s.find("timer:") != 0)
        return (NULL);
    std::string raw = s;
    strip_tag(raw, "timer:", true);
    int navg = strip_number_tag(raw, "avg:");
    if (navg == TAG_UNFOUND)
        navg = 1;
    if (navg < 1 || navg > 20)
        throw make_stringf("Bad marker spec '%s' (avg out of bounds)",
                           s.c_str());
    dungeon_feature_type feat = DNGN_FLOOR;
    std::string fname = strip_tag_prefix(raw, "feat:");
    if (!fname.empty()
        && (feat = dungeon_feature_by_name(fname)) == DNGN_UNSEEN)
    {
        throw make_stringf("Bad feature name (%s) in marker spec '%s'",
                           fname.c_str(), s.c_str());
    }
    
    std::vector<std::string> limits = split_string("-", raw);
    const int nlims = limits.size();
    if (nlims < 1 || nlims > 2)
        throw make_stringf("Malformed turn range (%s) in marker '%s'",
                           raw.c_str(), s.c_str());
    const int low = atoi(limits[0].c_str());
    const int high = nlims == 1? low : atoi(limits[1].c_str());
    if (low == 0 || high < low)
        throw make_stringf("Malformed turn range (%s) in marker '%s'",
                           raw.c_str(), s.c_str());
    const int duration = low == high? low : random_range(low, high, navg);
    return new map_timed_feature_marker(coord_def(0, 0),
                                        duration, feat);
}
//////////////////////////////////////////////////////////////////////////
// Map markers in env.
void env_activate_markers()
{
    for (dgn_marker_map::iterator i = env.markers.begin();
         i != env.markers.end(); ++i)
    {
        i->second->activate();
    }
}
void env_add_marker(map_marker *marker)
{
    env.markers.insert(dgn_pos_marker(marker->pos, marker));
}
void env_remove_marker(map_marker *marker)
{
    std::pair<dgn_marker_map::iterator, dgn_marker_map::iterator>
        els = env.markers.equal_range(marker->pos);
    for (dgn_marker_map::iterator i = els.first; i != els.second; ++i)
    {
        if (i->second == marker)
        {
            env.markers.erase(i);
            break;
        }
    }
    delete marker;
}
void env_remove_markers_at(const coord_def &c,
                           map_marker_type type)
{
    std::pair<dgn_marker_map::iterator, dgn_marker_map::iterator>
        els = env.markers.equal_range(c);
    for (dgn_marker_map::iterator i = els.first; i != els.second; )
    {
        dgn_marker_map::iterator todel = i++;
        if (type == MAT_ANY || todel->second->get_type() == type)
        {
            delete todel->second;
            env.markers.erase(todel);
        }
    }
}
map_marker *env_find_marker(const coord_def &c, map_marker_type type)
{
    std::pair<dgn_marker_map::const_iterator, dgn_marker_map::const_iterator>
        els = env.markers.equal_range(c);
    for (dgn_marker_map::const_iterator i = els.first; i != els.second; ++i)
        if (type == MAT_ANY || i->second->get_type() == type)
            return (i->second);
    return (NULL);
}
std::vector<map_marker*> env_get_markers(const coord_def &c)
{
    std::pair<dgn_marker_map::const_iterator, dgn_marker_map::const_iterator>
        els = env.markers.equal_range(c);
    std::vector<map_marker*> rmarkers;
    for (dgn_marker_map::const_iterator i = els.first; i != els.second; ++i)
        rmarkers.push_back(i->second);
    return (rmarkers);
}
void env_clear_markers()
{
    for (dgn_marker_map::iterator i = env.markers.begin();
         i != env.markers.end(); ++i)
        delete i->second;
    env.markers.clear();
}

struct map_feat_marker_spec : public map_transformer

struct map_marker_spec : public map_transformer

    dungeon_feature_type feat;

    std::string marker;

    map_feat_marker_spec(int _key, dungeon_feature_type _feat)
        : key(_key), feat(_feat) { }

    map_marker_spec(int _key, const std::string &mark)
        : key(_key), marker(mark) { }

#include "mapmark.h"

}
// Returns true if s contains tag 'tag', and strips out tag from s.
bool strip_tag(std::string &s, const std::string &tag)
{
    if (s == tag)
    {
        s.clear();
        return (true);
    }
    std::string::size_type pos;
    if ((pos = s.find(" " + tag + " ")) != std::string::npos)
    {
        // Leave one space intact.
        s.erase(pos, tag.length() + 1);
        return (true);
    }
    if ((pos = s.find(tag + " ")) != std::string::npos
        || (pos = s.find(" " + tag)) != std::string::npos)
    {
        s.erase(pos, tag.length() + 1);
        return (true);
    }
    return (false);
}
#define TAG_UNFOUND -20404
int strip_number_tag(std::string &s, const std::string &tagprefix)
{
    std::string::size_type pos = s.find(tagprefix);
    if (pos == std::string::npos)
        return (TAG_UNFOUND);
    std::string::size_type ns = s.find(" ", pos);
    if (ns == std::string::npos)
        ns = s.length();
    std::string argument =
        s.substr(pos + tagprefix.length(), ns - pos - tagprefix.length());
    s.erase(pos, ns - pos + 1);
    return atoi(argument.c_str());

    // Transforms and markers have to be regenerated, they will not be copied.

    for (int i = 0, size = map.transforms.size(); i < size; ++i)
        transforms.push_back( map.transforms[i]->clone() );
    for (int i = 0, size = map.markers.size(); i < size; ++i)
        markers.push_back( map.markers[i]->clone() );

    const dungeon_feature_type feat = dungeon_feature_by_name(arg);
    if (feat == DNGN_UNSEEN)
        return make_stringf("unknown feature: %s", arg.c_str());
    transforms.push_back(new map_feat_marker_spec(key[0], feat));    

    transforms.push_back(new map_marker_spec(key[0], arg));

        env.add_marker(markers[i]);

        env_add_marker(markers[i]);

// map_feat_marker_spec

// map_marker_spec

std::string map_feat_marker_spec::apply_transform(map_lines &map)

std::string map_marker_spec::apply_transform(map_lines &map)

        map.add_marker(new map_feature_marker(positions[0], feat));
        return ("");

        try
        {
            map_marker *mark = map_marker::parse_marker(marker);
            if (!mark)
                return make_stringf("Unable to parse marker from %s",
                                    marker.c_str());
            mark->pos = positions[0];
            map.add_marker(mark);
            return ("");
        }
        catch (const std::string &err)
        {
            return (err);
        }

map_transformer::transform_type map_feat_marker_spec::type() const

map_transformer::transform_type map_marker_spec::type() const

std::string map_feat_marker_spec::describe() const

std::string map_marker_spec::describe() const

    return map_feature_marker(coord_def(), feat).describe();

    return ("unimplemented");

map_transformer *map_feat_marker_spec::clone() const

map_transformer *map_marker_spec::clone() const

    return new map_feat_marker_spec(key, feat);

    return new map_marker_spec(key, marker);

                    && you.level_type != LEVEL_PANDEMONIUM)

                 && you.level_type != LEVEL_PANDEMONIUM)

dgnevent.o \

mapmark.o \

#include "mapmark.h"

        return (0);

    
    const coord_def pos(luaL_checkint(ls, 2), luaL_checkint(ls, 3));
    dungeon_feature_type feat = DNGN_UNSEEN;
    if (lua_isnumber(ls, 4))
        feat = static_cast<dungeon_feature_type>( luaL_checkint(ls, 4) );
    else
        feat = dungeon_feature_by_name( luaL_checkstring(ls, 4) );
    map->map.add_marker( new map_feature_marker(pos, feat) );

// String "tags"
#define TAG_UNFOUND -20404
bool strip_tag(std::string &s, const std::string &tag, bool nopad = false);
int strip_number_tag(std::string &s, const std::string &tagprefix);
std::string strip_tag_prefix(std::string &s, const std::string &tagprefix);

}
// Returns true if s contains tag 'tag', and strips out tag from s.
bool strip_tag(std::string &s, const std::string &tag, bool skip_padding)
{
    if (s == tag)
    {
        s.clear();
        return (true);
    }
    std::string::size_type pos;
    if (skip_padding)
    {
        if ((pos = s.find(tag)) != std::string::npos)
        {
            s.erase(pos, tag.length());
            trim_string(s);
            return (true);
        }
        return (false);
    }
    
    if ((pos = s.find(" " + tag + " ")) != std::string::npos)
    {
        // Leave one space intact.
        s.erase(pos, tag.length() + 1);
        trim_string(s);
        return (true);
    }
    if ((pos = s.find(tag + " ")) != std::string::npos
        || (pos = s.find(" " + tag)) != std::string::npos)
    {
        s.erase(pos, tag.length() + 1);
        trim_string(s);
        return (true);
    }
    return (false);

std::string strip_tag_prefix(std::string &s, const std::string &tagprefix)
{
    const std::string::size_type pos = s.find(tagprefix);
    if (pos == std::string::npos)
        return ("");
    std::string::size_type ns = s.find(" ", pos);
    if (ns == std::string::npos)
        ns = s.length();
    
    const std::string argument =
        s.substr(pos + tagprefix.length(), ns - pos - tagprefix.length());
    s.erase(pos, ns - pos + 1);
    trim_string(s);
    return (argument);
}
int strip_number_tag(std::string &s, const std::string &tagprefix)
{
    const std::string num = strip_tag_prefix(s, tagprefix);
    return (num.empty()? TAG_UNFOUND : atoi(num.c_str()));
}

        LEVEL_PANDEMONIUM);

               LEVEL_PANDEMONIUM);

#include "dgnevent.h"

        && you.char_direction == DIR_DESCENDING)

        && you.char_direction == GDT_DESCENDING)

        you.char_direction = DIR_ASCENDING;

        you.char_direction = GDT_ASCENDING;

    if ( grid_destroys_items(my_grid) )

    if ( grid_destroys_items(my_grid) && !silenced(you.pos()) )

    dungeon_events.fire_event(
        dgn_event(DET_TURN_ELAPSED, coord_def(0, 0), turns * 10));

// Returns true if this item should be preserved as far as possible.
bool item_is_critical(const item_def &item);

}
// The Orb of Zot and unique runes are considered critical.
bool item_is_critical(const item_def &item)
{
    if (item.base_type == OBJ_ORBS)
        return (true);
    return (item.base_type == OBJ_MISCELLANY
            && item.sub_type == MISC_RUNE_OF_ZOT
            && (item.plus != RUNE_DEMONIC
                && item.plus != RUNE_ABYSSAL));

#include "mapmark.h"

                                env.find_marker(coord_def(count_x, count_y),

                                env_find_marker(coord_def(count_x, count_y),

                                env.remove_marker(marker);

                                env_remove_marker(marker);

const char *level_area_type_name(int level_type);

    "D", "Lab", "Abyss", "Pan"

    "D", "Lab", "Abyss", "Pan", "Bzr"

static const char *level_area_type_name(int level_type)

const char *level_area_type_name(int level_type)

#include "mapmark.h"

    case LEVEL_BAZAAR:
        return ("bzr");

    }
    else if (stair_taken == DNGN_ENTER_BAZAAR)
    {
        stair_taken = DNGN_STONE_ARCH;

    else if (stair_taken == DNGN_EXIT_BAZAAR)
    {
        stair_taken = DNGN_STONE_STAIRS_DOWN_I;
    }

            if (you.char_direction == DIR_ASCENDING

            if (you.char_direction == GDT_ASCENDING

                if (grd[i][j] == DNGN_ENTER_HELL
                    || grd[i][j] == DNGN_ENTER_ABYSS
                    || grd[i][j] == DNGN_ENTER_PANDEMONIUM)

                if (grid_sealable_portal(grd[i][j]))

                    env_remove_markers_at(coord_def(i,j), MAT_ANY);

static bool level_type_allows_followers(level_area_type type)
{
    return (type == LEVEL_DUNGEON || type == LEVEL_PANDEMONIUM);
}

    // Lose all listeners.
    dungeon_events.clear();

    if (you.char_direction == DIR_ASCENDING &&

    if (you.char_direction == GDT_ASCENDING &&

    if ((you.level_type == LEVEL_DUNGEON
         || you.level_type == LEVEL_PANDEMONIUM)

    if (level_type_allows_followers(you.level_type)

        // Activate markers that want activating, but only when
        // entering a new level in an existing game. If we're starting
        // a new game, or reloading an existing game,
        // env_activate_markers() is done in acr.cc.
        env_activate_markers();

public:
    void add_marker(map_marker *);
    void remove_marker(map_marker *);
    void remove_markers_at(const coord_def &c);
    map_marker *find_marker(const coord_def &c, map_marker_type) const;
    std::vector<map_marker*> get_markers(const coord_def &c) const;
    void clear_markers();

    DIR_DESCENDING = 0,
    DIR_ASCENDING = 1

    GDT_NONE,
    GDT_DESCENDING,
    GDT_ASCENDING

// When adding:
// 
// * New stairs/portals: update grid_stair_direction.
// * Any: edit view.cc and add a glyph and colour for the feature.
// * Any: edit direct.cc and add a description for the feature.
// * Any: edit dat/descript.txt and add a long description if appropriate.
// * Any: check the grid_* functions in misc.cc and make sure
//   they return sane values for your new feature.
//
// Also take note of MINMOVE and MINSEE above.
//

    DNGN_RETURN_RESERVED_4,             // 146 

    DNGN_RETURN_RESERVED_4,             // 146
    // Portals to various places unknown.
    DNGN_ENTER_BAZAAR = 160,
    DNGN_EXIT_BAZAAR,

    EC_SHIMMER_BLUE,    // shimmering colours of blue.

    LEVEL_BAZAAR,

};
// Can't change this order without breaking saves.
enum map_marker_type
{
    MAT_FEATURE,              // Stock marker.
    NUM_MAP_MARKER_TYPES,
    MAT_ANY

        mprf(MSGCH_SOUND, 
             grid_item_destruction_message(grd[you.x_pos][you.y_pos]));

        if (!silenced(you.pos()))
            mprf(MSGCH_SOUND, 
                 grid_item_destruction_message(grd[you.x_pos][you.y_pos]));

    MMT_NO_DOOR    = 0x10     // No secret-doorisation.

    MMT_NO_DOOR    = 0x10,    // No secret-doorisation.
    MMT_OPAQUE     = 0x20     // Vault may impede connectivity.

// Map markers
class map_marker
{
public:
    map_marker(map_marker_type type, const coord_def &pos);
    virtual ~map_marker();
    map_marker_type get_type() const { return type; }
    virtual void write(tagHeader &) const;
    virtual void read(tagHeader &);
    virtual map_marker *clone() const = 0;
    virtual std::string describe() const = 0;
    
    static map_marker *read_marker(tagHeader&);
public:
    coord_def pos;
protected:
    map_marker_type type;
    typedef map_marker *(*marker_reader)(tagHeader &, map_marker_type);
    static marker_reader readers[NUM_MAP_MARKER_TYPES];
};
class map_feature_marker : public map_marker
{
public:
    map_feature_marker(const coord_def &pos = coord_def(0, 0),
                       dungeon_feature_type feat = DNGN_UNSEEN);
    map_feature_marker(const map_feature_marker &other);
    void write(tagHeader &) const;
    void read(tagHeader &);
    map_marker *clone() const;
    std::string describe() const;
    static map_marker *read(tagHeader &, map_marker_type);
    
public:
    dungeon_feature_type feat;
};
//////////////////////////////////////////////////////////////////////////

#include "mapmark.h"

                                 int dl = 0);

                                 int dl = 0,
                                 bool vault_only = false);

static void place_minivaults(int level_number, int level_type);

static void place_minivaults(const std::string &tag = "",
                             int fewest = -1, int most = -1,
                             bool force = false);

static void plan_main(int level_number, char force_plan);

static void plan_main(int level_number, int force_plan);

static void bazaar_level(int level_number);

static void place_shops(int level_number);

static void place_shops(int level_number, int nshops = 0);

    return (dgn_map_mask(c) && dgn_grid_is_passable(grd(c)));

    return ((dgn_map_mask(c) & MMT_OPAQUE) && dgn_grid_is_passable(grd(c)));

            if (travel_point_distance[x][y] || dgn_map_mask[x][y])
                continue;
            if (!dgn_grid_is_passable(grd[x][y]))

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

    if (!place.map.has_tag("transparent"))
        mask_vault(place, MMT_OPAQUE);

    for (unsigned char shcount = 0; shcount < 5; shcount++)

    for (int shcount = 0; shcount < MAX_SHOPS; shcount++)

    env.clear_markers();

    env_clear_markers();

                        env.add_marker(

                        env_add_marker(

    if (you.level_type == LEVEL_LABYRINTH || dgn_level_vetoed)

    if (you.level_type == LEVEL_LABYRINTH || you.level_type == LEVEL_BAZAAR
        || dgn_level_vetoed)

        place_minivaults(level_number, level_type);

        place_minivaults();

    if (level_type == LEVEL_BAZAAR)
    {
        bazaar_level(level_number);
        return (BUILD_QUIT);
    }
    

        return BUILD_QUIT;

        return (BUILD_QUIT);

        return BUILD_SKIP;

        return (BUILD_SKIP);

}
static void fixup_bazaar_stairs()
{
    for (int y = 0; y < GYM; ++y)
    {
        for (int x = 0; x < GXM; ++x)
        {
            const dungeon_feature_type feat = grd[x][y];
            if (grid_is_stone_stair(feat) || grid_is_rock_stair(feat))
            {
                if (grid_stair_direction(feat) == CMD_GO_DOWNSTAIRS)
                    grd[x][y] = DNGN_EXIT_BAZAAR;
                else
                    grd[x][y] = DNGN_STONE_ARCH;
            }
        }
    }
}
static void bazaar_level(int level_number)
{
    int vault = random_map_for_place(level_id::current(), false);
    if (vault == -1)
        vault = random_map_for_tag("bazaar", false);
    if (vault != -1)
    {
        ensure_vault_placed( build_vaults(level_number, vault) );
        link_items();
        fixup_bazaar_stairs();
        return;
    }
    // No primary Bazaar vaults (ugh).
    plan_main(level_number, 0);
    place_minivaults("bazaar", 1, 1, true);
    // No vaults placed yet? Place some shops of our own.
    if (level_vaults.empty())
        place_shops(level_number, random_range(5, MAX_SHOPS));
    link_items();
    fixup_bazaar_stairs();    

static void place_minivaults(int level_number, int level_type)

static void place_minivaults(const std::string &tag, int lo, int hi, bool force)

    const level_id curr = level_id::current();

    if (level_type != LEVEL_DUNGEON)

    if (curr.level_type != LEVEL_DUNGEON && !force)
        return;
    if (lo == -1)
        lo = hi = 1;
    
    int nvaults = random_range(lo, hi);
    if (!tag.empty())
    {
        for (int i = 0; i < nvaults; ++i)
        {
            const int vault = random_map_for_tag(tag, true);
            if (vault == -1)
                return;
            build_minivaults(you.your_level, vault);
        }

    }

            build_minivaults(level_number, vault);

            build_minivaults(you.your_level, vault);

    int chance = level_number == 0? 50 : 100;
    while (chance && random2(100) < chance)

    int chance = you.your_level == 0? 50 : 100;
    while ((chance && random2(100) < chance) || nvaults-- > 0)

        build_minivaults(level_number, vault);

        build_minivaults(you.your_level, vault);

    if (level_number >= 11 && level_number <= 23 && one_chance_in(15))
        place_specific_stair(DNGN_ENTER_LABYRINTH);

    if (one_chance_in(15))
        place_specific_stair(DNGN_ENTER_LABYRINTH, "lab_entry",
                             level_number, true);
    if (one_chance_in(20))
        place_specific_stair(DNGN_ENTER_BAZAAR, "bzr_entry",
                             level_number, true);

                                 int dlevel)

                                 int dlevel,
                                 bool vault_only)

    if (tag.empty() || !place_portal_vault(stair, tag, dlevel))

    if ((tag.empty() || !place_portal_vault(stair, tag, dlevel))
        && !vault_only)
    {

    }

    {
#ifdef DEBUG_DIAGNOSTICS
        mprf(MSGCH_WARN, "Unable to find exit from %s", place.map.name.c_str());
#endif

    }

static void place_shops(int level_number)

static void place_shops(int level_number, int nshops)

    unsigned char no_shops = 0;

    if (!nshops)
    {

    no_shops = MAX_SHOPS;

        nshops = MAX_SHOPS;

    no_shops = ((temp_rand > 28) ? 0 :                        // 76.8%
                (temp_rand > 4)  ? 1                          // 19.2% 
                                 : 1 + random2( MAX_SHOPS )); //  4.0% 

        nshops = ((temp_rand > 28) ? 0 :                        // 76.8%
                  (temp_rand > 4)  ? 1                          // 19.2% 
                  : random_range(1, MAX_RANDOM_SHOPS));          //  4.0% 

    if (no_shops == 0 || level_number < 3)
        return;

        if (nshops == 0 || level_number < 3)
            return;

    }

    for (int i = 0; i < no_shops; i++)

    for (int i = 0; i < nshops; i++)

static void plan_main(int level_number, char force_plan)

static void plan_main(int level_number, int force_plan)

    char do_stairs = 0;

    int do_stairs = 0;

    if (((player_in_branch( BRANCH_MAIN_DUNGEON ) && level_number > 20) 
            || you.level_type == LEVEL_PANDEMONIUM) 

    if (((player_in_branch( BRANCH_MAIN_DUNGEON ) && level_number > 20)
            || you.level_type == LEVEL_PANDEMONIUM)

        grd[40][36] = DNGN_ENTER_ABYSS; 

        grd[40][36] = DNGN_ENTER_ABYSS;

                    || env.find_marker(coord_def(xpos, ypos),

                    || env_find_marker(coord_def(xpos, ypos),

}
////////////////////////////////////////////////////////////////////////
// Dungeon markers
map_marker::marker_reader
map_marker::readers[NUM_MAP_MARKER_TYPES] =
{
    &map_feature_marker::read,
};
map_marker::map_marker(map_marker_type t, const coord_def &p)
    : pos(p), type(t)
{
}
map_marker::~map_marker()
{

void map_marker::write(tagHeader &outf) const
{
    marshallShort(outf, type);
    marshallCoord(outf, pos);
}
void map_marker::read(tagHeader &inf)
{
    // Don't read type! The type has to be read by someone who knows how
    // to look up the unmarshall function.
    unmarshallCoord(inf, pos);
}
map_marker *map_marker::read_marker(tagHeader &inf)
{
    const map_marker_type type =
        static_cast<map_marker_type>(unmarshallShort(inf));
    return readers[type]? (*readers[type])(inf, type) : NULL;
}
////////////////////////////////////////////////////////////////////////////
// map_feature_marker
map_feature_marker::map_feature_marker(
    const coord_def &p,
    dungeon_feature_type _feat)
    : map_marker(MAT_FEATURE, p), feat(_feat)
{
}
map_feature_marker::map_feature_marker(
    const map_feature_marker &other)
    : map_marker(MAT_FEATURE, other.pos), feat(other.feat)
{
}
void map_feature_marker::write(tagHeader &outf) const
{
    this->map_marker::write(outf);
    marshallShort(outf, feat);
}
void map_feature_marker::read(tagHeader &inf)
{
    map_marker::read(inf);
    feat = static_cast<dungeon_feature_type>(unmarshallShort(inf));
}
map_marker *map_feature_marker::read(tagHeader &inf, map_marker_type)
{
    map_marker *mapf = new map_feature_marker();
    mapf->read(inf);
    return (mapf);
}
map_marker *map_feature_marker::clone() const
{
    return new map_feature_marker(pos, feat);
}
std::string map_feature_marker::describe() const
{
    return make_stringf("feature (%s)", dungeon_feature_name(feat));
}

std::string feature_description(int mx, int my);

std::string feature_description(int mx, int my,
                                description_level_type dtype = DESC_CAP_A,
                                bool add_stop = true);
std::string raw_feature_description(dungeon_feature_type grid,
                                    trap_type tr = NUM_TRAPS,
                                    bool temporary = false);

                                trap_type tr = NUM_TRAPS);

                                trap_type trap = NUM_TRAPS,
                                bool temporary = false,
                                description_level_type dtype = DESC_CAP_A,
                                bool add_stop = true);

#include "mapmark.h"

    feat = feature_description(you.x_pos, you.y_pos);

    feat = feature_description(you.x_pos, you.y_pos, DESC_NOCAP_A, false);

    if (grid != DNGN_ENTER_SHOP)
        feat[0] = tolower(feat[0]);
    if (ends_with(feat, "."))
        feat = feat.substr(0, feat.length() - 1);

                                trap_type trap)

                                trap_type trap,
                                bool temporary,
                                description_level_type dtype,
                                bool add_stop)
{
    std::string desc =
        raw_feature_description(grid, trap, temporary);
    if (add_stop)
        desc += ".";
    if (dtype == DESC_PLAIN || (!grid_is_trap(grid) && isupper(desc[0])))
        return (desc);
    switch (dtype)
    {
    case DESC_CAP_THE:
        return "The " + desc;
    case DESC_NOCAP_THE:
        return "the " + desc;
    case DESC_CAP_A:
        return article_a(desc, false);
    case DESC_NOCAP_A:
        return article_a(desc, true);
    default:
        return (desc);
    }
}
std::string raw_feature_description(dungeon_feature_type grid,
                                    trap_type trap,
                                    bool temporary)

            return ("A dart trap.");

            return ("dart trap");

            return ("An arrow trap.");

            return ("arrow trap");

            return ("A spear trap.");

            return ("spear trap");

            return ("An axe trap.");

            return ("axe trap");

            return ("A teleportation trap.");

            return ("teleportation trap");

            return ("An amnesia trap.");

            return ("amnesia trap");

            return ("A blade trap.");

            return ("blade trap");

            return ("A bolt trap.");

            return ("bolt trap");

            return ("A Zot trap.");

            return ("Zot trap");

            return ("A needle trap.");

            return ("needle trap");

            return ("An undefined trap.");

            return ("undefined trap");

        return ("A stone wall.");

        return ("stone wall");

            return ("A wall of the weird stuff which makes up Pandemonium.");

            return ("wall of the weird stuff which makes up Pandemonium");

            return ("A rock wall.");

            return ("rock wall");

        return ("An unnaturally hard rock wall.");    

        return ("unnaturally hard rock wall");    

        return ("A closed door.");

        return ("closed door");

        return ("A metal wall.");

        return ("metal wall");

        return ("A wall of green crystal.");

        return ("wall of green crystal");

           return ("An idol of Beogh.");

           return ("idol of Beogh");

        return ("An orcish idol.");

        return ("orcish idol");

        return ("A wall of solid wax.");

        return ("wall of solid wax");

        return ("A silver statue.");

        return ("silver statue");

        return ("A granite statue.");

        return ("granite statue");

        return ("An orange crystal statue.");

        return ("orange crystal statue");

        return ("Some lava.");

        return ("Some lava");

        return ("Some deep water.");

        return ("Some deep water");

        return ("Some shallow water.");

        return ("Some shallow water");

        return ("Floor.");

        return ("Floor");

        return ("An open door.");

        return ("open door");

        return ("A rock staircase leading down.");

        return ("rock staircase leading down");

        return ("A stone staircase leading down.");

        return ("stone staircase leading down");

        return ("A rock staircase leading up.");

        return ("rock staircase leading up");

        return ("A stone staircase leading up.");

        return ("stone staircase leading up");

        return ("A gateway to Hell.");

        return ("gateway to Hell");

        return ("A mechanical trap.");

        return ("mechanical trap");

        return ("A magical trap.");

        return ("magical trap");

        return ("A trap.");

        return ("trap");

        return ("A shop.");

        return ("shop");

        return ("A labyrinth entrance.");

        if (temporary)
            return ("slowly fading labyrinth entrance");
        else
            return ("labyrinth entrance");
    case DNGN_ENTER_BAZAAR:
        if (temporary)
            return ("gently fading gateway to a fabulous bazaar");
        else
            return ("gateway to a fabulous bazaar");
    case DNGN_EXIT_BAZAAR:
        return ("exit from the bazaar");

        return ("A gateway to the Iron City of Dis.");

        return ("gateway to the Iron City of Dis");

        return ("A gateway to Gehenna.");

        return ("gateway to Gehenna");

        return ("A gateway to the freezing wastes of Cocytus.");

        return ("gateway to the freezing wastes of Cocytus");

        return ("A gateway to the decaying netherworld of Tartarus.");

        return ("gateway to the decaying netherworld of Tartarus");

        return ("A one-way gate to the infinite horrors of the Abyss.");

        return ("one-way gate to the infinite horrors of the Abyss");

        return ("A gateway leading out of the Abyss.");

        return ("gateway leading out of the Abyss");

        return ("An empty arch of ancient stone.");

        return ("empty arch of ancient stone");

        return ("A gate leading to the halls of Pandemonium.");

        return ("gate leading to the halls of Pandemonium");

        return ("A gate leading out of Pandemonium.");

        return ("gate leading out of Pandemonium");

        return ("A gate leading to another region of Pandemonium.");

        return ("gate leading to another region of Pandemonium");

        return ("A staircase to the Orcish Mines.");

        return ("staircase to the Orcish Mines");

        return ("A staircase to the Hive.");

        return ("staircase to the Hive");

        return ("A staircase to the Lair.");

        return ("staircase to the Lair");

        return ("A staircase to the Slime Pits.");

        return ("staircase to the Slime Pits");

        return ("A staircase to the Vaults.");

        return ("staircase to the Vaults");

        return ("A staircase to the Crypt.");

        return ("staircase to the Crypt");

        return ("A staircase to the Hall of Blades.");

        return ("staircase to the Hall of Blades");

        return ("A gate to the Realm of Zot.");

        return ("gate to the Realm of Zot");

        return ("A staircase to the Ecumenical Temple.");

        return ("staircase to the Ecumenical Temple");

        return ("A staircase to the Snake Pit.");

        return ("staircase to the Snake Pit");

        return ("A staircase to the Elven Halls.");

        return ("staircase to the Elven Halls");

        return ("A staircase to the Tomb.");

        return ("staircase to the Tomb");

        return ("A staircase to the Swamp.");

        return ("staircase to the Swamp");

        return ("A staircase to the Shoals.");