#include "menu.h" // For print_formatted_paragraph()
#include "message.h"

#include "menu.h" // For print_formatted_paragraph()

#include <sstream>

player::~player()

player_save_info player_save_info::operator=(const player& rhs)

    delete kills;

    name = rhs.your_name;
    experience = rhs.experience;
    experience_level = rhs.experience_level;
    wizard = rhs.wizard;
    species = rhs.species;
    class_name = rhs.class_name;
    return *this;

bool player::is_valid() const

bool player_save_info::operator<(const player_save_info& rhs) const

    // Check if there's a name.
    return (your_name[0] != 0);

    return experience < rhs.experience ||
        (experience == rhs.experience && name < rhs.name);

std::string player::short_desc() const

std::string player_save_info::short_desc() const

    std::string desc;
    desc += your_name;
    desc += ", a level ";
    char st_prn[20];
    itoa(experience_level, st_prn, 10);
    desc += st_prn;

    std::ostringstream desc;
    desc << name << ", a level " << experience_level << ' '
         << species_name(species, experience_level) << ' '
         << class_name;

    desc += " ";
    desc += species_name(species, experience_level);
    desc += " ";
    desc += class_name;

        desc += " (WIZ)";

        desc << " (WIZ)";

    return (desc);

    return desc.str();

bool player::operator < (const player &p) const

player::~player()

    return (experience > p.experience
        || (experience == p.experience &&
                stricmp(your_name, p.your_name) < 0));

    delete kills;

        const std::vector<player> &existing_chars,

        const std::vector<player_save_info> &existing_chars,

        const std::vector<player> &existing,

        const std::vector<player_save_info> &existing,

                const player &p = *static_cast<player*>( sel->data );
                strncpy(name, p.your_name, kNameLen);

                const player_save_info &p =
                    *static_cast<player_save_info*>( sel->data );
                strncpy(name, p.name.c_str(), kNameLen);

    std::vector<player> existing_chars;

    std::vector<player_save_info> existing_chars;

        if (existing_chars.size() == 0) 

        if (existing_chars.empty()) 

        for (int i = 0, size = existing_chars.size(); i < size; ++i)

        for (unsigned int i = 0; i < existing_chars.size(); ++i)

std::vector<player> find_saved_characters();

std::vector<player_save_info> find_saved_characters();

#include <functional>

// Returns a full player struct read from the save.
player read_character_info(const std::string &savefile)

// Return the save_info from the save.
player_save_info read_character_info(const std::string &savefile)

    player fromfile;
    player backup;

    player_save_info fromfile;

    backup.copy_from(you);

        // backup before we clobber "you"
        const player backup(you);

        fromfile.copy_from(you);
        you     .copy_from(backup);

        
        fromfile = you;
        you.copy_from(backup);

std::vector<player> find_saved_characters()

std::vector<player_save_info> find_saved_characters()

    std::vector<player> chars;

    std::vector<player_save_info> chars;

    for (int i = 0, size = allfiles.size(); i < size; ++i)

    for (unsigned int i = 0; i < allfiles.size(); ++i)

            player p = read_character_info(get_savedir_path(filename));
            if (p.is_valid())

            player_save_info p=read_character_info(get_savedir_path(filename));
            if (!p.name.empty())

    std::sort(chars.begin(), chars.end());

    std::sort(chars.rbegin(), chars.rend());

    bool is_valid() const;
    std::string short_desc() const;
    
    // For sorting
    bool operator < (const player &p) const;
public:

struct player_save_info
{
    std::string name;
    unsigned long experience;
    int experience_level;
    bool wizard;
    species_type species;
    std::string class_name;
    player_save_info operator=(const player& rhs);
    bool operator<(const player_save_info& rhs) const;
    std::string short_desc() const;
};