void set_terrain_changed( int x, int y );

}
inline void set_terrain_changed(const coord_def &c)
{
    set_terrain_changed(c.x, c.y);

    const bool wizard_map = map_radius == 1000 && you.wizard;

            if (is_terrain_known(i, j))

            if (!wizard_map && is_terrain_known(i, j))

                if (!get_envmap_obj(i, j))

                if (wizard_map || !get_envmap_obj(i, j))

                        && grd[i][j] == DNGN_EXIT_PANDEMONIUM)
#ifdef WIZARD
                    || (map_radius == 1000 && you.wizard)
#endif
                    )

                     && grd[i][j] == DNGN_EXIT_PANDEMONIUM)
                    || wizard_map)

static void mons_open_door(const coord_def &pos)
{
    if (grd(pos) == DNGN_SECRET_DOOR && !see_grid(pos))
        set_terrain_changed(pos);
    grd(pos) = DNGN_OPEN_DOOR;
}

    const coord_def newpos = monster->pos() + coord_def(mmov_x, mmov_y);

    if (grd[monster->x + mmov_x][monster->y + mmov_y] == DNGN_CLOSED_DOOR
        || (grd[monster->x + mmov_x][monster->y + mmov_y] == DNGN_SECRET_DOOR

    if (grd(newpos) == DNGN_CLOSED_DOOR
        || (grd(newpos) == DNGN_SECRET_DOOR

                grd[monster->x + mmov_x][monster->y + mmov_y] = DNGN_OPEN_DOOR;

                mons_open_door(newpos);

            grd[monster->x + mmov_x][monster->y + mmov_y] = DNGN_OPEN_DOOR;

            mons_open_door(newpos);

            set_terrain_changed(monster->pos() + coord_def(mmov_x, mmov_y));

               bool check_place = false);

               bool check_place = false,
               bool clobber = false);

int find_map_by_name(const std::string &name);

                       bool check_place);

                       bool check_place, bool clobber);

                        bool check_place);

                        bool check_place, bool clobber);

        bool check_place)

        bool check_place,
        bool clobber)

    return (write_vault( vdefs[which_vault], vgrid, place, check_place ));

    return (write_vault( vdefs[which_vault], vgrid, place,
                         check_place, clobber ));

                       bool check_place)

                       bool check_place, bool clobber)

                                              place, check_place);

                                              place, check_place, clobber);

                          bool check_place)

                          bool check_place, bool clobber)

            if (igrd[x][y] != NON_ITEM || mgrd[x][y] != NON_MONSTER)

            if (!clobber
                && (igrd[x][y] != NON_ITEM || mgrd[x][y] != NON_MONSTER))

#ifdef DEBUG_DIAGNOSTICS
                mprf(MSGCH_DIAGNOSTICS,
                     "Rejecting place because of %s at (%d,%d)",
                     dungeon_feature_name(grid), x, y);
#endif

                             bool check_place)

                             bool check_place, bool clobber)

    if (bad_map_place(def, startx, starty, width, height, check_place))

    if (bad_map_place(def, startx, starty, width, height, check_place,
                      clobber))

        bool check_place)

        bool check_place,
        bool clobber)

    if (!apply_vault_grid(def, map, place, check_place))

    if (!apply_vault_grid(def, map, place, check_place, clobber))

}
int find_map_by_name(const std::string &name)
{
    for (unsigned i = 0, size = vdefs.size(); i < size; ++i)
        if (vdefs[i].name == name)
            return (i);
    return (-1);

#include <vector>

bool builder(int level_number, int level_type);
void level_welcome_messages();
void define_zombie(int mid, int ztype, int cs, int power);
bool is_wall(int feature);
bool place_specific_trap(int spec_x, int spec_y,  trap_type spec_type);
void place_spec_shop(int level_number, int shop_x, int shop_y,
                     int force_s_type, bool representative = false);
bool unforbidden(const coord_def &c, unsigned mask);
coord_def dgn_find_nearby_stair(int stair_to_find, bool find_closest);

bool builder(int level_number, int level_type);
bool dgn_place_map(int map, bool generating_level, bool clobber);
void level_clear_vault_memory();
void level_welcome_messages();
void define_zombie(int mid, int ztype, int cs, int power);
bool is_wall(int feature);
bool place_specific_trap(int spec_x, int spec_y,  trap_type spec_type);
void place_spec_shop(int level_number, int shop_x, int shop_y,
                     int force_s_type, bool representative = false);
bool unforbidden(const coord_def &c, unsigned mask);
coord_def dgn_find_nearby_stair(int stair_to_find, bool find_closest);

#include "view.h"

static bool build_secondary_vault(int level_number, int vault, int rune_subst = -1);

static bool build_secondary_vault(int level_number, int vault,
                                  int rune_subst = -1,
                                  bool generating_level = true,
                                  bool clobber = false);

                         bool check_vault_place = false);

                         bool check_vault_place = false,
                         bool generating_level = true, bool clobber = false);

                             bool level_builder = true, bool clobber = false,

static dgn_region_list vault_zones;

}
void level_clear_vault_memory()
{
    level_vaults.clear();
    dgn_map_mask.init(0);

    dgn_map_mask.init(0);
    level_vaults.clear();
    vault_zones.clear();

    level_clear_vault_memory();

        build_minivaults( level_number, vaultidx,

        build_minivaults( level_number, vaultidx, true, false,

            build_minivaults( level_number, vaultidx,

            build_minivaults( level_number, vaultidx, true, false,

                                 const vault_placement &place)

                                 const vault_placement &place,
                                 bool clobber)

            const dungeon_feature_type dfeat = grd[vx][vy];

            if ((grd[vx][vy] != DNGN_FLOOR
                 && grd[vx][vy] != DNGN_ROCK_WALL
                 && grd[vx][vy] != DNGN_CLOSED_DOOR
                 && grd[vx][vy] != DNGN_SECRET_DOOR
                 && (!water_ok ||
                     (grd[vx][vy] != DNGN_DEEP_WATER
                      && grd[vx][vy] != DNGN_SHALLOW_WATER)))
                || igrd[vx][vy] != NON_ITEM
                || mgrd[vx][vy] != NON_MONSTER)

            if ((dfeat != DNGN_FLOOR
                 && dfeat != DNGN_ROCK_WALL
                 && dfeat != DNGN_CLOSED_DOOR
                 && dfeat != DNGN_SECRET_DOOR
                 && (!water_ok
                     || (dfeat != DNGN_DEEP_WATER
                         && dfeat != DNGN_SHALLOW_WATER))
                 && (!clobber
                     || (!grid_is_solid(dfeat) && dfeat != DNGN_LAVA
                         && !grid_is_watery(dfeat))))
                || (!clobber
                    && (igrd[vx][vy] != NON_ITEM
                        || mgrd[vx][vy] != NON_MONSTER)))

                                 int &v1x, int &v1y)

                                 int &v1x, int &v1y, bool clobber)

        if (!safe_minivault_place( v1x, v1y, place ))

        if (!safe_minivault_place( v1x, v1y, place, clobber ))

                             bool building_level, bool clobber,

    else if (!find_minivault_place(place, v1x, v1y))

    else if (!find_minivault_place(place, v1x, v1y, clobber))

    place.map.map.apply_markers(coord_def(v1x, v1y));
    

    vault_zones.push_back(
        dgn_region(place.x, place.y, place.width, place.height));

            const dungeon_feature_type oldgrid = grd[vx][vy];

            if (!building_level)
            {
                link_items();
                const dungeon_feature_type newgrid = grd[vx][vy];
                grd[vx][vy] = oldgrid;
                dungeon_terrain_changed(coord_def(vx, vy), newgrid);
                env_remove_markers_at(coord_def(vx, vy), MAT_ANY);
            }

    place.map.map.apply_markers(coord_def(v1x, v1y));    

    }
}
static dungeon_feature_type dgn_find_rune_subst(const std::string &tag)
{
    const std::string suffix("_entry");
    const std::string::size_type psuffix = tag.find(suffix);
    if (psuffix == std::string::npos)
        return (DNGN_FLOOR);
    const std::string key = tag.substr(0, psuffix);
    if (key == "bzr")
        return (DNGN_ENTER_PORTAL_VAULT);
    else if (key == "lab")
        return (DNGN_ENTER_LABYRINTH);
    else if (key == "hell")
        return (DNGN_ENTER_HELL);
    else if (key == "pan")
        return (DNGN_ENTER_PANDEMONIUM);
    else if (key == "abyss")
        return (DNGN_ENTER_ABYSS);
    else
    {
        for (int i = 0; i < NUM_BRANCHES; ++i)
        {
            if (branches[i].entry_stairs != NUM_FEATURES
                && !strcasecmp(branches[i].abbrevname, key.c_str()))
            {
                return (branches[i].entry_stairs);
            }
        }
    }
    return (DNGN_FLOOR);
}
static dungeon_feature_type dgn_find_rune_subst_tags(const std::string &tags)
{
    std::vector<std::string> words = split_string(" ", tags);
    for (int i = 0, size = words.size(); i < size; ++i)
    {
        const dungeon_feature_type feat = dgn_find_rune_subst(words[i]);
        if (feat != DNGN_FLOOR)
            return (feat);

    return (DNGN_FLOOR);

bool dgn_place_map(int map, bool generating_level, bool clobber)
{
    const map_def *mdef = map_by_index(map);
    bool did_map = false;
    if (mdef->is_minivault())
        did_map =
            build_minivaults(you.your_level, map, generating_level, clobber);
    else
    {
        dungeon_feature_type rune_subst = DNGN_FLOOR;
        if (mdef->has_tag_suffix("_entry"))
            rune_subst = dgn_find_rune_subst_tags(mdef->tags);
        did_map = build_secondary_vault(you.your_level, map, rune_subst,
                                        generating_level, clobber);
    }

    // Activate any markers within the map.
    if (did_map)
    {
        const vault_placement &vp = level_vaults[level_vaults.size() - 1];
        for (int y = vp.y; y < vp.y + vp.height; ++y)
        {
            for (int x = vp.x; x < vp.x + vp.width; ++x)
            {
                std::vector<map_marker *> markers =
                    env_get_markers(coord_def(x, y));
                for (int i = 0, size = markers.size(); i < size; ++i)
                    markers[i]->activate();
                if (!see_grid(x, y))
                    set_terrain_changed(x, y);
            }
        }
    }
    return (did_map);
}

static bool build_secondary_vault(int level_number, int vault, int rune_subst)

static bool build_secondary_vault(int level_number, int vault,
                                  int rune_subst, bool generating_level,
                                  bool clobber)

    if (build_vaults(level_number, vault, rune_subst, true, true))

    if (build_vaults(level_number, vault, rune_subst, true, true,
                     generating_level, clobber))

                         bool build_only, bool check_collisions)

                         bool build_only, bool check_collisions,
                         bool generating_level, bool clobber)

    const int gluggy = vault_main(vgrid, place, force_vault, check_collisions);

    const int gluggy = vault_main(vgrid, place, force_vault,
                                  check_collisions, clobber);

    place.map.map.apply_markers(coord_def(place.x, place.y));
    

            const dungeon_feature_type oldgrid = grd[vx][vy];

            if (!generating_level)
            {
                // Have to link items each square at a time, or
                // dungeon_terrain_changed could blow up.
                link_items();
                const dungeon_feature_type newgrid = grd[vx][vy];
                grd[vx][vy] = oldgrid;
                dungeon_terrain_changed(coord_def(vx, vy), newgrid);
                env_remove_markers_at(coord_def(vx, vy), MAT_ANY);
            }

    place.map.map.apply_markers(coord_def(place.x, place.y));

    vault_zones.push_back(
        dgn_region(place.x, place.y, place.width, place.height));

        if (early_exit && at != from && grd(at) == DNGN_FLOOR)

        const dungeon_feature_type feat = grd(at);
        if (early_exit && at != from && is_traversable(feat))

        if (unforbidden(at, MMT_VAULT))

        if (unforbidden(at, MMT_VAULT) && !is_traversable(feat))

void debug_place_map();

}
static void debug_load_map_by_name(const std::string &name)
{
    level_clear_vault_memory();
    const int map = find_map_by_name(name);
    if (map == -1)
    {
        mprf("Can't find map named '%s'.", name.c_str());
        return;
    }
    if (dgn_place_map(map, false, true))
        mprf("Successfully placed %s.", map_by_index(map)->name.c_str());
    else
        mprf("Failed to place %s.", map_by_index(map)->name.c_str());
}
void debug_place_map()
{
    char what_to_make[100];
    mesclr();
    mprf(MSGCH_PROMPT, "Enter map name: ");
    if (cancelable_get_line(what_to_make, sizeof what_to_make))
    {
        canned_msg(MSG_OK);
        return;
    }
    std::string what = what_to_make;
    trim_string(what);
    if (what.empty())
    {
        canned_msg(MSG_OK);
        return;
    }
    debug_load_map_by_name(what);

                       "L      : place a vault by name\n"

                       "T      : make a trap\n"
                       "v      : show gold value of an item\n",

                       "T      : make a trap\n",

                       "v      : show gold value of an item\n"

                       "=      : sum skill points\n"

        break;
    case 'L':
        debug_place_map();