void start_translevel_travel(const level_pos &pos);

struct level_id;
struct travel_target;
void start_translevel_travel(const travel_target &pos);

struct level_id;

level_pos prompt_translevel_target(int prompt_flags = TPF_DEFAULT_OPTIONS);

travel_target prompt_translevel_target(int prompt_flags = TPF_DEFAULT_OPTIONS);

struct travel_target
{
    level_pos p;
    bool      entrance_only;
    travel_target(const level_pos &_pos, bool entry = false)
        : p(_pos), entrance_only(entry)
    {
    }
    travel_target()
        : p(), entrance_only(false)
    {
    }
    void clear()
    {
        p.reset();
        entrance_only = false;
    }
};

    // Get the LevelInfo for the specified level (defaults to the current
    // level).
    LevelInfo& get_level_info(branch_type branch = BRANCH_MAIN_DUNGEON,
                              int depth = -1)
    {
        return get_level_info( level_id(branch, depth) );
    }

#include <sstream>

static level_pos travel_target;

static travel_target level_target;

static std::string trans_travel_dest;

static int find_transtravel_square(const level_pos &pos, bool verbose = true);

static bool find_transtravel_square(const level_pos &pos,
                                   bool verbose = true);

        if (!find_transtravel_square(travel_target) || !you.running.x)

        if (!find_transtravel_square(level_target.p) || !you.running.x)

                        && (travel_target.pos.x != you.x_pos
                            || travel_target.pos.y != you.y_pos
                            || travel_target.id != 
                                        level_id::current()))

                         && (level_target.p.pos != you.pos()
                            || level_target.p.id != level_id::current()))

                        return CMD_NO_CMD;

                        return (CMD_NO_CMD);
                    }
                    // Check for entrance-only thang. If we've reached the
                    // entrance, kill travel.
                    if (level_target.entrance_only)
                    {
                        LevelInfo &li =
                            travel_cache.get_level_info(level_id::current());
                        const stair_info *si = li.get_stair(you.pos());
                        if (si && si->destination.id == level_target.p.id)
                        {
                            you.running = runmode;
                            stop_running();
                            return (CMD_NO_CMD);
                        }

void set_trans_travel_dest(char *buffer, int maxlen, const level_pos &target)

std::string get_trans_travel_dest(const travel_target &target,
                                  bool skip_branch = false,
                                  bool skip_coord = false)

    if (!buffer) return;
    const int branch_id = target.id.branch;

    const int branch_id = target.p.id.branch;

    if (!branch) return;

    if (!branch)
        return ("");

    // Show level+depth information and tack on an @(x,y) if the player
    // wants to go to a specific square on the target level. We don't use 
    // actual coordinates since that will give away level information we
    // don't want the player to have.
    if ( branches[branch_id].depth != 1 )
        snprintf(buffer, maxlen, "%s:%d%s", branch, target.id.depth,
                 target.pos.x != -1? " @ (x,y)" : "");
    else
        snprintf(buffer, maxlen, "%s%s", branch,
                 target.pos.x != -1? " @ (x,y)" : "");

    std::ostringstream dest;
    if (!skip_branch)
        dest << branch;
    if (branches[branch_id].depth != 1)
    {
        if (!skip_branch)
            dest << ":";
        dest << target.p.id.depth;
    }
    if (target.p.pos.x != -1 && !skip_coord)
        dest << " @ (x,y)";
    else if (target.entrance_only)
        dest << " (entrance)";
    return (dest.str());

static char trans_travel_dest[30];

            if (*trans_travel_dest && remember_targ)

            if (!trans_travel_dest.empty() && remember_targ)

                    make_stringf("Enter - %s", trans_travel_dest) );

                    make_stringf("Enter - %s", trans_travel_dest.c_str()) );

    case '<': case '>': case '?':

    case '<': case '>': case '?': case '$': case '^':

        return (-1);
    case '$':

static void travel_depth_munge(int munge_method, branch_type *br, int *depth)

static travel_target parse_travel_target(
    std::string s, travel_target &targ)

    level_id lid(*br, *depth);

    trim_string(s);
    const std::string ekey("(entrance)");
    std::string::size_type epos = s.find(ekey);
    if (!s.empty())
        targ.entrance_only = epos != std::string::npos;
    if (targ.entrance_only && !s.empty())
        s = trimmed_string(s.substr(0, epos) + s.substr(epos + ekey.length()));
    
    if (!s.empty())
        targ.p.id.depth = atoi(s.c_str());
    if (!targ.p.id.depth && !s.empty() && s[0] == '0')
    {
        targ.p.id.depth = 1;
        targ.entrance_only = true;
    }
    return (targ);
}
static void travel_depth_munge(int munge_method,
                               const std::string &s,
                               travel_target &targ)
{
    parse_travel_target(s, targ);
    level_id lid(targ.p.id);

        break;
    case '^':
        targ.entrance_only = !targ.entrance_only;

    *br    = lid.branch;
    *depth = lid.depth;
    if (*depth < 1)
        *depth = 1;

    targ.p.id = lid;
    if (targ.p.id.depth < 1)
        targ.p.id.depth = 1;

static level_id prompt_travel_depth(const level_id &id)

static travel_target prompt_travel_depth(const level_id &id)

    branch_type branch = id.branch;

    travel_target target(level_pos(id), false);
    

    if (single_level_branch(branch))
        return level_id(branch, 1);

    if (single_level_branch(target.p.id.branch))
        return travel_target(level_id(target.p.id.branch, 1));

    int depth = get_nearest_level_depth(branch);

    target.p.id.depth = get_nearest_level_depth(target.p.id.branch);

             "(default %d, ? - help) ", branches[branch].longname, depth);

             "(default %s, ? - help) ",
             branches[target.p.id.branch].longname,
             get_trans_travel_dest(target, true).c_str());

        {
            if (*buf)
                depth = atoi(buf);
            return level_id(branch, depth);
        }

            return parse_travel_target(buf, target);

            return level_id(BRANCH_MAIN_DUNGEON, 0);

            return travel_target(level_id(BRANCH_MAIN_DUNGEON, 0));

        travel_depth_munge(response, &branch, &depth);

        travel_depth_munge(response, buf, target);

level_pos prompt_translevel_target(int prompt_flags)

travel_target prompt_translevel_target(int prompt_flags)

    level_pos target;

    travel_target target;

        return (travel_target);

        return (level_target);

        target = find_up_level();
        if (target.id.depth > 0 && remember_targ)
            set_trans_travel_dest(trans_travel_dest, sizeof trans_travel_dest,
                                    target);

        target.p = find_up_level();
        if (target.p.id.depth > 0 && remember_targ)
            trans_travel_dest = get_trans_travel_dest(target);

        target = find_down_level();
        if (target.id.depth > 0 && remember_targ)
            set_trans_travel_dest(trans_travel_dest, sizeof trans_travel_dest,
                                    target);

        target.p = find_down_level();
        if (target.p.id.depth > 0 && remember_targ)
            trans_travel_dest = get_trans_travel_dest(target);

    target.id.branch = static_cast<branch_type>(branch);

    target.p.id.branch = static_cast<branch_type>(branch);

    target.id = prompt_travel_depth(target.id);

    target = prompt_travel_depth(target.p.id);

    if (target.id.depth < 1 || target.id.depth >= MAX_LEVELS)
        target.id.depth = -1;

    if (target.p.id.depth < 1 || target.p.id.depth >= MAX_LEVELS)
        target.p.id.depth = -1;

    if (target.id.depth > -1 && remember_targ)
        set_trans_travel_dest(trans_travel_dest, sizeof trans_travel_dest, 
                              target);

    if (target.p.id.depth > -1 && remember_targ)
        trans_travel_dest = get_trans_travel_dest(target);

void start_translevel_travel(const level_pos &pos)

void start_translevel_travel(const travel_target &pos)

    if (!can_travel_to(pos.id))

    if (!can_travel_to(pos.p.id))

        start_travel(pos.pos.x, pos.pos.y);

        start_travel(pos.p.pos.x, pos.p.pos.y);

    travel_target = pos;

    level_target = pos;

    if (pos.id != level_id::current())

    if (pos.p.id != level_id::current())

        if (!loadlev_populate_stair_distances(pos))

        if (!loadlev_populate_stair_distances(pos.p))

        populate_stair_distances(pos);
    
    set_trans_travel_dest(trans_travel_dest, sizeof trans_travel_dest,
                          travel_target);

        populate_stair_distances(pos.p);
    trans_travel_dest = get_trans_travel_dest(level_target);

        level_pos target = prompt_translevel_target();
        if (target.id.depth == -1) return;

        travel_target target = prompt_translevel_target();
        if (target.p.id.depth <= 0)
            return;

        travel_target = target;

        level_target = target;

    if (level_id::current() == travel_target.id &&
            (travel_target.pos.x == -1 || 
             (travel_target.pos.x == you.x_pos &&
             travel_target.pos.y == you.y_pos)))

    if (level_id::current() == level_target.p.id
        && (level_target.p.pos.x == -1 || level_target.p.pos == you.pos()))

    if (travel_target.id.depth > -1)

    if (level_target.p.id.depth > 0)

static int find_transtravel_square(const level_pos &target, bool verbose)

static bool find_transtravel_square(const level_pos &target, bool verbose)

    const LevelInfo &target_level = travel_cache.get_level_info( target.id );

    const LevelInfo &target_level =
        travel_cache.get_level_info( target.id );

        return 1;

        return (true);

    return 0;

    return (false);

    
    // Start running
    you.running = RMODE_TRAVEL;

    // Check whether we can get to the square.
    find_travel_pos(you.x_pos, you.y_pos, NULL, NULL, NULL);

    level_target = level_pos(level_id::current(), coord_def(x, y));

    if (travel_point_distance[x][y] == 0
        && (x != you.x_pos || you.running.y != you.y_pos)
        && is_travelsafe_square(x, y, false)
        && can_travel_interlevel())

    if (!can_travel_interlevel())

        // We'll need interlevel travel to get here.
        travel_target.id = level_id::current();
        travel_target.pos.x = x;
        travel_target.pos.y = y;
        you.running = RMODE_INTERLEVEL;
        you.running.x = you.running.y = 0;
        last_stair.depth = -1;
        // We need the distance of the target from the various stairs around.
        populate_stair_distances(travel_target);
        set_trans_travel_dest(trans_travel_dest, sizeof trans_travel_dest, 
                              travel_target);

        // Start running
        you.running = RMODE_TRAVEL;
        start_running();

    start_running();

    else
    {
        start_translevel_travel(level_target);
    }

    char dest[30];

    std::string dest;

        set_trans_travel_dest(dest, sizeof dest, waypoints[i]);
        // All waypoints will have @ (x,y), remove that.
        char *at = strchr(dest, '@');
        if (at)
            *--at = 0;
        snprintf(choice, sizeof choice, "(%d) %-8s", i, dest);

        dest = get_trans_travel_dest(waypoints[i], false, true);
        
        snprintf(choice, sizeof choice, "(%d) %-8s", i, dest.c_str());

                const level_pos lp = res->pos;

                const travel_target lp = res->pos;

    if (behaviour != BEH_WANDER && !force)

    if (!force && behaviour != BEH_WANDER)

        prompt_translevel_target(TPF_ALLOW_UPDOWN | TPF_SHOW_ALL_BRANCHES);

        prompt_translevel_target(TPF_ALLOW_UPDOWN | TPF_SHOW_ALL_BRANCHES).p;

    " <w>$</w>      : Change default to deepest visited level in this branch."

    " <w>$</w>      : Change default to deepest visited level in this branch.\n"
    " <w>^</w>      : Change default to the entrance to the current level.\n"