#define BUILD_METHOD_KEY "build_method_key"
#define LAYOUT_TYPE_KEY  "layout_type_key"
#define LEVEL_VAULTS_KEY "level_vaults_key"
#define TEMP_VAULTS_KEY  "temp_vaults_key"
#define LEVEL_EXTRAS_KEY "level_extras_key"
#define LEVEL_ID_KEY     "level_id_key"

void remember_vault_placement(std::string key, vault_placement &place);

// Used by debug_mons_scan() when announcing that a just generated level
// has floating/detached monsters.
bool river_level, lake_level, many_pools_level;

            // If debug_mons_scan() find a problem while Generating_Level is

            // If debug_mons_scan() finds a problem while Generating_Level is

            if (dgn_Build_Method.size() > 0 && dgn_Build_Method[0] == ' ')
                dgn_Build_Method = dgn_Build_Method.substr(1);

            env.properties[BUILD_METHOD_KEY] = dgn_Build_Method;
            env.properties[LAYOUT_TYPE_KEY]  = dgn_Layout_Type;
            env.properties[LEVEL_ID_KEY]     = level_id::current().describe();

    river_level      = false;
    lake_level       = false;
    many_pools_level = false;

    // Set up containers for storing some level generation info.
    env.properties[LEVEL_VAULTS_KEY].new_table(SV_STR);
    env.properties[TEMP_VAULTS_KEY].new_table(SV_STR);
    env.properties[LEVEL_EXTRAS_KEY].new_vector(SV_STR);

    dgn_Layout_Type = "rooms";

        dgn_Layout_Type.clear();

    dgn_Layout_Type = "shoals";

    dgn_Build_Method += make_stringf(" shoals [%d]", level_number);
    dgn_Layout_Type   = "shoals";

    dgn_Layout_Type = "swamp";

    dgn_Build_Method += " swamp";
    dgn_Layout_Type   = "swamp";

    dgn_Build_Method += make_stringf(" portal_vault_level [%d]",
                                     level_number);
    dgn_Layout_Type   = "portal vault";

        dgn_Build_Method += " random_map_for_place";

        dgn_Build_Method += " normal_random_map_for_place";

    dgn_Build_Method += make_stringf(" basic [%d]", level_number);
    dgn_Layout_Type  = "basic";

    std::string extra = make_stringf("special room [%s %d]",
                                     vault->name.c_str(), level_number);
    env.properties[LEVEL_EXTRAS_KEY].get_vector().push_back(extra);

    remember_vault_placement(LEVEL_VAULTS_KEY, place);

    many_pools_level = true;

    std::string extra = make_stringf("many pools [%d %d]", (int) pool_type,
                                     num_pools);
    env.properties[LEVEL_EXTRAS_KEY].get_vector().push_back(extra);

    dgn_Build_Method = "spotty_level";

    dgn_Build_Method += make_stringf(" spotty_level [%d%s%s]",
                                     iterations, seeded ? " seeeded" : "",
                                     boxy ? " boxy" : "");

    else if (dgn_Layout_Type.empty())
        dgn_Layout_Type = "spotty";

    dgn_Build_Method = "bigger_room";
    dgn_Layout_Type  = "open";

    dgn_Build_Method += " bigger_room";
    dgn_Layout_Type   = "open";

    dgn_Build_Method = "plan_main";
    dgn_Layout_Type  = "rooms";

    dgn_Build_Method += make_stringf(" plan_main [%d%s]", level_number,
                                     force_plan ? " force_plan" : "");
    dgn_Layout_Type   = "rooms";

    dgn_Build_Method = "plan_1";
    dgn_Layout_Type  = "open";

    dgn_Build_Method += make_stringf(" plan_1 [%d]", level_number);
    dgn_Layout_Type   = "open";

    dgn_Build_Method = "plan_2";
    dgn_Layout_Type  = "cross";

    dgn_Build_Method += " plan_2";
    dgn_Layout_Type   = "cross";

    dgn_Build_Method = "plan_3";
    dgn_Layout_Type  = "rooms";

    dgn_Build_Method += " plan_3";
    dgn_Layout_Type   = "rooms";

    dgn_Build_Method = "plan_4";
    dgn_Layout_Type  = "city";

    dgn_Build_Method += make_stringf(" plan_4 [%d,%d %d,%d %d]",
                                     (int) forbid_x1, (int) forbid_y1,
                                     (int) forbid_x2, (int) forbid_y2,
                                     (int) force_wall);
    dgn_Layout_Type   = "city";

    dgn_Build_Method = "plan_5";
    dgn_Layout_Type  = "misc"; // XXX: What type of layout is this?

    dgn_Build_Method += " plan_5";
    dgn_Layout_Type   = "misc"; // XXX: What type of layout is this?

    dgn_Build_Method = "plan_6";
    dgn_Layout_Type  = "open";

    dgn_Build_Method += make_stringf(" plan_6 [%d]", level_number);
    dgn_Layout_Type   = "open";

    dgn_Build_Method = "octa_room";

    dgn_Build_Method += make_stringf(" octa_room [%d %d]", oblique_max,
                                     (int) type_floor);

    remember_vault_placement(LEVEL_VAULTS_KEY, place);

    dgn_Layout_Type = "labyrinth";

    dgn_Build_Method += make_stringf(" labyrinth [%d]", level_number);
    dgn_Layout_Type   = "labyrinth";

    dgn_Build_Method = "city_level";
    dgn_Layout_Type  = "city";

    dgn_Build_Method += make_stringf(" city_level [%d]", level_number);
    dgn_Layout_Type   = "city";

    dgn_Build_Method += make_stringf(" roguey_level [%d%s]", level_number,
                                     make_stairs ? " make_stairs" : "");

    river_level = true;

    std::string extra = make_stringf("river [%d]", (int) river_type);
    env.properties[LEVEL_EXTRAS_KEY].get_vector().push_back(extra);

    lake_level = true;

    std::string extra = make_stringf("lake [%d]", (int) lake_type);
    env.properties[LEVEL_EXTRAS_KEY].get_vector().push_back(extra);

}
void remember_vault_placement(std::string key, vault_placement &place)
{
    CrawlHashTable &table = env.properties[key].get_table();
    std::string name = make_stringf("%s [%d]", place.map.name.c_str(),
                                    table.size() + 1);
    std::string place_str
        = make_stringf("(%d,%d) (%d,%d) orient: %d lev: %d alt: %d rune: %d "
                       "subst: %d",
                       place.pos.x, place.pos.y, place.size.x, place.size.y,
                       place.orient, place.level_number, place.altar_count,
                       place.num_runes, place.rune_subst);
    table[name] = place_str;

    mon_inv_type mon_slot;

    mon_inv_type mon_slot = NUM_MONSTER_SLOTS;

        && mon_slot != NUM_MONSTER_SLOTS

        if (old_eq != NON_ITEM)

        if (old_eq != NON_ITEM && mon_slot != NUM_MONSTER_SLOTS)

    if (!Generating_Level)
        return;

    CrawlHashTable &props = env.properties;

    extern std::string dgn_Build_Method;

    std::string method;
    std::string type;

    mprf("dgn_Build_Method = %s", dgn_Build_Method.c_str());
    mprf("dgn_Layout_Type  = %s", dgn_Layout_Type.c_str());

    if (Generating_Level)
    {
        mpr("Currently generating level.");
        extern std::string dgn_Build_Method;
        method = dgn_Build_Method;
        type   = dgn_Layout_Type;
    }
    else
    {
        if (!props.exists(BUILD_METHOD_KEY))
            method = "ABSENT";
        else
            method = props[BUILD_METHOD_KEY].get_string();

    extern bool river_level, lake_level, many_pools_level;

        if (!props.exists(LAYOUT_TYPE_KEY))
            type = "ABSENT";
        else
            type = props[LAYOUT_TYPE_KEY].get_string();
    }

    if (river_level)
        mpr("river level");
    if (lake_level)
        mpr("lake level");
    if (many_pools_level)
        mpr("many pools level");

    mprf("dgn_Build_Method = %s", method.c_str());
    mprf("dgn_Layout_Type  = %s", type.c_str());

    std::vector<std::string> vault_names;

    std::string extra;

    for (unsigned int i = 0; i < Level_Vaults.size(); i++)
        vault_names.push_back(Level_Vaults[i].map.name);

    if (!props.exists(LEVEL_EXTRAS_KEY))
        extra = "ABSENT";
    else
    {
        const CrawlVector &vec = props[LEVEL_EXTRAS_KEY].get_vector();

    if (Level_Vaults.size() > 0)
            mpr_comma_separated_list("Level_Vaults: ", vault_names,
                                     " and ", ", ", MSGCH_WARN);
    vault_names.clear();

        for (unsigned int i = 0; i < vec.size(); i++)
            extra += vec[i].get_string() + ", ";
    }

    for (unsigned int i = 0; i < Temp_Vaults.size(); i++)
        vault_names.push_back(Temp_Vaults[i].map.name);

    mprf("Level extras: %s", extra.c_str());
    mpr("Level vaults:");
    if (!props.exists(LEVEL_VAULTS_KEY))
        mpr("ABSENT");
    else
    {
        const CrawlHashTable &vaults = props[LEVEL_VAULTS_KEY].get_table();
        CrawlHashTable::const_iterator i = vaults.begin();
        for (; i != vaults.end(); i++)
            mprf("    %s: %s", i->first.c_str(),
                 i->second.get_string().c_str());
    }
    mpr("");
    mpr("Temp vaults:");
    if (!props.exists(TEMP_VAULTS_KEY))
        mpr("ABSENT");
    else
    {
        const CrawlHashTable &vaults = props[TEMP_VAULTS_KEY].get_table();
        CrawlHashTable::const_iterator i = vaults.begin();

    if (Temp_Vaults.size() > 0)
        mpr_comma_separated_list("Temp_Vaults: ", vault_names,
                                 " and ", ", ", MSGCH_WARN);

        for (; i != vaults.end(); i++)
            mprf("    %s: %s", i->first.c_str(),
                 i->second.get_string().c_str());
    }
    mpr("");

    CrawlHashTable &props = env.properties;

    if (Generating_Level)
    {
        fprintf(file, EOL "Crashed while generating level." EOL);

    std::string place = level_id::current().describe();
    std::string orig_place;

        _dump_levgen();
        fprintf(file, EOL);
    }
}

    if (!props.exists(LEVEL_ID_KEY))
        orig_place = "ABSENT";
    else
        orig_place = props[LEVEL_ID_KEY].get_string();
    fprintf(file, "Level id: %s" EOL, place.c_str());
    if (place != orig_place)
        fprintf(file, "Level id when level was generated: %s" EOL,
                orig_place.c_str());

    _dump_levgen();
}

            map_marker* tmp = at_pos[i];

            map_marker* tmp = at_pos[j];

    extern std::string dgn_Build_Method;
    dgn_Build_Method += " abyss";
    dgn_Layout_Type   = "abyss";