public:
    enum stair_type
    {
        PHYSICAL,
        PLACEHOLDER
    };
    
public:

    int       grid;         // Grid feature of the stair.

    dungeon_feature_type grid; // Grid feature of the stair.

    stair_type type;

          distance(-1), guessed_pos(true)

          distance(-1), guessed_pos(true), type(PHYSICAL)

    void clear_distance()
    {
        distance = -1;
    }

    void clear_distance() { distance = -1; }

    std::string describe() const;
    bool can_travel() const { return (type == PHYSICAL); }

private:
    void create_placeholder_stair(const coord_def &, const level_pos &);
    void resize_stair_distances();

#define TC_MINOR_VERSION ((unsigned char) 7)

#define TC_MINOR_VERSION ((unsigned char) 9)

        // Skip placeholders, since there are no real stairs there.
        if (!si.can_travel())
            continue;
        

            stair_info *so = lo.get_stair(dest.pos);
            if (so)

            if (stair_info *so = lo.get_stair(dest.pos))

            int newdist = find_transtravel_stair(dest.id, target,

            const int newdist =
                find_transtravel_stair(dest.id, target,

    writeByte(file, type);

    grid = readShort(file);

    grid = static_cast<dungeon_feature_type>(readShort(file));

    type = static_cast<stair_type>(readByte(file));

std::string stair_info::describe() const
{
    if (destination.is_valid())
    {
        const level_pos &lp(destination);
        return
            make_stringf(
                " (-> %s@(%d,%d)%s%s)", lp.id.describe().c_str(),
                lp.pos.x, lp.pos.y,
                guessed_pos? " guess" : "",
                type == PLACEHOLDER? " placeholder" : "");
    }
    else if (destination.id.is_valid())
    {
        return make_stringf(
            " (->%s (?))", destination.id.describe().c_str());
    }
    return (" (?)");
}

    }
    else if (!si && guess)
    {
        create_placeholder_stair(coord_def(x, y), p);

void LevelInfo::create_placeholder_stair(const coord_def &stair,
                                         const level_pos &dest)
{
    // If there are any existing placeholders with the same 'dest', zap them.
    for (int i = 0, size = stairs.size(); i < size; ++i)
    {
        if (stairs[i].type == stair_info::PLACEHOLDER
            && stairs[i].destination == dest)
        {
            stairs.erase( stairs.begin() + i );
            break;
        }
    }
    stair_info placeholder;
    placeholder.position = stair;
    placeholder.grid     = DNGN_FLOOR;
    placeholder.destination = dest;
    placeholder.type     = stair_info::PLACEHOLDER;
    stairs.push_back(placeholder);
    resize_stair_distances();
}

    for (int i = stairs.size() - 1; i >= 0; --i)

    for (int i = static_cast<int>(stairs.size()) - 1; i >= 0; --i)

        if (stairs[i].type != stair_info::PHYSICAL)
            continue;
        

        bool found = false;

        int found = -1;

                found = true;

                found = j;

        if (!found)

        if (found == -1)

        }
        else
        {
            stairs[found].type = stair_info::PHYSICAL;

    resize_stair_distances();
}

void LevelInfo::resize_stair_distances()
{

    stair_distances.resize( nstairs * nstairs, 0 );

    stair_distances.resize( nstairs * nstairs, 0 );    

            if ((x == you.x_pos && y == you.y_pos)
                    || (envc 
                        && is_travelable_stair(grid) 
                        && (is_terrain_seen(x, y)
                            || !is_branch_stair(x, y))))

            if (((x == you.x_pos && y == you.y_pos)
                 || envc)
                && is_travelable_stair(grid) 
                && (is_terrain_seen(x, y) || !is_branch_stair(x, y)))

    bool collect_travel_data = you.level_type != LEVEL_LABYRINTH 
                    && you.level_type != LEVEL_ABYSS 
                && you.level_type != LEVEL_PANDEMONIUM;

    const bool collect_travel_data = you.level_type != LEVEL_LABYRINTH 
        && you.level_type != LEVEL_ABYSS 
        && you.level_type != LEVEL_PANDEMONIUM;

static inline bool dgn_square_is_passable(const coord_def &c)
{
    return (dgn_map_mask(c) && dgn_grid_is_passable(grd(c)));
}

    bool (*passable)(dungeon_feature_type) = dgn_grid_is_passable)

    bool (*passable)(const coord_def &) = dgn_square_is_passable)

            if (travel_point_distance[cp.x][cp.y]
                || dgn_map_mask(cp)
                || !passable(grd(cp)))
            {

            if (travel_point_distance[cp.x][cp.y] || !passable(cp))

            }

inline static bool dgn_square_travel_ok(const coord_def &c)
{
    const dungeon_feature_type feat = grd(c);
    return (is_traversable(feat) || grid_is_trap(feat)
            || feat == DNGN_SECRET_DOOR);
}

                dgn_fill_zone(coord_def(x, y), 1, np, is_traversable);

                dgn_fill_zone(coord_def(x, y), 1, np, dgn_square_travel_ok);

#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS, "Placing PC on %s",
         dungeon_feature_name(
             static_cast<dungeon_feature_type>(stair_to_find)));
#endif    

}
#ifdef DEBUG_DIAGNOSTICS
static std::string stair_destination_description(const coord_def &pos)
{
    if (LevelInfo *linf = travel_cache.find_level_info(level_id::current()))
    {
        const stair_info *si = linf->get_stair(pos);
        if (si)
            return (" " + si->describe());
        else if (is_stair(grd(pos)))
            return (" (unknown stair)");
    }
    return ("");

#endif

    mprf("(%d,%d): %s - %s%s", mx, my,

    const std::string traveldest =
        stair_destination_description(coord_def(mx, my));
    mprf("(%d,%d): %s - %s%s%s", mx, my,

         marker.c_str());

         marker.c_str(),
         traveldest.c_str());