monster_type mon_chosen;

    monster_type mon_chosen = MONS_PROGRAM_BUG;

typedef
flood_find<map_def::map_feature_finder, map_def::map_bounds_check>
map_flood_finder;

static int dgn_points_connected(lua_State *ls)

static int dgn_map_pathfind(lua_State *ls, int minargs,
                            bool (map_flood_finder::*f)(const coord_def &))

    if (nargs < 5)
        return luaL_error(ls,
                          "Not enough points to test connectedness "
                          "(need at least two)");

    if (nargs < minargs)
        return luaL_error
            (ls,
             make_stringf("Not enough points to test connectedness "
                          "(need at least %d)", minargs / 2).c_str());

    flood_find<map_def::map_feature_finder, map_def::map_bounds_check>
        finder(feat_finder, bounds_checker);

    map_flood_finder finder(feat_finder, bounds_checker);

    const bool connected = finder.points_connected_from(pos);
    PLUARET(boolean, connected);

    PLUARET(boolean, (finder.*f)(pos));    
}
static int dgn_points_connected(lua_State *ls)
{
    return dgn_map_pathfind(ls, 5, &map_flood_finder::points_connected_from);

static int dgn_any_point_connected(lua_State *ls)
{
    return dgn_map_pathfind(ls, 5, &map_flood_finder::any_point_connected_from);
}
static int dgn_has_exit_from(lua_State *ls)
{
    return dgn_map_pathfind(ls, 3, &map_flood_finder::has_exit_from);
}

    { "any_point_connected", dgn_any_point_connected },
    { "has_exit_from", dgn_has_exit_from },

    if (!dlua.error.empty())
        end(1, false, "Lua error: %s", dlua.error.c_str());
    lua_getglobal(dlua, "dgn_run_map");

    bool any_point_connected_from(const coord_def &start);
    bool has_exit_from(const coord_def &start);

    bool point_hunt;

    bool point_hunt, want_exit;

    : travel_pathfind(), point_hunt(false), needed_features(),
      needed_points(), left_vault(true), vaults(),

    : travel_pathfind(), point_hunt(false), want_exit(false),
      needed_features(), needed_points(), left_vault(true), vaults(),

bool flood_find<fgrd, bound_check>::any_point_connected_from(
    const coord_def &sp)
{
    if (needed_points.empty())
        return (true);
    set_floodseed(sp);
    const size_t sz = needed_points.size();
    pathfind(RMODE_EXPLORE);
    return (needed_points.size() < sz);
}
template <typename fgrd, typename bound_check>
bool flood_find<fgrd, bound_check>::has_exit_from(
    const coord_def &sp)
{
    want_exit = true;
    set_floodseed(sp);
    return (pathfind(RMODE_EXPLORE) == coord_def(-1, -1));
}
template <typename fgrd, typename bound_check>

    {
        if (want_exit)
        {
            greedy_dist = 100;
            greedy_place = coord_def(-1, -1);
            return (true);
        }

    }

end
function dgn.any_glyph_connected(map, ...)
   return dgn.places_connected(map, dgn.gly_points, 
                              dgn.any_point_connected, ...)

function dgn.has_exit_from_glyph(map, glyph)
   return dgn.places_connected(map, dgn.gly_point, dgn.has_exit_from, glyph)
end

end

end