enum translevel_prompt_flags
{
    TPF_NO_FLAGS          = 0,
    
    TPF_ALLOW_WAYPOINTS   = 0x1,
    TPF_ALLOW_UPDOWN      = 0x2,
    TPF_REMEMBER_TARGET   = 0x4,
    TPF_SHOW_ALL_BRANCHES = 0x8,
    TPF_DEFAULT_OPTIONS   = TPF_ALLOW_WAYPOINTS | TPF_ALLOW_UPDOWN
                                                | TPF_REMEMBER_TARGET
};
level_pos prompt_translevel_target(int prompt_flags = TPF_DEFAULT_OPTIONS);

static bool is_known_branch(int branch)

static bool is_known_branch_id(int branch)

    if (branch == BRANCH_MAIN_DUNGEON) return true;

    if (branch == BRANCH_MAIN_DUNGEON)
        return true;

    if (you.where_are_you == branch) return true;

    if (you.where_are_you == branch)
        return true;

    // The Vestibule is special: there are no stairs to it, just
    // a portal

    // The Vestibule is special: there are no stairs to it, just a
    // portal

    {
        // XXX There must be a better way to do this...
        std::vector<stash_search_result> tmp;
        get_matching_features(text_pattern("gateway to Hell"), tmp);
        return !tmp.empty();
    }

        return overmap_knows_portal( DNGN_ENTER_HELL );

}
static bool is_known_branch(const Branch &br)
{
    return (is_known_branch_id(br.id));

static std::vector<branch_type> get_known_branches()

static std::vector<branch_type> get_branches(bool (*selector)(const Branch &))

        if (is_known_branch(branches[i].id))

        if (selector(branches[i]))

static int prompt_travel_branch()

static bool is_valid_branch(const Branch &br)
{
    return (!!br.shortname);
}
static int prompt_travel_branch(int prompt_flags)

    std::vector<branch_type> br = get_known_branches();

    std::vector<branch_type> br =
        get_branches(
            (prompt_flags & TPF_SHOW_ALL_BRANCHES)?
            is_valid_branch : is_known_branch );

    if (br.size() < 1) return branch;

    if (br.size() < 1)
        return branch;

    const bool allow_waypoints = (prompt_flags & TPF_ALLOW_WAYPOINTS);
    const bool allow_updown    = (prompt_flags & TPF_ALLOW_UPDOWN);
    const bool remember_targ   = (prompt_flags & TPF_REMEMBER_TARGET);
    

    int waycount = travel_cache.get_waypoint_count();

    const int waycount = allow_waypoints? travel_cache.get_waypoint_count() : 0;
    

        char buf[100];

                snprintf(buf, sizeof buf, "(%c) %-14s ",
                         branches[br[i]].travel_shortcut,
                         branches[br[i]].shortname);
                line += buf;

                line += make_stringf("(%c) %-14s ",
                                     branches[br[i]].travel_shortcut,
                                     branches[br[i]].shortname);

        char shortcuts[100];
        *shortcuts = 0;
        if (*trans_travel_dest || waycount || waypoint_list)

        std::string shortcuts;
        if ((*trans_travel_dest && remember_targ)
            || (allow_waypoints && (waycount || waypoint_list)))

            strncpy(shortcuts, "(", sizeof shortcuts);

            shortcuts = "(";

                strncat(shortcuts, "[*] lists branches", sizeof shortcuts);

                shortcuts += "[*] lists branches";

                strncat(shortcuts, "[*] lists waypoints", sizeof shortcuts);

                shortcuts += "[*] lists waypoints";

            if (*trans_travel_dest)

            if (*trans_travel_dest && remember_targ)

                char travel_dest[60];
                snprintf(travel_dest, sizeof travel_dest, "[Enter] for %s",
                        trans_travel_dest);

                    strncat( shortcuts, ", ", sizeof shortcuts);
                strncat(shortcuts, travel_dest, sizeof shortcuts);

                    shortcuts += ", ";
                shortcuts += make_stringf("[Enter] for %s",
                                          trans_travel_dest);

            strncat(shortcuts, ") ", sizeof shortcuts);

            shortcuts += ") ";

        snprintf(buf, sizeof buf, "Where do you want to go? %s", shortcuts);
        mpr(buf, MSGCH_PROMPT);

        mprf(MSGCH_PROMPT, "Where do you want to go? %s", shortcuts.c_str());

            return (ID_UP);

            return (allow_updown? ID_UP : ID_CANCEL);

            return (ID_DOWN);

            return (allow_updown? ID_DOWN : ID_CANCEL);

            if (keyin >= '0' && keyin <= '9')

            if ((keyin >= '0' && keyin <= '9') && allow_waypoints)

static level_pos prompt_translevel_target()

level_pos prompt_translevel_target(int prompt_flags)

    int branch = prompt_travel_branch();

    int branch = prompt_travel_branch(prompt_flags);
    const bool remember_targ = (prompt_flags & TPF_REMEMBER_TARGET);

        if (target.id.depth > -1)

        if (target.id.depth > -1 && remember_targ)

        if (target.id.depth > -1)

        if (target.id.depth > -1 && remember_targ)

    if (target.id.depth > -1)

    if (target.id.depth > -1 && remember_targ)

                target);

                              target);

                        travel_target);

                          travel_target);
    

bool overmap_knows_portal(dungeon_feature_type portal);

bool overmap_knows_portal(dungeon_feature_type portal)
{
    for ( portal_map_type::const_iterator pl_iter = portals_present.begin();
          pl_iter != portals_present.end(); ++pl_iter )
    {
        if (portal_to_feature(pl_iter->second) == portal)
            return (true);
    }
    return (false);
}

void wizard_interlevel_travel();

#include "branch.h"

#include "files.h"

#include "view.h"

static void wizard_go_to_level(const level_pos &pos)
{
    const int abs_depth = absdungeon_depth(pos.id.branch, pos.id.depth);
    const int stair_taken =
        abs_depth > you.your_level? DNGN_STONE_STAIRS_DOWN_I
                                  : DNGN_STONE_STAIRS_UP_I;
    const int old_level = you.your_level;
    const int old_where = you.where_are_you;
    const bool was_a_labyrinth = you.level_type == LEVEL_LABYRINTH;
    you.level_type    = LEVEL_DUNGEON;
    you.where_are_you = pos.id.branch;
    you.your_level    = abs_depth;
    load(stair_taken, LOAD_ENTER_LEVEL, was_a_labyrinth, old_level, old_where);
    save_game_state();
    new_level();
    viewwindow(1, true);
    // Tell the travel code that we're now on a new level
    init_new_level(true);
}
void wizard_interlevel_travel()
{
    const level_pos pos =
        prompt_translevel_target(TPF_ALLOW_UPDOWN | TPF_SHOW_ALL_BRANCHES);
    
    if (pos.id.depth < 1 || pos.id.depth > branches[pos.id.branch].depth)
    {
        canned_msg(MSG_OK);
        return;
    }
    wizard_go_to_level(pos);
}

FLAGS: no_rotate

        level_travel(0);

        wizard_interlevel_travel();