fiddlerwoaroof/crawl - Change TAVHZJPVNJBZR7CUURAOYNDZPNVQ3AGHTXDEP5K4JGYETBLQJDRQC

Cleaned up hiscores xlog format (suggested by Shawn Moore). Breaks compatbility

with older xlogfiles.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@1093 c06c8d41-db1a-0410-9941-cceddc491573

Created by dshaligram on March 25, 2007

TAVHZJPVNJBZR7CUURAOYNDZPNVQ3AGHTXDEP5K4JGYETBLQJDRQC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/libutil.h at line 35 [5.2493627]

[3.144071]

[4.619377]


std::string replace_all(std::string s,
                        const std::string &tofind,
                        const std::string &replacement);

Insertion in crawl-ref/source/libutil.cc at line 194 [5.2494093]

[4.622048]

}
std::string replace_all(std::string s,
                        const std::string &find,
                        const std::string &repl)
{
    std::string::size_type start = 0;
    std::string::size_type found;
   
    while ((found = s.find(find, start)) != std::string::npos)
    {
        s.replace( found, find.length(), repl );
        start = found + repl.length();
    }
    return (s);

Insertion in crawl-ref/source/hiscores.h at line 14 [5.2986382]
[5.2986628]
[5.2986628]
```
struct scorefile_entry;
```

Replacement in crawl-ref/source/hiscores.h at line 42 [5.2986382]

∅:D[6.445] → [5.2987545:2987603]

∅:D[4.813805] → [5.2987545:2987603]

B:BD[5.2987545] → [5.2987545:2987603]

                                  bool verbose = false );

[6.445]

[5.2987603]

                                         bool verbose = false );
class xlog_fields
{
public:
    xlog_fields();
    xlog_fields(const std::string &line);
    void init(const std::string &line);
    std::string xlog_line() const;
    void add_field(const std::string &key,
                   const char *format, ...);
    std::string str_field(const std::string &) const;
    int int_field(const std::string &) const;
    long long_field(const std::string &) const;
private:
    std::string xlog_unescape(const std::string &) const;
    std::string xlog_escape(const std::string &) const;
    void map_fields() const;
    std::string::size_type next_separator(const std::string &s,
                                          std::string::size_type start) const;
    std::vector<std::string> split_fields(const std::string &s) const;
private:
    typedef std::vector< std::pair<std::string, std::string> > xl_fields;
    typedef std::map<std::string, std::string> xl_map;
    xl_fields fields;
    mutable xl_map fieldmap;
};
struct scorefile_entry 
{
public:
    char        version;
    char        release;
    long        points;
    std::string name;
    long        uid;                // for multiuser systems
    char        race;
    char        cls;
    std::string race_class_name;    // overrides race & cls if non-empty.
    char        lvl;                // player level.
    char        best_skill;         // best skill #
    char        best_skill_lvl;     // best skill level
    int         death_type;
    int         death_source;       // 0 or monster TYPE
    int         mon_num;            // sigh...
    std::string death_source_name;  // overrides death_source
    std::string auxkilldata;        // weapon wielded, spell cast, etc
    char        dlvl;               // dungeon level (relative)
    char        level_type;         // what kind of level died on..
    char        branch;             // dungeon branch
    int         final_hp;           // actual current HPs (probably <= 0)
    int         final_max_hp;       // net HPs after rot
    int         final_max_max_hp;   // gross HPs before rot
    int         damage;             // damage of final attack
    int         str;                // final str (useful for nickname)
    int         intel;              // final int
    int         dex;                // final dex (useful for nickname)
    int         god;                // god
    int         piety;              // piety 
    int         penance;            // penance
    char        wiz_mode;           // character used wiz mode
    time_t      birth_time;         // start time of character
    time_t      death_time;         // end time of character
    long        real_time;          // real playing time in seconds
    long        num_turns;          // number of turns taken 
    int         num_diff_runes;     // number of rune types in inventory
    int         num_runes;          // total number of runes in inventory
public:
    scorefile_entry();
    scorefile_entry(int damage, int death_source, int death_type,
                    const char *aux, bool death_cause_only = false);
    scorefile_entry(const scorefile_entry &se);
    scorefile_entry &operator = (const scorefile_entry &other);
    
    void init_death_cause(int damage, int death_source, int death_type,
                          const char *aux);
    void init();
    void reset();
    enum death_desc_verbosity {
        DDV_TERSE,
        DDV_ONELINE,
        DDV_NORMAL,
        DDV_VERBOSE,
        DDV_LOGVERBOSE     // Semi-verbose for logging purposes
    };
    std::string raw_string() const;
    bool parse(const std::string &line);
    
    std::string hiscore_line(death_desc_verbosity verbosity) const;
    std::string character_description(death_desc_verbosity) const;
    // Full description of death: Killed by an xyz wielding foo
    std::string death_description(death_desc_verbosity) const;
    std::string death_place(death_desc_verbosity) const;
    std::string game_time(death_desc_verbosity) const;
private:
    mutable std::auto_ptr<xlog_fields> fields;
    
private:
    std::string single_cdesc() const;
    std::string strip_article_a(const std::string &s) const;
    std::string terse_missile_cause() const;
    std::string terse_missile_name() const;
    std::string terse_beam_cause() const;
    std::string terse_wild_magic() const;
    std::string terse_trap() const;
    const char *damage_verb() const;
    const char *death_source_desc() const;
    std::string damage_string(bool terse = false) const;

Insertion in crawl-ref/source/hiscores.h at line 163 [5.2986382]

[5.2987604]

    bool parse_obsolete_scoreline(const std::string &line);
    bool parse_scoreline(const std::string &line);
    void init_with_fields();
    void add_auxkill_field() const;
    void set_score_fields() const;
    std::string short_kill_message() const;
    std::string long_kill_message() const;
    std::string make_oneline(const std::string &s) const;
    
    void init_from(const scorefile_entry &other);
    int kludge_branch(int branch_01) const;
};

Replacement in crawl-ref/source/hiscores.cc at line 627 [5.2987663]
B:BD[7.8082] → [7.8082:8148]
```
    //    | in values. Literal | must be escaped as || in values.
```
[7.8082]
[7.8148]
```
    //    :: in values.
```
Replacement in crawl-ref/source/hiscores.cc at line 630 [5.2987663]
B:BD[7.8233] → [7.8233:8250]
```
    // type (4).
```
[7.8233]
[5.3034352]
```
    // type (4). 0.3 or 0.4 may discontinue read support for (3).
```

Deletion in crawl-ref/source/hiscores.cc at line 637 [5.2987663]

∅:D[7.8418] → [5.3034867:3034870]

∅:D[4.818076] → [5.3034867:3034870]

B:BD[5.3034867] → [5.3034867:3034870]

B:BD[5.3034870] → [7.8419:8542]

∅:D[7.8542] → [5.3034953:3034955]

∅:D[4.818174] → [5.3034953:3034955]

B:BD[5.3034953] → [5.3034953:3034955]

B:BD[5.3034955] → [7.8543:8711]

∅:D[7.8711] → [4.818198:818199]

B:BD[4.818198] → [4.818198:818199]

B:BD[4.818199] → [7.8712:8938]

∅:D[7.8938] → [4.818217:818223]

B:BD[4.818217] → [4.818217:818223]

B:BD[4.818223] → [7.8939:9252]

∅:D[7.9252] → [4.818255:818261]

B:BD[4.818255] → [4.818255:818261]

B:BD[4.818261] → [7.9253:9273]

}
// xlogfile escape: s/\\/\\\\/g, s/|/\\|/g, s/:/|/g, 
std::string scorefile_entry::xlog_escape(const std::string &s) const
{
    return
        replace_all_of(
            replace_all_of(
                replace_all_of(s, "\\", "\\\\"),
                "|", "\\|" ),
            ":", "|" );
}
// xlogfile unescape: s/\\(.)/$1/g, s/|/:/g
std::string scorefile_entry::xlog_unescape(const std::string &s) const
{
    std::string unesc = s;
    bool escaped = false;
    for (int i = 0, size = unesc.size(); i < size; ++i)
    {
        const char c = unesc[i];
        if (escaped)
        {
            escaped = false;
            continue;
        }
        
        if (c == '|')
            unesc[i] = ':';
        else if (c == '\\')
        {
            escaped = true;
            unesc.erase(i--, 1);
            size--;
        }
    }
    return (unesc);

Deletion in crawl-ref/source/hiscores.cc at line 645 [5.2987663]

B:BD[7.9399] → [7.9399:9559]

∅:D[7.9559] → [5.3035067:3035068]

B:BD[5.3035067] → [5.3035067:3035068]

B:BD[5.3035068] → [7.9560:9710]

    
    std::string line;
    for (int i = 0, size = fields->size(); i < size; ++i)
    {
        const std::pair<std::string, std::string> &f = (*fields)[i];
        // Don't write empty fields.
        if (f.second.empty())
            continue;
        
        if (!line.empty())
            line += ":";

Replacement in crawl-ref/source/hiscores.cc at line 646 [5.2987663]
B:BD[7.9711] → [7.9711:9802]
∅:D[7.9802] → [4.818488:818489]
B:BD[4.818488] → [4.818488:818489]
B:BD[4.818489] → [7.9803:9822]
```
        line += f.first;
        line += "=";
        line += xlog_escape(f.second);
    }
    return (line);
```
[7.9711]
[5.3035083]
```
    return fields->xlog_line();
```

Replacement in crawl-ref/source/hiscores.cc at line 651 [5.2987663]

B:BD[5.3035175] → [7.9887:10212]

∅:D[7.10212] → [4.818636:818637]

B:BD[4.818636] → [4.818636:818637]

B:BD[4.818637] → [7.10213:10389]

∅:D[7.10389] → [5.3035197:3035198]

B:BD[5.3035197] → [5.3035197:3035198]

    std::vector<std::string> rawfields = split_string(":", line);
    fields.reset(new hs_fields);
    for (int i = 0, size = rawfields.size(); i < size; ++i)
    {
        const std::string field = rawfields[i];
        std::string::size_type st = field.find('=');
        if (st == std::string::npos)
            continue;
        fields->push_back(
            std::pair<std::string, std::string>(
                field.substr(0, st),
                xlog_unescape(field.substr(st + 1)) ) );
    }

[5.3035175]

[7.10390]

    fields.reset(new xlog_fields(line));

Deletion in crawl-ref/source/hiscores.cc at line 655 [5.2987663]

B:BD[7.10438] → [7.10438:10440]

∅:D[7.10440] → [4.818699:818700]

B:BD[4.818699] → [4.818699:818700]

B:BD[4.818700] → [7.10441:10723]

∅:D[7.10723] → [5.3035291:3035292]

B:BD[5.3035291] → [5.3035291:3035292]

B:BD[5.3035292] → [7.10724:10808]

∅:D[7.10808] → [4.818912:818913]

B:BD[4.818912] → [4.818912:818913]

B:BD[4.818913] → [7.10809:10859]

B:BD[7.10859] → [2.289:339]

}
void scorefile_entry::add_field(const std::string &key,
                                const char *format,
                                ...) const
{
    char buf[400];
    va_list args;
    va_start(args, format);
    vsnprintf(buf, sizeof buf, format, args);
    va_end(args);
    fields->push_back(
        std::pair<std::string, std::string>( key, buf ) );
}
void scorefile_entry::add_auxkill_field() const
{
    add_field("kaux", "%s", auxkilldata.c_str());

Deletion in crawl-ref/source/hiscores.cc at line 657 [5.2987663]
B:BD[5.3035310] → [7.11054:11097]
∅:D[7.11097] → [5.3035348:3035350]
B:BD[5.3035348] → [5.3035348:3035350]
B:BD[5.3035350] → [2.340:377]
∅:D[2.377] → [7.11275:11277]
B:BD[7.11275] → [7.11275:11277]
∅:D[7.11277] → [4.818926:818927]
B:BD[5.3035444] → [4.818926:818927]
B:BD[4.818927] → [7.11278:11448]
∅:D[7.11448] → [5.3035487:3035488]
B:BD[5.3035487] → [5.3035487:3035488]
B:BD[5.3035488] → [7.11449:11471]
∅:D[7.11471] → [5.3035592:3035595]
∅:D[4.819024] → [5.3035592:3035595]
B:BD[5.3035592] → [5.3035592:3035595]
B:BD[5.3035595] → [7.11472:11531]
∅:D[7.11531] → [5.3035664:3035666]
B:BD[5.3035664] → [5.3035664:3035666]
B:BD[5.3035666] → [7.11532:11740]
∅:D[7.11740] → [5.3035737:3035738]
B:BD[5.3035737] → [5.3035737:3035738]
B:BD[5.3035738] → [7.11741:11868]
∅:D[7.11868] → [5.3036226:3036232]
B:BD[5.3036226] → [5.3036226:3036232]
B:BD[5.3036232] → [7.11869:11987]
∅:D[7.11987] → [5.3036301:3036307]
B:BD[5.3036301] → [5.3036301:3036307]
B:BD[5.3036307] → [7.11988:11990]
∅:D[7.11990] → [5.3038458:3038459]
∅:D[4.819311] → [5.3038458:3038459]
B:BD[5.3038458] → [5.3038458:3038459]
```
void scorefile_entry::read_auxkill_field()
{
    auxkilldata = str_field("kaux");
}
std::string scorefile_entry::str_field(const std::string &s) const
{
    hs_map::const_iterator i = fieldmap->find(s);
    if (i == fieldmap->end())
        return ("");
    return i->second;
}
int scorefile_entry::int_field(const std::string &s) const
{
    std::string field = str_field(s);
    return atoi(field.c_str());
}
long scorefile_entry::long_field(const std::string &s) const
{
    std::string field = str_field(s);
    return atol(field.c_str());
}
void scorefile_entry::map_fields()
{
    fieldmap.reset(new hs_map);
    for (int i = 0, size = fields->size(); i < size; ++i)
    {
        const std::pair<std::string, std::string> f = (*fields)[i];
        
        (*fieldmap)[f.first] = f.second;
    }
}
```

Replacement in crawl-ref/source/hiscores.cc at line 709 [5.2987663]

B:BD[5.3039347] → [7.13128:13240]

    map_fields();
    points = long_field("sc");
    name   = str_field("name");
    uid    = int_field("uid");

[5.3039347]

[5.3039368]

    points = fields->long_field("sc");
    name   = fields->str_field("name");
    uid    = fields->int_field("uid");

Replacement in crawl-ref/source/hiscores.cc at line 713 [5.2987663]

B:BD[5.3039369] → [7.13241:13353]

    race   = str_to_species(str_field("race"));
    cls    = get_class_index_by_name(str_field("cls").c_str());

[5.3039369]

[5.3039458]

    race   = str_to_species(fields->str_field("race"));
    cls    = get_class_index_by_name(fields->str_field("cls").c_str());

Replacement in crawl-ref/source/hiscores.cc at line 716 [5.2987663]
B:BD[5.3039459] → [7.13354:13384]
```
    lvl    = int_field("xl");
```
[5.3039459]
[5.3039574]
```
    lvl    = fields->int_field("xl");
```

Replacement in crawl-ref/source/hiscores.cc at line 718 [5.2987663]

B:BD[5.3039575] → [7.13385:13575]

    best_skill = str_to_skill(str_field("sk"));
    best_skill_lvl = int_field("sklev");
    death_type = str_to_kill_method(str_field("ktyp"));
    death_source_name = str_field("killer");

[5.3039575]

[5.3039876]

    best_skill = str_to_skill(fields->str_field("sk"));
    best_skill_lvl = fields->int_field("sklev");
    death_type = str_to_kill_method(fields->str_field("ktyp"));
    death_source_name = fields->str_field("killer");
    auxkilldata = fields->str_field("kaux");
    branch = str_to_branch(fields->str_field("br"));
    dlvl   = fields->int_field("lvl");
    level_type = str_to_level_area_type(fields->str_field("ltyp"));

Replacement in crawl-ref/source/hiscores.cc at line 727 [5.2987663]

B:BD[5.3039877] → [7.13576:13602]

∅:D[7.13602] → [5.3039974:3039975]

B:BD[5.3039974] → [5.3039974:3039975]

B:BD[5.3039975] → [7.13603:13739]

    read_auxkill_field();
    branch = str_to_branch(str_field("br"));
    dlvl   = int_field("lvl");
    level_type = str_to_level_area_type(str_field("ltyp"));

[5.3039877]

[7.13739]

    final_hp = fields->int_field("hp");
    final_max_hp = fields->int_field("mhp");
    final_max_max_hp = fields->int_field("mmhp");
    damage = fields->int_field("dam");
    str = fields->int_field("str");
    intel = fields->int_field("int");
    dex = fields->int_field("dex");

Replacement in crawl-ref/source/hiscores.cc at line 735 [5.2987663]

B:BD[7.13740] → [7.13740:14352]

    final_hp = int_field("hp");
    final_max_hp = int_field("mhp");
    final_max_max_hp = int_field("mmhp");
    damage = int_field("dam");
    str = int_field("str");
    intel = int_field("int");
    dex = int_field("dex");
    god = str_to_god(str_field("god"));
    piety = int_field("piety");
    penance = int_field("pen");
    wiz_mode = int_field("wiz");
    birth_time = parse_time(str_field("start"));
    death_time = parse_time(str_field("end"));
    real_time  = long_field("dur");
    num_turns  = long_field("turn");
    num_diff_runes = int_field("urune");
    num_runes = int_field("nrune");

[7.13740]

[7.14352]

    god = str_to_god(fields->str_field("god"));
    piety = fields->int_field("piety");
    penance = fields->int_field("pen");
    wiz_mode = fields->int_field("wiz");
    birth_time = parse_time(fields->str_field("start"));
    death_time = parse_time(fields->str_field("end"));
    real_time  = fields->long_field("dur");
    num_turns  = fields->long_field("turn");
    num_diff_runes = fields->int_field("urune");
    num_runes = fields->int_field("nrune");

Replacement in crawl-ref/source/hiscores.cc at line 749 [5.2987663]
B:BD[7.14404] → [7.14404:14439]
```
    fields.reset(new hs_fields());
```
[7.14404]
[7.14439]
```
    fields.reset(new xlog_fields);
```

Replacement in crawl-ref/source/hiscores.cc at line 754 [5.2987663]

B:BD[7.14465] → [7.14465:14945]

    add_field("v", VER_NUM);
    add_field("lv", SCORE_VERSION);
    add_field("sc", "%ld", points);
    add_field("name", "%s", name.c_str());
    add_field("uid", "%d", uid);
    add_field("race", "%s", species_name(race, lvl));
    add_field("cls", "%s", get_class_name(cls));
    add_field("xl", "%d", lvl);
    add_field("sk", "%s", skill_name(best_skill));
    add_field("sklev", "%d", best_skill_lvl);
    add_field("title", "%s", skill_title( best_skill, best_skill_lvl,

[7.14465]

[7.14945]

    fields->add_field("v", VER_NUM);
    fields->add_field("lv", SCORE_VERSION);
    fields->add_field("sc", "%ld", points);
    fields->add_field("name", "%s", name.c_str());
    fields->add_field("uid", "%d", uid);
    fields->add_field("race", "%s", species_name(race, lvl));
    fields->add_field("cls", "%s", get_class_name(cls));
    fields->add_field("xl", "%d", lvl);
    fields->add_field("sk", "%s", skill_name(best_skill));
    fields->add_field("sklev", "%d", best_skill_lvl);
    fields->add_field("title", "%s", skill_title( best_skill, best_skill_lvl,

Replacement in crawl-ref/source/hiscores.cc at line 766 [5.2987663]

B:BD[7.15020] → [7.15020:15139]

    add_field("ktyp", ::kill_method_name(kill_method_type(death_type)));
    add_field("killer", death_source_desc());

[7.15020]

[7.15139]

    fields->add_field("ktyp", ::kill_method_name(kill_method_type(death_type)));
    fields->add_field("killer", death_source_desc());

Replacement in crawl-ref/source/hiscores.cc at line 769 [5.2987663]
B:BD[7.15140] → [7.15140:15165]
```
    add_auxkill_field();
```
[7.15140]
[7.15165]
```
    fields->add_field("kaux", "%s", auxkilldata.c_str());
```
Replacement in crawl-ref/source/hiscores.cc at line 771 [5.2987663]
B:BD[7.15166] → [7.15166:15195]
```
    add_field("place", "%s",
```
[7.15166]
[7.15195]
```
    fields->add_field("place", "%s",
```

Replacement in crawl-ref/source/hiscores.cc at line 774 [5.2987663]

B:BD[7.15312] → [7.15312:15463]

    add_field("br", "%s", short_branch_name(branch));
    add_field("lvl", "%d", dlvl);
    add_field("ltyp", "%s", level_area_type_name(level_type));

[7.15312]

[7.15463]

    fields->add_field("br", "%s", short_branch_name(branch));
    fields->add_field("lvl", "%d", dlvl);
    fields->add_field("ltyp", "%s", level_area_type_name(level_type));

Replacement in crawl-ref/source/hiscores.cc at line 778 [5.2987663]

B:BD[7.15464] → [7.15464:15727]

    add_field("hp", "%d", final_hp);
    add_field("mhp", "%d", final_max_hp);
    add_field("mmhp", "%d", final_max_max_hp);
    add_field("dam", "%d", damage);
    add_field("str", "%d", str);
    add_field("int", "%d", intel);
    add_field("dex", "%d", dex);

[7.15464]

[7.15727]

    fields->add_field("hp", "%d", final_hp);
    fields->add_field("mhp", "%d", final_max_hp);
    fields->add_field("mmhp", "%d", final_max_max_hp);
    fields->add_field("dam", "%d", damage);
    fields->add_field("str", "%d", str);
    fields->add_field("int", "%d", intel);
    fields->add_field("dex", "%d", dex);

Replacement in crawl-ref/source/hiscores.cc at line 788 [5.2987663]

B:BD[7.15793] → [7.15793:15864]

        add_field("god", "%s", god == GOD_NO_GOD? "" : god_name(god));

[7.15793]

[7.15864]

        fields->add_field("god", "%s", god == GOD_NO_GOD? "" : god_name(god));

Replacement in crawl-ref/source/hiscores.cc at line 790 [5.2987663]
B:BD[7.15883] → [7.15883:15924]
```
        add_field("piety", "%d", piety);
```
[7.15883]
[7.15924]
```
        fields->add_field("piety", "%d", piety);
```
Replacement in crawl-ref/source/hiscores.cc at line 792 [5.2987663]
B:BD[7.15945] → [7.15945:15986]
```
        add_field("pen", "%d", penance);
```
[7.15945]
[7.15986]
```
        fields->add_field("pen", "%d", penance);
```
Replacement in crawl-ref/source/hiscores.cc at line 794 [5.2987663]
B:BD[7.16004] → [7.16004:16046]
```
        add_field("wiz", "%d", wiz_mode);
```
[7.16004]
[7.16046]
```
        fields->add_field("wiz", "%d", wiz_mode);
```

Replacement in crawl-ref/source/hiscores.cc at line 796 [5.2987663]

B:BD[7.16051] → [7.16051:16266]

    add_field("start", "%s", make_date_string(birth_time).c_str());
    add_field("end", "%s", make_date_string(death_time).c_str());
    add_field("dur", "%ld", real_time);
    add_field("turn", "%ld", num_turns);

[7.16051]

[7.16266]

    fields->add_field("start", "%s", make_date_string(birth_time).c_str());
    fields->add_field("end", "%s", make_date_string(death_time).c_str());
    fields->add_field("dur", "%ld", real_time);
    fields->add_field("turn", "%ld", num_turns);

Replacement in crawl-ref/source/hiscores.cc at line 802 [5.2987663]

B:BD[7.16291] → [7.16291:16341]

        add_field("urune", "%d", num_diff_runes);

[7.16291]

[7.16341]

        fields->add_field("urune", "%d", num_diff_runes);

Replacement in crawl-ref/source/hiscores.cc at line 805 [5.2987663]
B:BD[7.16361] → [7.16361:16406]
```
        add_field("nrune", "%d", num_runes);
```
[7.16361]
[7.16406]
```
        fields->add_field("nrune", "%d", num_runes);
```
Replacement in crawl-ref/source/hiscores.cc at line 809 [5.2987663]
B:BD[7.16492] → [7.16492:16540]
```
    add_field("tmsg", "%s", short_msg.c_str());
```
[7.16492]
[7.16540]
```
    fields->add_field("tmsg", "%s", short_msg.c_str());
```

Replacement in crawl-ref/source/hiscores.cc at line 812 [5.2987663]

B:BD[7.16625] → [7.16625:16676]

        add_field("vmsg", "%s", long_msg.c_str());

[7.16625]

[7.16676]

        fields->add_field("vmsg", "%s", long_msg.c_str());

Insertion in crawl-ref/source/hiscores.cc at line 1933 [5.2987663]

[4.848736]

}
//////////////////////////////////////////////////////////////////////////////
// xlog_fields
xlog_fields::xlog_fields() : fields(), fieldmap()
{
}
xlog_fields::xlog_fields(const std::string &line) : fields(), fieldmap()
{
    init(line);
}
std::string::size_type
xlog_fields::next_separator(const std::string &s,
                            std::string::size_type start) const
{
    std::string::size_type p = s.find(':', start);
    if (p != std::string::npos && p < s.length() - 1 && s[p + 1] == ':')
        return next_separator(s, p + 2);
    return (p);
}
std::vector<std::string>
xlog_fields::split_fields(const std::string &s) const
{
    std::string::size_type start = 0, end = 0;
    std::vector<std::string> fs;
    for ( ; (end = next_separator(s, start)) != std::string::npos;
          start = end + 1  )
    {
        fs.push_back( s.substr(start, end - start) );
    }
    if (start < s.length())
        fs.push_back( s.substr(start) );
    return (fs);
}
void xlog_fields::init(const std::string &line)
{
    std::vector<std::string> rawfields = split_fields(line);
    for (int i = 0, size = rawfields.size(); i < size; ++i)
    {
        const std::string field = rawfields[i];
        std::string::size_type st = field.find('=');
        if (st == std::string::npos)
            continue;
        fields.push_back(
            std::pair<std::string, std::string>(
                field.substr(0, st),
                xlog_unescape(field.substr(st + 1)) ) );
    }
    map_fields();
}
// xlogfile escape: s/:/::/g
std::string xlog_fields::xlog_escape(const std::string &s) const
{
    return replace_all(s, ":", "::");
}
// xlogfile unescape: s/::/:/g
std::string xlog_fields::xlog_unescape(const std::string &s) const
{
    return replace_all(s, "::", ":");
}
void xlog_fields::add_field(const std::string &key,
                            const char *format,
                            ...)
{
    char buf[500];
    va_list args;
    va_start(args, format);
    vsnprintf(buf, sizeof buf, format, args);
    va_end(args);
    fields.push_back(
        std::pair<std::string, std::string>( key, buf ) );
    fieldmap[key] = buf;

Insertion in crawl-ref/source/hiscores.cc at line 2021 [5.2987663]

[4.848738]


std::string xlog_fields::str_field(const std::string &s) const
{
    xl_map::const_iterator i = fieldmap.find(s);
    if (i == fieldmap.end())
        return ("");
    return i->second;
}
int xlog_fields::int_field(const std::string &s) const
{
    std::string field = str_field(s);
    return atoi(field.c_str());
}
long xlog_fields::long_field(const std::string &s) const
{
    std::string field = str_field(s);
    return atol(field.c_str());
}
void xlog_fields::map_fields() const
{
    fieldmap.clear();
    for (int i = 0, size = fields.size(); i < size; ++i)
    {
        const std::pair<std::string, std::string> &f = fields[i];
        fieldmap[f.first] = f.second;
    }
}
std::string xlog_fields::xlog_line() const
{
    std::string line;
    for (int i = 0, size = fields.size(); i < size; ++i)
    {
        const std::pair<std::string, std::string> &f = fields[i];
        // Don't write empty fields.
        if (f.second.empty())
            continue;
        
        if (!line.empty())
            line += ":";
        line += f.first;
        line += "=";
        line += xlog_escape(f.second);
    }
    return (line);
}

Deletion in crawl-ref/source/externs.h at line 1478 [5.3270163]

B:BD[5.3285918] → [5.3285918:3285948]

B:BD[5.3285948] → [4.901915:901923]

∅:D[4.901923] → [5.3285948:3286022]

B:BD[5.3285948] → [5.3285948:3286022]

B:BD[5.3286022] → [7.25023:25045]

∅:D[7.25045] → [5.3286054:3286158]

B:BD[5.3286054] → [5.3286054:3286158]

B:BD[5.3286158] → [7.25046:25120]

∅:D[7.25120] → [5.3286230:3286523]

B:BD[5.3286230] → [5.3286230:3286523]

B:BD[5.3286523] → [7.25121:25254]

∅:D[7.25254] → [5.3286670:3287900]

B:BD[5.3286670] → [5.3286670:3287900]

B:BD[5.3287900] → [4.901924:902091]

B:BD[4.902091] → [7.25255:25303]

∅:D[7.25303] → [4.902091:902092]

B:BD[4.902091] → [4.902091:902092]

B:BD[4.902092] → [7.25304:25373]

∅:D[7.25373] → [4.902092:902336]

B:BD[4.902092] → [4.902092:902336]

B:BD[4.902336] → [7.25374:25459]

∅:D[7.25459] → [4.902356:902364]

B:BD[4.902356] → [4.902356:902364]

B:BD[4.902364] → [7.25460:25542]

∅:D[7.25542] → [4.902364:902627]

B:BD[4.902364] → [4.902364:902627]

B:BD[4.902628] → [4.902628:902685]

B:BD[4.902685] → [7.25543:25598]

∅:D[7.25598] → [4.902685:902686]

B:BD[4.902685] → [4.902685:902686]

B:BD[4.902686] → [7.25599:25737]

∅:D[7.25737] → [4.902741:902742]

B:BD[4.902741] → [4.902741:902742]

B:BD[4.902742] → [7.25738:25832]

∅:D[7.25832] → [4.902742:902895]

B:BD[4.902742] → [4.902742:902895]

B:BD[4.902895] → [7.25833:25877]

∅:D[7.25877] → [4.902895:903152]

B:BD[4.902895] → [4.902895:903152]

B:BD[4.903152] → [7.25878:26758]

};
struct scorefile_entry 
{
public:
    char        version;
    char        release;
    long        points;
    std::string name;
    long        uid;                // for multiuser systems
    char        race;
    char        cls;
    std::string race_class_name;    // overrides race & cls if non-empty.
    char        lvl;                // player level.
    char        best_skill;         // best skill #
    char        best_skill_lvl;     // best skill level
    int         death_type;
    int         death_source;       // 0 or monster TYPE
    int         mon_num;            // sigh...
    std::string death_source_name;  // overrides death_source
    std::string auxkilldata;        // weapon wielded, spell cast, etc
    char        dlvl;               // dungeon level (relative)
    char        level_type;         // what kind of level died on..
    char        branch;             // dungeon branch
    int         final_hp;           // actual current HPs (probably <= 0)
    int         final_max_hp;       // net HPs after rot
    int         final_max_max_hp;   // gross HPs before rot
    int         damage;             // damage of final attack
    int         str;                // final str (useful for nickname)
    int         intel;              // final int
    int         dex;                // final dex (useful for nickname)
    int         god;                // god
    int         piety;              // piety 
    int         penance;            // penance
    char        wiz_mode;           // character used wiz mode
    time_t      birth_time;         // start time of character
    time_t      death_time;         // end time of character
    long        real_time;          // real playing time in seconds
    long        num_turns;          // number of turns taken 
    int         num_diff_runes;     // number of rune types in inventory
    int         num_runes;          // total number of runes in inventory
public:
    scorefile_entry();
    scorefile_entry(int damage, int death_source, int death_type,
                    const char *aux, bool death_cause_only = false);
    scorefile_entry(const scorefile_entry &se);
    scorefile_entry &operator = (const scorefile_entry &other);
    
    void init_death_cause(int damage, int death_source, int death_type,
                          const char *aux);
    void init();
    void reset();
    enum death_desc_verbosity {
        DDV_TERSE,
        DDV_ONELINE,
        DDV_NORMAL,
        DDV_VERBOSE,
        DDV_LOGVERBOSE     // Semi-verbose for logging purposes
    };
    std::string raw_string() const;
    bool parse(const std::string &line);
    
    std::string hiscore_line(death_desc_verbosity verbosity) const;
    std::string character_description(death_desc_verbosity) const;
    // Full description of death: Killed by an xyz wielding foo
    std::string death_description(death_desc_verbosity) const;
    std::string death_place(death_desc_verbosity) const;
    std::string game_time(death_desc_verbosity) const;
private:
    typedef std::vector< std::pair<std::string, std::string> > hs_fields;
    typedef std::map<std::string, std::string> hs_map;
    mutable std::auto_ptr<hs_fields> fields;
    mutable std::auto_ptr<hs_map> fieldmap;
    
private:
    std::string single_cdesc() const;
    std::string strip_article_a(const std::string &s) const;
    std::string terse_missile_cause() const;
    std::string terse_missile_name() const;
    std::string terse_beam_cause() const;
    std::string terse_wild_magic() const;
    std::string terse_trap() const;
    const char *damage_verb() const;
    const char *death_source_desc() const;
    std::string damage_string(bool terse = false) const;
    bool parse_obsolete_scoreline(const std::string &line);
    bool parse_scoreline(const std::string &line);
    void init_with_fields();
    void add_field(const std::string &key,
                   const char *format, ...) const;
    void add_auxkill_field() const;
    void set_score_fields() const;
    std::string short_kill_message() const;
    std::string long_kill_message() const;
    std::string make_oneline(const std::string &s) const;
    
    std::string str_field(const std::string &key) const;
    int int_field(const std::string &key) const;
    long long_field(const std::string &key) const;
    std::string xlog_escape(const std::string &s) const;
    std::string xlog_unescape(const std::string &s) const;
    void read_auxkill_field();
    void map_fields();
    void init_from(const scorefile_entry &other);
    int kludge_branch(int branch_01) const;

Cleaned up hiscores xlog format (suggested by Shawn Moore). Breaks compatbility

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/libutil.h at line 35 [5.2493627]

Insertion in crawl-ref/source/libutil.cc at line 194 [5.2494093]

Insertion in crawl-ref/source/hiscores.h at line 14 [5.2986382]

Replacement in crawl-ref/source/hiscores.h at line 42 [5.2986382]

Insertion in crawl-ref/source/hiscores.h at line 163 [5.2986382]

Replacement in crawl-ref/source/hiscores.cc at line 627 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 630 [5.2987663]

Deletion in crawl-ref/source/hiscores.cc at line 637 [5.2987663]

Deletion in crawl-ref/source/hiscores.cc at line 645 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 646 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 651 [5.2987663]

Deletion in crawl-ref/source/hiscores.cc at line 655 [5.2987663]

Deletion in crawl-ref/source/hiscores.cc at line 657 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 709 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 713 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 716 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 718 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 727 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 735 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 749 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 754 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 766 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 769 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 771 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 774 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 778 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 788 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 790 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 792 [5.2987663]

Replacement in crawl-ref/source/hiscores.cc at line 794 [5.2987663]