// Identifies a level. This has no meaning in the Abyss, labyrinths or
// Pandemonium.

// Identifies a level.

    unsigned char branch;   // The branch in which the level is.
    int           depth;    // What depth (in this branch - starting from 1)
                            // this level is.
    level_id() : branch(0), depth(-1) { }

public:
    int branch;     // The branch in which the level is.
    int depth;      // What depth (in this branch - starting from 1)
    int level_type;

    level_id(unsigned char br, int dep) : branch(br), depth(dep) { }

public:
    level_id() : branch(0), depth(-1), level_type(LEVEL_DUNGEON) { }
    level_id(int br, int dep, int ltype = LEVEL_DUNGEON)
        : branch(br), depth(dep), level_type(ltype)
    {
        if (level_type != LEVEL_DUNGEON)
            branch = depth = -1;
    }
    level_id(int ltype) : branch(-1), depth(-1), level_type(ltype) { }

    std::string describe(bool long_name = false, bool with_number = true) const;

    std::string describe( bool long_name, bool with_number ) const;

    bool is_valid() const
    {
        return (branch != -1 && depth != -1) || level_type != LEVEL_DUNGEON;
    }

    static level_id get_current_level_id();

    static level_id current();

        return branch == id.branch && depth == id.depth;

        return branch == id.branch && depth == id.depth
            && level_type == id.level_type;

        return branch != id.branch || depth != id.depth;

        return branch != id.branch || depth != id.depth
            || level_type != id.level_type;

        if (level_type != id.level_type)
            return (level_type < id.level_type);
        

    struct less_than
    {
        bool operator () (const level_id &first, const level_id &second) const
        {
            return first.branch < second.branch ||
                (first.branch == second.branch && first.depth < second.depth);
        }
    };

    }
    LevelInfo *find_level_info(const level_id &lev)
    {
        std::map<level_id, LevelInfo>::iterator i = levels.find(lev);
        return (i != levels.end()? &i->second : NULL);

    std::map<level_id, LevelInfo, level_id::less_than> levels;

    std::map<level_id, LevelInfo> levels;

#define TC_MINOR_VERSION ((unsigned char) 4)

#define TC_MINOR_VERSION ((unsigned char) 5)

        LevelInfo &li = travel_cache.get_level_info(
                            level_id::get_current_level_id());

        LevelInfo &li = travel_cache.get_level_info(level_id::current());

        LevelInfo &li = travel_cache.get_level_info(
                            level_id::get_current_level_id());

        LevelInfo &li = travel_cache.get_level_info(level_id::current());

    const level_id curr = level_id::get_current_level_id();

    const level_id curr = level_id::current();

                                        level_id::get_current_level_id()))

                                        level_id::current()))

                        && last_stair == level_id::get_current_level_id()) 

                        && last_stair == level_id::current()) 

                    last_stair = level_id::get_current_level_id();

                    last_stair = level_id::current();

unsigned char find_parent_branch(unsigned char br)

int find_parent_branch(int br)

            return (unsigned char) branch_backout[i][1];

            return branch_backout[i][1];

void find_parent_branch(unsigned char br, int depth, 
                        unsigned char *pb, int *pd)

void find_parent_branch(int br, int depth, 
                        int *pb, int *pd)

               unsigned char branch, int subdepth)

               int branch, int subdepth)

        unsigned char pb;

        int pb;

    level_id id = level_id::get_current_level_id();

    level_id id = level_id::current();

    level_id curr = level_id::get_current_level_id();

    level_id curr = level_id::current();

    level_id curr = level_id::get_current_level_id();

    level_id curr = level_id::current();

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

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

    travel_cache.get_level_info(level_id::get_current_level_id()).update();

    travel_cache.get_level_info(level_id::current()).update();

    if (level_id::get_current_level_id() == travel_target.id &&

    if (level_id::current() == travel_target.id &&

    level_id player_level = level_id::get_current_level_id();

    level_id player_level = level_id::current();

    level_id current = level_id::get_current_level_id();

    level_id current = level_id::current();

        travel_target.id = level_id::get_current_level_id();

        travel_target.id = level_id::current();

level_id level_id::get_current_level_id()

level_id level_id::current()

    level_id id;
    id.branch = you.where_are_you;
    id.depth  = subdungeon_depth(you.where_are_you, you.your_level);

    const level_id id(you.where_are_you,
                      subdungeon_depth(you.where_are_you, you.your_level),
                      you.level_type);

    level_id id = get_current_level_id();

    level_id id = current();

    return get_packed_place(branch, depth, LEVEL_DUNGEON);

    return get_packed_place(branch, depth, level_type);

    writeByte(file, branch);

    writeShort(file, branch);

    writeShort(file, level_type);

    branch = readByte(file);
    depth  = readShort(file);

    branch     = readShort(file);
    depth      = readShort(file);
    level_type = readShort(file);

    lp.id = level_id::get_current_level_id();

    lp.id = level_id::current();

    const level_id &lid = level_id::get_current_level_id();

    const level_id &lid = level_id::current();

    std::map<level_id, LevelInfo, level_id::less_than>::iterator i =
                    levels.begin();

    std::map<level_id, LevelInfo>::iterator i = levels.begin();

    std::map<level_id, LevelInfo, level_id::less_than>::const_iterator i =

    std::map<level_id, LevelInfo>::const_iterator i =

    std::map<level_id, LevelInfo, level_id::less_than>::const_iterator i =

    std::map<level_id, LevelInfo>::const_iterator i =

        if (i->first.level_type != LEVEL_DUNGEON)
            continue;

        get_level_info(level_id::get_current_level_id()).set_level_excludes();

        get_level_info(level_id::current()).set_level_excludes();

        get_level_info(level_id::get_current_level_id()).update();

        get_level_info(level_id::current()).update();

    std::map<level_id, LevelInfo, level_id::less_than>::iterator i =
                levels.begin();

    std::map<level_id, LevelInfo>::iterator i = levels.begin();

#include "misc.h"

void stash_init_new_level();

    level_id where() const;
    

    bool  isCurrent() const;
    bool  isBelowPlayer() const;
    bool  operator < (const LevelStashes &lev) const;

    bool  is_current() const;

    unsigned char branch;
    int depth;

    level_id place;

    typedef std::map<int, Stash>  c_stashes;
    typedef std::vector<ShopInfo> c_shops;

    typedef std::map<int, Stash>  stashes_t;
    typedef std::vector<ShopInfo> shops_t;

    c_stashes stashes;
    c_shops   shops;

    stashes_t stashes;
    shops_t   shops;

            || you.level_type == LEVEL_ABYSS
            || you.level_type == LEVEL_PANDEMONIUM;

            || you.level_type == LEVEL_ABYSS;

    LevelStashes *find_level(const level_id &pos);

    void remove_level(const LevelStashes &ls);

    void remove_level(const level_id &which = level_id::current());

private:
    std::vector<LevelStashes> levels;

private:

private:
    typedef std::map<level_id, LevelStashes> stash_levels_t;
    stash_levels_t levels;

#define ST_MINOR_VER ((unsigned char) 4)

#define ST_MINOR_VER ((unsigned char) 5)

void stash_init_new_level()
{
    // If there's an existing stash level for Pan, blow it away.
    stashes.remove_level( level_id(LEVEL_PANDEMONIUM) );
}

LevelStashes::LevelStashes()

LevelStashes::LevelStashes() : place(), stashes(), shops()

    branch = you.where_are_you;
    depth  = you.your_level;

bool LevelStashes::operator < (const LevelStashes &lev) const

level_id LevelStashes::where() const

    return branch < lev.branch || (branch == lev.branch && depth < lev.depth);

    return (place);

bool LevelStashes::isBelowPlayer() const
{
    return branch > you.where_are_you 
        || (branch == you.where_are_you && depth > you.your_level);
}

    c_stashes::const_iterator st = stashes.find(abspos);

    stashes_t::const_iterator st = stashes.find(abspos);

bool LevelStashes::isCurrent() const

bool LevelStashes::is_current() const

    return branch == you.where_are_you && depth == you.your_level;

    return (place == level_id::current());

    return branch >= BRANCH_DIS 
            && branch <= BRANCH_THE_PIT
            && branch != BRANCH_VESTIBULE_OF_HELL;

    return place.branch >= BRANCH_DIS
            && place.branch <= BRANCH_THE_PIT
            && place.branch != BRANCH_VESTIBULE_OF_HELL;

    return branch == branchid;

    return place.branch == branchid;

    int curr_subdungeon_level = subdungeon_depth( branch, depth );
    return (place_name(
                get_packed_place(branch, curr_subdungeon_level, LEVEL_DUNGEON), 
                true, true));

    return place.describe(true, true);

    return (short_place_name(
            get_packed_place( branch, 
                subdungeon_depth( branch, depth ),
                LEVEL_DUNGEON ) ));

    return place.describe();

    for (c_stashes::const_iterator iter = stashes.begin(); 

    for (stashes_t::const_iterator iter = stashes.begin(); 

    level_id clid(branch, subdungeon_depth(branch, depth));
    std::string lplace = "{" + short_place_name(clid) + "}";
    for (c_stashes::const_iterator iter = stashes.begin();

    std::string lplace = "{" + place.describe() + "}";
    for (stashes_t::const_iterator iter = stashes.begin();

                res.pos.id = clid;

                res.pos.id = place;

            res.pos.id = clid;

            res.pos.id = place;

        for (c_stashes::const_iterator iter = stashes.begin(); 

        for (stashes_t::const_iterator iter = stashes.begin(); 

    writeByte(file, branch);
    writeShort(file, (short) depth);

    place.save(file);

    for (c_stashes::const_iterator iter = stashes.begin(); 

    for (stashes_t::const_iterator iter = stashes.begin(); 

    branch = readByte(file);
    depth  = readShort(file);

    place.load(file);

    std::vector<LevelStashes>::iterator iter = levels.begin();
    for ( ; iter != levels.end() && !iter->isBelowPlayer(); iter++)
    {
        if (iter->isCurrent()) return *iter;
    }
    if (iter == levels.end())
        levels.push_back(LevelStashes());
    else
        levels.insert(iter, LevelStashes());
    return get_current_level();

    return (levels[level_id::current()]);
}
LevelStashes *StashTracker::find_level(const level_id &id)
{
    stash_levels_t::iterator i = levels.find(id);
    return (i != levels.end()? &i->second : NULL);

    
    std::vector<LevelStashes>::iterator iter = levels.begin();
    for ( ; iter != levels.end() && !iter->isBelowPlayer(); iter++)
    {
        if (iter->isCurrent()) return &*iter;
    }
    return (NULL);

    return find_level(level_id::current());

            remove_level(*lev);

            remove_level();

void StashTracker::remove_level(const LevelStashes &ls)

void StashTracker::remove_level(const level_id &place)

    std::vector<LevelStashes>::iterator iter = levels.begin();
    for ( ; iter != levels.end(); ++iter)
    {
        if (&ls == &*iter)
        {
            levels.erase(iter);
            break ;
        }
    }

    levels.erase(place);

        remove_level(current);

        remove_level();

        remove_level(current);

        remove_level();

        std::vector<LevelStashes>::const_iterator iter = levels.begin();
        for ( ; iter != levels.end(); iter++)

        for (stash_levels_t::const_iterator iter = levels.begin();
             iter != levels.end(); iter++)

            iter->write(os, identify);

            iter->second.write(os, identify);

    std::vector<LevelStashes>::const_iterator iter = levels.begin();

    stash_levels_t::const_iterator iter = levels.begin();

        iter->save(file);

        iter->second.save(file);

        if (st.stash_count()) levels.push_back(st);

        if (st.stash_count())
            levels[st.where()] = st;

        remove_level(*lev);

        remove_level();

    std::vector<LevelStashes>::const_iterator iter = levels.begin();

    stash_levels_t::const_iterator iter = levels.begin();

        iter->get_matching_stashes(search, results);

        iter->second.get_matching_stashes(search, results);

    level_id curr = level_id::get_current_level_id();

    level_id curr = level_id::current();

    level_pos curpos(level_id::get_current_level_id());

    level_pos curpos(level_id::current());

    stair_level[which_branch] = level_id::get_current_level_id();

    stair_level[which_branch] = level_id::current();

    level_pos where(level_id::get_current_level_id(), pos);

    level_pos where(level_id::current(), pos);

    const level_pos curpos(level_id::get_current_level_id(), pos);

    const level_pos curpos(level_id::current(), pos);

    level_pos where(level_id::get_current_level_id(), pos);

    level_pos where(level_id::current(), pos);

void init_new_level();

    level_id  old_level_id    = level_id::get_current_level_id();

    level_id  old_level_id    = level_id::current();

    travel_init_new_level();

    init_new_level();

        level_id  new_level_id    = level_id::get_current_level_id();

        level_id  new_level_id    = level_id::current();

    level_id  old_level_id    = level_id::get_current_level_id();

    level_id  old_level_id    = level_id::current();

    travel_init_new_level();

    init_new_level();

        level_id  new_level_id    = level_id::get_current_level_id();

        level_id  new_level_id    = level_id::current();

void init_new_level()
{
    travel_init_new_level();
    stash_init_new_level();
}

static std::string weapon_to_str( int weapon )

std::string weapon_to_str( int weapon )

#ifndef DISABLE_STICKY_STARTUP_OPTIONS

#endif // !DISABLE_STICKY_STARTUP_OPTIONS

#ifndef DISABLE_STICKY_STARTUP_OPTIONS

#endif // !DISABLE_STICKY_STARTUP_OPTIONS

#ifndef DISABLE_STICKY_STARTUP_OPTIONS

#endif // !DISABLE_STICKY_STARTUP_OPTIONS

#ifndef DISABLE_STICKY_STARTUP_OPTIONS

#endif // !DISABLE_STICKY_STARTUP_OPTIONS

static bool is_save_file_name(const std::string &name)

bool is_save_file_name(const std::string &name)

static bool is_packed_save(const std::string &name)

bool is_packed_save(const std::string &name)

static player read_character_info(const std::string &savefile)

player read_character_info(const std::string &savefile)

    if (!determine_version(charf, majorVersion, minorVersion))
        goto done_reading_character;

    if (determine_version(charf, majorVersion, minorVersion)
        && majorVersion == SAVE_MAJOR_VERSION)
    {
        restore_tagged_file(charf, TAGTYPE_PLAYER_NAME, minorVersion);
        fromfile = you;
        you      = backup;
    }

    if (majorVersion != SAVE_MAJOR_VERSION)
        goto done_reading_character;
    restore_tagged_file(charf, TAGTYPE_PLAYER_NAME, minorVersion);
    fromfile = you;
    you      = backup;
done_reading_character:

static std::vector<std::string> get_dir_files(const std::string &dirname)

std::vector<std::string> get_dir_files(const std::string &dirname)

    std::vector<player> chars;
#ifndef DISABLE_SAVEGAME_LISTS

    std::vector<player> chars;

#endif // !DISABLE_SAVEGAME_LISTS

    // Also tell travel that its world-view must change.
    travel_init_new_level();

    travel_init_new_level();

    init_new_level();

// Uncomment to prevent Crawl from looking for a list of saves when
// asking the player to enter a name. This can speed up startup
// considerably if you have a lot of saves lying around (even more so
// if the saves are zipped).
// 
// #define DISABLE_SAVEGAME_LISTS
// Uncomment to prevent Crawl from remembering startup preferences.
// 
// #define DISABLE_STICKY_STARTUP_OPTIONS