fiddlerwoaroof/crawl - Change 43ZTEB57FU7KE5EVMYWZONNVJBZCGF3JEAJZIY25LC4LGE65PG5QC

Redid how the resists screen works (both in-game and in-dump.)

Minor notes refactoring. Added a basic notes browser on '_'.

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

Created by haranp on November 29, 2006

43ZTEB57FU7KE5EVMYWZONNVJBZCGF3JEAJZIY25LC4LGE65PG5QC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/overmap.cc at line 130 [3.1070017]

B:BD[3.1073406] → [2.9282:9360]

    disp += "                    <white>Overview of the Dungeon</white>" EOL;

[3.1073406]

[3.1073574]

    disp += "                    <white>Overview of the Dungeon</white>\n" ;

Replacement in crawl-ref/source/overmap.cc at line 141 [3.1070017]

B:BD[3.1074492] → [2.9637:9697]

                disp += EOL "<white>Branches:</white>" EOL;

[3.1074492]

[2.9697]

                disp += "\n<white>Branches:</white>\n";

Replacement in crawl-ref/source/overmap.cc at line 152 [3.1070017]
B:BD[2.10051] → [2.10051:10080]
```
                disp += EOL;
```
[2.10051]
[2.10080]
```
                disp += "\n";
```
Replacement in crawl-ref/source/overmap.cc at line 158 [3.1070017]
B:BD[2.10188] → [2.10188:10209]
```
        disp += EOL;
```
[2.10188]
[2.10209]
```
        disp += "\n";
```
Replacement in crawl-ref/source/overmap.cc at line 164 [3.1070017]
B:BD[2.10332] → [2.10332:10382]
```
        disp += EOL "<white>Altars:</white>" EOL;
```
[2.10332]
[2.10382]
```
        disp += "\n<white>Altars:</white>\n";
```
Replacement in crawl-ref/source/overmap.cc at line 204 [3.1070017]
B:BD[2.11608] → [2.11608:11633]
```
            disp += EOL;
```
[2.11608]
[3.1080449]
```
            disp += "\n";
```
Replacement in crawl-ref/source/overmap.cc at line 210 [3.1070017]
B:BD[3.1080874] → [2.11686:11735]
```
        disp += EOL "<white>Shops:</white>" EOL;
```
[3.1080874]
[2.11735]
```
        disp += "\n<white>Shops:</white>\n";
```
Replacement in crawl-ref/source/overmap.cc at line 228 [3.1070017]
B:BD[2.12336] → [2.12336:12369]
```
                    disp += EOL;
```
[2.12336]
[2.12369]
```
                    disp += "\n";
```
Replacement in crawl-ref/source/overmap.cc at line 241 [3.1070017]
B:BD[2.12716] → [2.12716:12733]
```
    disp += EOL;
```
[2.12716]
[3.1082891]
```
    disp += "\n";
```
Replacement in crawl-ref/source/overmap.cc at line 246 [3.1070017]
B:BD[2.12797] → [2.12797:12848]
```
        disp += EOL "<white>Portals:</white>" EOL;
```
[2.12797]
[2.12848]
```
        disp += "\n<white>Portals:</white>\n";
```
Replacement in crawl-ref/source/overmap.cc at line 276 [3.1070017]
B:BD[2.13954] → [2.13954:13979]
```
            disp += EOL;
```
[2.13954]
[3.1083306]
```
            disp += "\n";
```
Insertion in crawl-ref/source/output.h at line 16 [3.1087719]
[3.1087991]
[3.1087991]
```
#include "menu.h"
```
Replacement in crawl-ref/source/output.h at line 28 [3.1087719]
B:BD[4.204894] → [4.204894:204946]
```
void get_full_detail(char* buffer, bool calc_unid);
```
[4.204894]
[3.1088238]
```
std::vector<formatted_string> get_full_detail(bool calc_unid);
```
Insertion in crawl-ref/source/output.cc at line 26 [3.1088282]
[4.205096]
[3.1088712]
```
#include "initfile.h"
```
Replacement in crawl-ref/source/output.cc at line 555 [3.1088282]
B:BD[4.205489] → [4.205489:205522]
```
unsigned char* itosym1(int stat)
```
[4.205489]
[4.205522]
```
const char* itosym1(int stat)
```
Replacement in crawl-ref/source/output.cc at line 557 [3.1088282]
B:BD[4.205524] → [4.205524:205584]
```
    return (unsigned char*)( (stat >= 1) ? "+  " : ".  " );
```
[4.205524]
[4.205584]
```
    return ( (stat >= 1) ? "+  " : ".  " );
```
Replacement in crawl-ref/source/output.cc at line 560 [3.1088282]
B:BD[4.205587] → [4.205587:205620]
```
unsigned char* itosym3(int stat)
```
[4.205587]
[4.205620]
```
const char* itosym3(int stat)
```
Replacement in crawl-ref/source/output.cc at line 562 [3.1088282]
B:BD[4.205622] → [4.205622:205675]
```
    return (unsigned char*)( (stat >= 3) ? "+ + +" :
```
[4.205622]
[5.359865]
```
    return ( (stat >=  3) ? "+ + +" :
```

Replacement in crawl-ref/source/output.cc at line 604 [3.1088282]

B:BD[4.206396] → [4.206396:206449]

B:BD[4.206474] → [4.206474:206512]

B:BD[4.206512] → [5.360080:360125]

∅:D[5.360125] → [4.206556:206590]

B:BD[4.206556] → [4.206556:206590]

void get_full_detail(char* buffer, bool calc_unid)
{
#define CUR_AD &buffer[++lines*45],44
#define BUF_SIZE 24*3*45
    int lines = -1;
    memset(buffer, 0, BUF_SIZE);

[4.206396]

[4.206590]

static const char* determine_color_string( int level ) {
    switch ( level ) {
    case 3:
    case 2:
	return "<lightgreen>";
    case 1:
        return "<green>";
    case -1:
        return "<red>";
    case -2:
    case -3:
        return "<lightred>";
    default:
        return "<lightgrey>";
    }
}

Replacement in crawl-ref/source/output.cc at line 621 [3.1088282]

B:BD[4.206591] → [4.206591:207052]

    snprintf(CUR_AD, "%s the %s", you.your_name, player_title());
    lines++;
    snprintf(CUR_AD, "Race       : %s", species_name(you.species,you.experience_level) );
    snprintf(CUR_AD, "Class      : %s", you.class_name);
    snprintf(CUR_AD, "Worship    : %s", 
            you.religion == GOD_NO_GOD? "" : god_name(you.religion) );
    snprintf(CUR_AD, "Level      : %7d", you.experience_level);
    snprintf(CUR_AD, "Exp        : %7lu", you.experience);

[4.206591]

[4.207052]

std::vector<formatted_string> get_full_detail(bool calc_unid)
{
    char buf[1000];
    // 3 columns, splits at columns 32, 52
    column_composer cols(3, 32, 52);
    snprintf(buf, sizeof buf,
             "<red>%s the %s</red>\n\n"
             "Race       : %s\n"
             "Class      : %s\n"
             "Worship    : %s\n"
             "Level      : %7d\n"
             "Exp        : %7lu\n",
             you.your_name, player_title(),
             species_name(you.species,you.experience_level),
             you.class_name,
             you.religion == GOD_NO_GOD? "" : god_name(you.religion),
             you.experience_level,
             you.experience);
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 643 [3.1088282]

B:BD[4.207094] → [4.207094:207323]

        int xp_needed = (exp_needed(you.experience_level+2) - you.experience) + 1;
        snprintf(CUR_AD, "Next Level : %7lu", exp_needed(you.experience_level + 2) + 1);
        snprintf(CUR_AD, "Exp Needed : %7d", xp_needed);

[4.207094]

[4.207323]

        int xp_needed = (exp_needed(you.experience_level+2)-you.experience)+1;
        snprintf(buf, sizeof buf,
                 "Next Level : %7lu\n"
                 "Exp Needed : %7d\n",
                 exp_needed(you.experience_level + 2) + 1,
                 xp_needed);
        cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 652 [3.1088282]

B:BD[4.207338] → [4.207338:207580]

    {
        snprintf(CUR_AD, "                  ");
        snprintf(CUR_AD, "                  ");
    }
    snprintf(CUR_AD, "Spls.Left  : %7d", player_spell_levels() );
    snprintf(CUR_AD, "Gold       : %7d", you.gold );
    lines++;

[4.207338]

[4.207580]

        cols.add_formatted(0, "\n\n", false);
       
    snprintf(buf, sizeof buf,
             "Spls.Left  : %7d\n"
             "Gold       : %7d\n",
             player_spell_levels(),
             you.gold);
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 664 [3.1088282]

B:BD[4.207646] → [4.207646:207719]

            snprintf(CUR_AD, "HP         : %3d/%d", you.hp, you.hp_max);

[4.207646]

[4.207719]

            snprintf(buf, sizeof buf, "HP         : %3d/%d",you.hp,you.hp_max);

Replacement in crawl-ref/source/output.cc at line 666 [3.1088282]

B:BD[4.207732] → [4.207732:207790]

            snprintf(CUR_AD, "HP         : %3d", you.hp);

[4.207732]

[4.207790]

            snprintf(buf, sizeof buf, "HP         : %3d", you.hp);

Replacement in crawl-ref/source/output.cc at line 670 [3.1088282]

B:BD[4.207811] → [5.360126:360180]

∅:D[5.360180] → [4.207866:207934]

B:BD[4.207866] → [4.207866:207934]

        snprintf(CUR_AD, "HP         : %3d/%d (%d)", 
                you.hp, you.hp_max, you.hp_max + player_rotted() );

[4.207811]

[4.207934]

        snprintf(buf, sizeof buf, "HP         : %3d/%d (%d)", 
                 you.hp, you.hp_max, you.hp_max + player_rotted() );

Insertion in crawl-ref/source/output.cc at line 673 [3.1088282]
[4.207940]
[4.207940]
```
    cols.add_formatted(0, buf, true);
```

Replacement in crawl-ref/source/output.cc at line 676 [3.1088282]

B:BD[4.207990] → [4.207990:208092]

        snprintf(CUR_AD, "MP         : %3d/%d", 
            you.magic_points, you.max_magic_points);

[4.207990]

[4.208092]

        snprintf(buf, sizeof buf, "MP         : %3d/%d", 
                 you.magic_points, you.max_magic_points);

Replacement in crawl-ref/source/output.cc at line 679 [3.1088282]

B:BD[4.208101] → [4.208101:208165]

        snprintf(CUR_AD, "MP         : %3d", you.magic_points);

[4.208101]

[4.208165]

        snprintf(buf, sizeof buf, "MP         : %3d", you.magic_points);
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 683 [3.1088282]

B:BD[4.208208] → [4.208208:208268]

        snprintf(CUR_AD, "Str        : %3d", you.strength);

[4.208208]

[4.208268]

        snprintf(buf, sizeof buf, "Str        : %3d", you.strength);

Replacement in crawl-ref/source/output.cc at line 685 [3.1088282]

B:BD[4.208277] → [4.208277:208377]

        snprintf(CUR_AD, "Str        : %3d (%d)", 
                you.strength, you.max_strength);

[4.208277]

[4.208377]

        snprintf(buf, sizeof buf, "Str        : %3d (%d)",
                 you.strength, you.max_strength);
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 690 [3.1088282]

B:BD[4.208418] → [4.208418:208475]

        snprintf(CUR_AD, "Int        : %3d", you.intel);

[4.208418]

[4.208475]

        snprintf(buf, sizeof buf, "Int        : %3d", you.intel);

Replacement in crawl-ref/source/output.cc at line 692 [3.1088282]

B:BD[4.208484] → [4.208484:208561]

        snprintf(CUR_AD, "Int        : %3d (%d)", you.intel, you.max_intel);

[4.208484]

[4.208561]

        snprintf(buf, sizeof buf, "Int        : %3d (%d)",
                 you.intel, you.max_intel);
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 697 [3.1088282]

B:BD[4.208598] → [4.208598:208653]

        snprintf(CUR_AD, "Dex        : %3d", you.dex);

[4.208598]

[4.208653]

        snprintf(buf, sizeof buf, "Dex        : %3d", you.dex);

Replacement in crawl-ref/source/output.cc at line 699 [3.1088282]

B:BD[4.208662] → [4.208662:208735]

        snprintf(CUR_AD, "Dex        : %3d (%d)", you.dex, you.max_dex);

[4.208662]

[4.208735]

        snprintf(buf, sizeof buf, "Dex        : %3d (%d)",you.dex,you.max_dex);
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 702 [3.1088282]

B:BD[4.208736] → [4.208736:208932]

    snprintf(CUR_AD, "AC         : %3d", player_AC() );
    snprintf(CUR_AD, "Evasion    : %3d", player_evasion() );
    snprintf(CUR_AD, "Shield     : %3d", player_shield_class() );
    lines++;

[4.208736]

[4.208932]

    snprintf(buf, sizeof buf,
             "AC         : %3d\n"
             "Evasion    : %3d\n"
             "Shield     : %3d\n",
             player_AC(),
             player_evasion(),
             player_shield_class());
    cols.add_formatted(0, buf, false);

Replacement in crawl-ref/source/output.cc at line 717 [3.1088282]

B:BD[4.209128] → [4.209128:209245]

        snprintf(CUR_AD, "Play time  : %10s", buff);
        snprintf(CUR_AD, "Turns      : %10ld", you.num_turns );

[4.209128]

[4.209245]

        snprintf(buf, sizeof buf,
                 "Play time  : %10s\n"
                 "Turns      : %10ld\n",
                 buff, you.num_turns );
        cols.add_formatted(0, buf, true);

Replacement in crawl-ref/source/output.cc at line 724 [3.1088282]

B:BD[4.209252] → [5.360181:360201]

    lines = 24 + 1;

[4.209252]

[4.209268]

    const int rfire = player_res_fire(calc_unid);
    const int rcold = player_res_cold(calc_unid);
    const int rlife = player_prot_life(calc_unid);
    const int rpois = player_res_poison(calc_unid);
    const int relec = player_res_electricity(calc_unid);
    snprintf(buf, sizeof buf, "\n\n"             
             "Res.Fire  : %s%s\n"
             "Res.Cold  : %s%s\n"
             "Life Prot.: %s%s\n"
             "Res.Poison: %s%s\n"
             "Res.Elec. : %s%s\n",
             determine_color_string(rfire), itosym3(rfire),
             determine_color_string(rcold), itosym3(rcold),
             determine_color_string(rlife), itosym3(rlife),
             determine_color_string(rpois), itosym1(rpois),
             determine_color_string(relec), itosym1(relec));
    cols.add_formatted(1, buf, false);

Replacement in crawl-ref/source/output.cc at line 743 [3.1088282]

B:BD[4.209269] → [4.209269:210212]

    snprintf(CUR_AD, "Res.Fire  : %s", 
            itosym3( player_res_fire(calc_unid) ) );
    snprintf(CUR_AD, "Res.Cold  : %s", 
            itosym3( player_res_cold(calc_unid) ) );
    snprintf(CUR_AD, "Life Prot.: %s", 
            itosym3( player_prot_life(calc_unid) ) );
    snprintf(CUR_AD, "Res.Poison: %s", 
            itosym1( player_res_poison(calc_unid) ) );
    snprintf(CUR_AD, "Res.Elec. : %s", 
            itosym1( player_res_electricity(calc_unid) ) );
    lines++;
    
    snprintf(CUR_AD, "Sust.Abil.: %s", 
            itosym1( player_sust_abil(calc_unid) ) );
    snprintf(CUR_AD, "Res.Mut.  : %s", 
            itosym1( wearing_amulet( AMU_RESIST_MUTATION, calc_unid) ) );
    snprintf(CUR_AD, "Res.Slow  : %s", 
            itosym1( wearing_amulet( AMU_RESIST_SLOW, calc_unid) ) );
    snprintf(CUR_AD, "Clarity   : %s", 
            itosym1( wearing_amulet( AMU_CLARITY, calc_unid) ) );
    lines++;
    lines++;

[4.209269]

[4.210212]

    const int rsust = player_sust_abil(calc_unid);
    const int rmuta = wearing_amulet(AMU_RESIST_MUTATION, calc_unid);
    const int rslow = wearing_amulet(AMU_RESIST_SLOW, calc_unid);
    const int rclar = wearing_amulet(AMU_CLARITY, calc_unid);
    snprintf(buf, sizeof buf,
             "Sust.Abil.: %s%s\n"
             "Res.Mut.  : %s%s\n"
             "Res.Slow  : %s%s\n"
             "Clarity   : %s%s\n \n",
             determine_color_string(rsust), itosym1(rsust),
             determine_color_string(rmuta), itosym1(rmuta),
             determine_color_string(rslow), itosym1(rslow),
             determine_color_string(rclar), itosym1(rclar));
    cols.add_formatted(1, buf, true);

Replacement in crawl-ref/source/output.cc at line 779 [3.1088282]

B:BD[4.210942] → [4.210942:211005]

B:BD[4.211005] → [5.360322:360365]

∅:D[5.360365] → [4.211062:211124]

B:BD[4.211062] → [4.211062:211124]

                in_name( you.equip[ e_order[i] ], DESC_PLAIN, 
                         str_pass, true );
                snprintf(CUR_AD, "%-7s: %s", slot, str_pass);

[4.210942]

[4.211124]

                const int inum = you.equip[e_order[i]];
                in_name( inum, DESC_PLAIN, str_pass, true );
                str_pass[38] = 0; // truncate
                const char* colname = colour_to_str(you.inv[inum].colour);
                snprintf(buf, sizeof buf, "%-7s: <%s>%s</%s>",
                         slot, colname, str_pass, colname);

Replacement in crawl-ref/source/output.cc at line 791 [3.1088282]

B:BD[4.211312] → [4.211312:211381]

                        snprintf(CUR_AD, "%-7s: Blade Hands", slot);

[4.211312]

[4.211381]

                        snprintf(buf, sizeof buf, "%-7s: Blade Hands", slot);

Replacement in crawl-ref/source/output.cc at line 793 [3.1088282]

B:BD[4.211441] → [4.211441:211506]

                        snprintf(CUR_AD, "%-7s: Unarmed", slot);

[4.211441]

[4.211506]

                        snprintf(buf, sizeof buf, "%-7s: Unarmed", slot);

Replacement in crawl-ref/source/output.cc at line 795 [3.1088282]

B:BD[4.211531] → [4.211531:211588]

                        snprintf(CUR_AD, "%-7s:", slot);

[4.211531]

[4.211588]

                        snprintf(buf, sizeof buf, "%-7s:", slot);

Replacement in crawl-ref/source/output.cc at line 799 [3.1088282]

B:BD[4.211645] → [4.211645:211698]

                    snprintf(CUR_AD, "%-7s:", slot);

[4.211645]

[4.211698]

                    snprintf(buf, sizeof buf, "%-7s:", slot);

Insertion in crawl-ref/source/output.cc at line 802 [3.1088282]
[4.211730]
[4.211730]
```
            cols.add_formatted(1, buf, false);
```

Replacement in crawl-ref/source/output.cc at line 806 [3.1088282]

B:BD[4.211747] → [5.360366:360390]

∅:D[5.360390] → [4.211763:212608]

B:BD[4.211763] → [4.211763:212608]

    lines = 24 * 2 + 1;
    snprintf(CUR_AD, "See Invis. : %s", 
            itosym1( player_see_invis(calc_unid) ) );
    snprintf(CUR_AD, "Warding    : %s", 
            itosym1( wearing_amulet(AMU_WARDING, calc_unid)
                     || (you.religion == GOD_VEHUMET && 
                         you.duration[DUR_PRAYER] && 
                         !player_under_penance() &&
                         you.piety >= 75) ) );
    snprintf(CUR_AD, "Conserve   : %s", 
            itosym1( wearing_amulet( AMU_CONSERVATION, calc_unid) ) );
    snprintf(CUR_AD, "Res.Corr.  : %s", 
            itosym1( wearing_amulet( AMU_RESIST_CORROSION, calc_unid) ) );
    
    if ( !wearing_amulet( AMU_THE_GOURMAND, calc_unid) )
    {
        switch (you.species)
        {
        case SP_GHOUL:
            snprintf(CUR_AD, "Saprovore  : %s", itosym3(3) );
            break;

[4.211747]

[4.212608]

    const int rinvi = player_see_invis(calc_unid);
    const int rward = wearing_amulet(AMU_WARDING, calc_unid) ||
        (you.religion == GOD_VEHUMET && you.duration[DUR_PRAYER] &&
         !player_under_penance() && you.piety >= 75);
    const int rcons = wearing_amulet(AMU_CONSERVATION, calc_unid);
    const int rcorr = wearing_amulet(AMU_RESIST_CORROSION, calc_unid);

Replacement in crawl-ref/source/output.cc at line 813 [3.1088282]

B:BD[4.212609] → [4.212609:212737]

        case SP_KOBOLD:
        case SP_TROLL:
            snprintf(CUR_AD, "Saprovore  : %s", itosym3(2) );
            break;

[4.212609]

[4.212737]

    snprintf(buf, sizeof buf, "\n\n"
             "See Invis. : %s%s\n"
             "Warding    : %s%s\n"
             "Conserve   : %s%s\n"
             "Res.Corr.  : %s%s\n",
             determine_color_string(rinvi), itosym1(rinvi),
             determine_color_string(rward), itosym1(rward),
             determine_color_string(rcons), itosym1(rcons),
             determine_color_string(rcorr), itosym1(rcorr));
    cols.add_formatted(2, buf, false);    
             
    int saplevel = 0;
    switch (you.species)
    {            
    case SP_GHOUL:
        saplevel = 3;
        snprintf(buf, sizeof buf, "Saprovore  : %s%s",
                 determine_color_string(3), itosym3(3) );
        break;

Replacement in crawl-ref/source/output.cc at line 833 [3.1088282]

B:BD[4.212738] → [4.212738:212867]

        case SP_HILL_ORC:
        case SP_OGRE:
            snprintf(CUR_AD, "Saprovore  : %s", itosym3(1) );
            break;

[4.212738]

[5.360391]

    case SP_KOBOLD:
    case SP_TROLL:
        saplevel = 2;
        snprintf(buf, sizeof buf, "Saprovore  : %s%s",
                 determine_color_string(2), itosym3(2) );
        break;

Replacement in crawl-ref/source/output.cc at line 840 [3.1088282]

∅:D[5.360392] → [4.212995:213103]

B:BD[4.212995] → [4.212995:213103]

        default:
            snprintf(CUR_AD, "Gourmand   : %s", itosym1(0) );
            break;
        }

[5.360392]

[4.213103]

    case SP_HILL_ORC:
    case SP_OGRE:
        saplevel = 1;
        break;
    default:
        saplevel = 0;
        break;
    }
    const char* pregourmand;
    const char* postgourmand;
    if ( wearing_amulet(AMU_THE_GOURMAND, calc_unid) )
    {
        pregourmand = "Gourmand   : ";
        postgourmand = itosym1(1);
        saplevel = 1;

Replacement in crawl-ref/source/output.cc at line 858 [3.1088282]

B:BD[4.213124] → [4.213124:213244]

        snprintf(CUR_AD, "Gourmand   : %s", 
                itosym1( wearing_amulet( AMU_THE_GOURMAND, calc_unid) ) );

[4.213124]

[4.213244]

        pregourmand = "Saprovore  : ";
        postgourmand = itosym3(saplevel);

Replacement in crawl-ref/source/output.cc at line 861 [3.1088282]

B:BD[4.213250] → [4.213250:213268]

    
    lines++;

[4.213250]

[4.213268]

    snprintf(buf, sizeof buf, "%s%s%s", pregourmand,
             determine_color_string(saplevel), postgourmand);
    cols.add_formatted(2, buf, false);
    cols.add_formatted(2, " \n", false);

Replacement in crawl-ref/source/output.cc at line 868 [3.1088282]

B:BD[4.213332] → [4.213332:213455]

        snprintf(CUR_AD, "Prev.Telep.: %s", 
            itosym1( scan_randarts(RAP_PREVENT_TELEPORTATION, calc_unid) ) );

[4.213332]

[4.213455]

        snprintf(buf, sizeof buf, "Prev.Telep.: %s%s",
                 determine_color_string(-1), itosym1(1));

Replacement in crawl-ref/source/output.cc at line 871 [3.1088282]

B:BD[4.213464] → [4.213464:213603]

B:BD[4.213603] → [5.360393:360448]

∅:D[5.360448] → [4.213666:213873]

B:BD[4.213666] → [4.213666:213873]

        snprintf(CUR_AD, "Rnd.Telep. : %s", 
            itosym1( player_teleport(calc_unid) ) );
    snprintf(CUR_AD, "Ctrl.Telep.: %s", 
	     itosym1( player_control_teleport(calc_unid) ) );
    snprintf(CUR_AD, "Levitation : %s", itosym1( player_is_levitating() ) );
    snprintf(CUR_AD, "Ctrl.Flight: %s", 
            itosym1( wearing_amulet(AMU_CONTROLLED_FLIGHT, calc_unid) ) ); 
    lines++;

[4.213464]

[4.213873]

    {
        const int rrtel = player_teleport(calc_unid);
        snprintf(buf, sizeof buf, "Rnd.Telep. : %s%s",
                 determine_color_string(rrtel), itosym1(rrtel));
    }
    cols.add_formatted(2, buf, false);
    const int rctel = player_control_teleport(calc_unid);
    const int rlevi = player_is_levitating();
    const int rcfli = wearing_amulet(AMU_CONTROLLED_FLIGHT, calc_unid);
    snprintf(buf, sizeof buf,
             "Ctrl.Telep.: %s%s\n"
             "Levitation : %s%s\n"
             "Ctrl.Flight: %s%s\n",
             determine_color_string(rctel), itosym1(rctel),
             determine_color_string(rlevi), itosym1(rlevi),
             determine_color_string(rcfli), itosym1(rcfli));
    cols.add_formatted(2, buf, false);

Replacement in crawl-ref/source/output.cc at line 890 [3.1088282]
B:BD[4.213874] → [4.213874:213886]
```
    return;
```
[4.213874]
[4.213886]
```
    return cols.formatted_lines();
```

Insertion in crawl-ref/source/notes.h at line 56 [5.368326]

[5.370032]

    std::string describe( bool when = true, bool where = true,
                          bool what = true ) const;

Deletion in crawl-ref/source/notes.h at line 61 [5.368326]
B:BD[5.370072] → [5.370072:370119]
```
std::string describe_note( const Note& note );
```

Replacement in crawl-ref/source/notes.cc at line 229 [5.370339]

B:BD[5.376369] → [5.376369:376446]

std::string describe_note( const Note& note ) {
    char buf[200], buf2[50];

[5.376369]

[5.376446]

std::string Note::describe( bool when, bool where, bool what ) const {

Replacement in crawl-ref/source/notes.cc at line 231 [5.370339]

B:BD[5.376447] → [5.376447:379393]

    switch ( note.type ) {
    case NOTE_HP_CHANGE:
        // [ds] Shortened HP change note from "Had X hitpoints" to accommodate
        // the cause for the loss of hitpoints.
	snprintf(buf, sizeof buf, "HP: %d/%d [%s]", 
                note.first, note.second, note.name.c_str());
	break;
    case NOTE_MP_CHANGE:
	snprintf(buf, sizeof buf, "Mana: %d/%d", note.first, note.second);
	break;
    case NOTE_MAXHP_CHANGE:
	snprintf(buf, sizeof buf, "Reached %d max hit points", note.first);
	break;
    case NOTE_MAXMP_CHANGE:
	snprintf(buf, sizeof buf, "Reached %d max mana", note.first);
	break;
    case NOTE_XP_LEVEL_CHANGE:
	snprintf(buf, sizeof buf, "Reached XP level %d. %s", note.first, 
                 note.name.c_str());
	break;
    case NOTE_DUNGEON_LEVEL_CHANGE:
	snprintf(buf, sizeof buf, "Entered %s",
		place_name(note.packed_place, true, true).c_str());
	break;
    case NOTE_LEARN_SPELL:
	snprintf(buf, sizeof buf, "Learned a level %d spell: %s",
		spell_difficulty(note.first), spell_title(note.first));
	break;
    case NOTE_GET_GOD:
	snprintf(buf, sizeof buf, "Became a worshipper of %s",
		god_name(note.first, true));
	break;
    case NOTE_LOSE_GOD:
	snprintf(buf, sizeof buf, "Fell from the grace of %s",
		god_name(note.first));
	break;
    case NOTE_GOD_GIFT:
	snprintf(buf, sizeof buf, "Received a gift from %s",
		god_name(note.first));
	break;
    case NOTE_ID_ITEM:
        if (note.desc.length() > 0)
            snprintf(buf, sizeof buf, "Identified %s (%s)", note.name.c_str(),
                    note.desc.c_str());
        else
	    snprintf(buf, sizeof buf, "Identified %s", note.name.c_str());
	break;
    case NOTE_GET_ITEM:
	snprintf(buf, sizeof buf, "Got %s", note.name.c_str());
	break;
    case NOTE_GAIN_SKILL:
	snprintf(buf, sizeof buf, "Reached skill %d in %s",
		note.second, skill_name(note.first));
	break;
    case NOTE_SEEN_MONSTER:
        snprintf(buf, sizeof buf, "Noticed %s", note.name.c_str() );
	break;
    case NOTE_KILL_MONSTER:
        snprintf(buf, sizeof buf, "Defeated %s", note.name.c_str());
	break;
    case NOTE_POLY_MONSTER:
        snprintf(buf, sizeof buf, "%s changed form", note.name.c_str() );
	break;
    case NOTE_GOD_POWER:
	snprintf(buf, sizeof buf, "Acquired %s's %s power", 
                god_name(note.first),
		number_to_ordinal(real_god_power(note.first, note.second)+1));
	break;
    case NOTE_GET_MUTATION:
	snprintf(buf, sizeof buf, "Gained mutation: %s",
		mutation_name(note.first, note.second == 0 ? 1 : note.second));
	break;
    case NOTE_LOSE_MUTATION:
	snprintf(buf, sizeof buf, "Lost mutation: %s",
		mutation_name(note.first,
			      note.second == 3 ? 3 : note.second+1));
	break;
    case NOTE_USER_NOTE:
	snprintf(buf, sizeof buf, "%s", note.name.c_str());
	break;
    case NOTE_MESSAGE:
	snprintf(buf, sizeof buf, "%s", note.name.c_str());
	break;
    default:
	snprintf(buf, sizeof buf, "Buggy note description: unknown note type");
	break;

[5.376447]

[5.379393]

    std::string result;
    if ( when )
    {
        char buf[20];
        snprintf(buf, sizeof buf, "| %5ld ", turn );
        result += buf;

Replacement in crawl-ref/source/notes.cc at line 239 [5.370339]

B:BD[5.379399] → [5.379399:379661]

    snprintf(buf2, sizeof buf2, "| %5ld | ", note.turn );
    std::string placename = short_place_name(note.packed_place);
    while ( placename.length() < 7 )
	placename += ' ';
    return std::string(buf2) + placename + std::string(" | ") +
	std::string(buf);

[5.379399]

[5.379661]

    if ( where )
    {
        result += "| ";
        std::string placename = short_place_name(packed_place);
        while ( placename.length() < 7 )
            placename += ' ';
        result += placename;
        result += " | ";
    }
    if ( what )
    {
        char buf[200];
        switch ( type ) {
        case NOTE_HP_CHANGE:
            // [ds] Shortened HP change note from "Had X hitpoints" to
            // accommodate the cause for the loss of hitpoints.
            snprintf(buf, sizeof buf, "HP: %d/%d [%s]", 
                     first, second, name.c_str());
            break;
        case NOTE_MP_CHANGE:
            snprintf(buf, sizeof buf, "Mana: %d/%d", first, second);
            break;
        case NOTE_MAXHP_CHANGE:
            snprintf(buf, sizeof buf, "Reached %d max hit points", first);
            break;
        case NOTE_MAXMP_CHANGE:
            snprintf(buf, sizeof buf, "Reached %d max mana", first);
            break;
        case NOTE_XP_LEVEL_CHANGE:
            snprintf(buf, sizeof buf, "Reached XP level %d. %s", first, 
                     name.c_str());
            break;
        case NOTE_DUNGEON_LEVEL_CHANGE:
            snprintf(buf, sizeof buf, "Entered %s",
                     place_name(packed_place, true, true).c_str());
            break;
        case NOTE_LEARN_SPELL:
            snprintf(buf, sizeof buf, "Learned a level %d spell: %s",
                     spell_difficulty(first), spell_title(first));
            break;
        case NOTE_GET_GOD:
            snprintf(buf, sizeof buf, "Became a worshipper of %s",
                     god_name(first, true));
            break;
        case NOTE_LOSE_GOD:
            snprintf(buf, sizeof buf, "Fell from the grace of %s",
                     god_name(first));
            break;
        case NOTE_GOD_GIFT:
            snprintf(buf, sizeof buf, "Received a gift from %s",
                     god_name(first));
            break;
        case NOTE_ID_ITEM:
            if (desc.length() > 0)
                snprintf(buf, sizeof buf, "Identified %s (%s)",
                         name.c_str(), desc.c_str());
            else
                snprintf(buf, sizeof buf, "Identified %s", name.c_str());
            break;
        case NOTE_GET_ITEM:
            snprintf(buf, sizeof buf, "Got %s", name.c_str());
            break;
        case NOTE_GAIN_SKILL:
            snprintf(buf, sizeof buf, "Reached skill %d in %s",
                     second, skill_name(first));
            break;
        case NOTE_SEEN_MONSTER:
            snprintf(buf, sizeof buf, "Noticed %s", name.c_str() );
            break;
        case NOTE_KILL_MONSTER:
            snprintf(buf, sizeof buf, "Defeated %s", name.c_str());
            break;
        case NOTE_POLY_MONSTER:
            snprintf(buf, sizeof buf, "%s changed form", name.c_str() );
            break;
        case NOTE_GOD_POWER:
            snprintf(buf, sizeof buf, "Acquired %s's %s power", 
                     god_name(first),
                     number_to_ordinal(real_god_power(first, second)+1));
            break;
        case NOTE_GET_MUTATION:
            snprintf(buf, sizeof buf, "Gained mutation: %s",
                     mutation_name(first, second == 0 ? 1 : second));
            break;
        case NOTE_LOSE_MUTATION:
            snprintf(buf, sizeof buf, "Lost mutation: %s",
                     mutation_name(first, second == 3 ? 3 : second+1));
            break;
        case NOTE_USER_NOTE:
            snprintf(buf, sizeof buf, "%s", name.c_str());
            break;
        case NOTE_MESSAGE:
            snprintf(buf, sizeof buf, "%s", name.c_str());
            break;
        default:
            snprintf(buf, sizeof buf,
                     "Buggy note description: unknown note type");
            break;
        }
        result += buf;
    }
    return result;

Insertion in crawl-ref/source/menu.h at line 420 [4.255942]
[2.17078]
[2.17078]
```
    formatted_scroller() {}
```

Insertion in crawl-ref/source/menu.h at line 422 [4.255942]

[2.17135]

    virtual void add_item_formatted_string(const formatted_string& s);
    virtual void add_item_string(const std::string& s);
    virtual void add_text(const std::string& s);
    virtual ~formatted_scroller();

Insertion in crawl-ref/source/menu.cc at line 1278 [4.261322]

[2.17421]

{
    add_text(s);
}
void formatted_scroller::add_text(const std::string& s)

Replacement in crawl-ref/source/menu.cc at line 1287 [4.261322]

B:BD[2.17471] → [2.17471:17597]

        const size_t newpos = s.find( EOL, eolpos );
        add_entry(new MenuEntry(std::string(s, eolpos, newpos-eolpos)));

[2.17471]

[2.17597]

        const size_t newpos = s.find( "\n", eolpos );
        add_item_formatted_string(formatted_string::parse_string(std::string(s, eolpos, newpos-eolpos)));

Replacement in crawl-ref/source/menu.cc at line 1292 [4.261322]

B:BD[2.17672] → [2.17672:17715]

∅:D[2.17715] → [5.582739:582745]

B:BD[5.582739] → [5.582739:582745]

            eolpos = newpos + strlen(EOL);
    }

[2.17672]

[2.17716]

            eolpos = newpos + 1;
    }    
}
void formatted_scroller::add_item_formatted_string(const formatted_string& fs)
{
    MenuEntry* me = new MenuEntry;
    me->data = new formatted_string(fs);
    add_entry(me);
}
void formatted_scroller::add_item_string(const std::string& s)
{
    add_entry( new MenuEntry(s) );

Replacement in crawl-ref/source/menu.cc at line 1310 [4.261322]

B:BD[2.17794] → [2.17794:17850]

    formatted_string::parse_string(me->text).display();

[2.17794]

[5.582745]

    if ( me->data == NULL )
        Menu::draw_index_item(index, me);
    else
        static_cast<formatted_string*>(me->data)->display();
}
formatted_scroller::~formatted_scroller()
{
    // very important: this destructor is called *before* the
    // base (Menu) class destructor...which is at it should be.
    for ( unsigned i = 0; i < items.size(); ++i )
        if ( items[i]->data != NULL )
            delete static_cast<formatted_string*>(items[i]->data);

Replacement in crawl-ref/source/menu.cc at line 1355 [4.261322]
B:BD[2.18668] → [2.18668:18708]
```
                s.replace(loc, 1, EOL);
```
[2.18668]
[2.18708]
```
                s.replace(loc, 1, "\n");
```
Replacement in crawl-ref/source/menu.cc at line 1362 [4.261322]
B:BD[2.18860] → [2.18860:18896]
```
                s.insert(loc, EOL);
```
[2.18860]
[2.18896]
```
                s.insert(loc, "\n");
```
Insertion in crawl-ref/source/initfile.h at line 23 [3.2956146]
[5.784916]
[3.2956476]
```
const char* colour_to_str( unsigned char colour );
```

Insertion in crawl-ref/source/initfile.cc at line 52 [3.2957258]

[4.391347]

[3.2959142]

}
const std::string cols[16] =
{
    "black", "blue", "green", "cyan", "red", "magenta", "brown",
    "lightgrey", "darkgrey", "lightblue", "lightgreen", "lightcyan",
    "lightred", "lightmagenta", "yellow", "white"
};
const char* colour_to_str(unsigned char colour)
{
    if ( colour >= 16 )
        return "lightgrey";
    else
        return cols[colour].c_str();

Deletion in crawl-ref/source/initfile.cc at line 74 [3.2957258]

B:BD[3.2959259] → [3.2959259:2959502]

    const std::string cols[16] =
    {
        "black", "blue", "green", "cyan", "red", "magenta", "brown",
        "lightgrey", "darkgrey", "lightblue", "lightgreen", "lightcyan",
        "lightred", "lightmagenta", "yellow", "white"
    };

Insertion in crawl-ref/source/enum.h at line 648 [3.3287960]
[5.906435]
[5.906435]
```
    CMD_DISPLAY_NOTES,
```
Insertion in crawl-ref/source/chardump.h at line 25 [3.4099583]
[5.1207316]
[5.1207316]
```
void display_notes();
```
Replacement in crawl-ref/source/chardump.cc at line 493 [3.4100336]
B:BD[4.544838] → [5.1214327:1214354]
∅:D[5.1214354] → [4.544865:544953]
B:BD[4.544865] → [4.544865:544953]
```
    char buffer[24*3][45];
    char str_pass[80];
    char* ptr_n;
    get_full_detail(&buffer[0][0], calc_unid);
```
[4.544838]
[4.544953]
```
    std::vector<formatted_string> vfs = get_full_detail(calc_unid);
```
Replacement in crawl-ref/source/chardump.cc at line 495 [3.4100336]
B:BD[4.544954] → [5.1214355:1214388]
```
    for (int i = 0; i < 24; i++)
```
[4.544954]
[4.544987]
```
    for (unsigned int i = 0; i < vfs.size(); i++)
```

Replacement in crawl-ref/source/chardump.cc at line 497 [3.4100336]

B:BD[4.544993] → [4.544993:545024]

B:BD[4.545024] → [5.1214389:1214449]

∅:D[5.1214449] → [4.545088:545237]

B:BD[4.545088] → [4.545088:545237]

B:BD[4.545237] → [5.1214450:1214520]

∅:D[5.1214520] → [4.545308:545457]

B:BD[4.545308] → [4.545308:545457]

B:BD[4.545457] → [5.1214521:1214593]

∅:D[5.1214593] → [4.545528:545631]

B:BD[4.545528] → [4.545528:545631]

B:BD[4.545631] → [5.1214594:1214616]

        ptr_n = &buffer[i][0];
        if (buffer[i+24][0] == 0 && buffer[i+24*2][0] == 0)
            snprintf(&str_pass[0], 45, "%s", ptr_n);
        else
            snprintf(&str_pass[0], 45, "%-32s", ptr_n);
        text += str_pass;
        ptr_n = &buffer[i+24][0];
        if (buffer[i+24*2][0] == 0)
            snprintf(&str_pass[0], 45, "%s", ptr_n);
        else
            snprintf(&str_pass[0], 45, "%-20s", ptr_n);
        text += str_pass;
        ptr_n = &buffer[i+24*2][0];
        if (buffer[i+24*2][0] != 0)
        {
            snprintf(&str_pass[0], 45, "%s", ptr_n);
            text += str_pass;
        }
        text += "\n";

[4.544993]

[4.545652]

        text += vfs[i];
        text += '\n';

Replacement in crawl-ref/source/chardump.cc at line 500 [3.4100336]
B:BD[4.545658] → [4.545658:545659]
B:BD[4.545659] → [5.1214617:1214640]
```
    text += "\n" "\n";
```
[4.545658]
[5.1214640]
```
    text += "\n\n";
```
Replacement in crawl-ref/source/chardump.cc at line 511 [3.4100336]
B:BD[5.1214969] → [5.1214969:1215007]
```
	text += describe_note(note_list[i]);
```
[5.1214969]
[5.1215007]
```
	text += note_list[i].describe();
```

Replacement in crawl-ref/source/chardump.cc at line 1016 [3.4100336]

B:BD[5.1218437] → [5.1218437:1218713]

static void set_resist_dump_color( const char* data ) {
    while ( *data && *data != ':' )
	++data;
    if ( *data == 0 )
	return;
    ++data;
    int pluscount = 0;
    while ( *data ) {
	if ( *data == '+' )
	    ++pluscount;
	if ( *data == 'x' )
	    --pluscount;
	++data;

[5.1218437]

[5.1218713]

void display_notes()
{
#ifdef DOS_TERM
    char dosbuffer[4000];
    gettext( 1, 1, 80, 25, dosbuffer );
    window( 1, 1, 80, 25 );
#endif
    Menu scr;
    scr.set_title( new MenuEntry("| Turn  |Location | Note"));
    for ( unsigned int i = 0; i < note_list.size(); ++i )
    {
        std::string prefix = note_list[i].describe(true, true, false);
        std::string suffix = note_list[i].describe(false, false, true);
        if ( suffix.empty() )
            continue;
        int spaceleft = get_number_of_cols() - prefix.length() - 1;
        if ( spaceleft <= 0 )
            return;
        linebreak_string(suffix, spaceleft - 4, spaceleft);
        std::vector<std::string> parts = split_string("\n", suffix);
        scr.add_entry(new MenuEntry(prefix + parts[0]));
        for ( unsigned int j = 1; j < parts.size(); ++j )
            scr.add_entry(new MenuEntry(std::string(prefix.length()-2, ' ') +
                                        std::string("| ") + parts[j]));

Replacement in crawl-ref/source/chardump.cc at line 1042 [3.4100336]

B:BD[5.1218719] → [5.1218719:1218985]

    switch ( pluscount ) {
    case 3:
    case 2:
	textcolor(LIGHTGREEN);
	break;
    case 1:
	textcolor(GREEN);
	break;
    case -1:
	textcolor(RED);
	break;
    case -2:
    case -3:
	textcolor(LIGHTRED);
	break;
    default:
	textcolor(LIGHTGREY);
	break;
    }

[5.1218719]

[5.1218985]

    scr.show();
#ifdef DOS_TERM
    puttext(1, 1, 80, 25, dosbuffer);
    window(1, 1, 80, 25);
#endif
    redraw_screen();

Replacement in crawl-ref/source/chardump.cc at line 1050 [3.4100336]
B:BD[5.1218988] → [5.1218988:1219012]
```
void resists_screen() {
```
[5.1218988]
[5.1219012]
```
void resists_screen()
{
```
Insertion in crawl-ref/source/chardump.cc at line 1057 [3.4100336]
[5.1219129]
[5.1219129]
```
    std::vector<formatted_string> vfs = get_full_detail(false);
```
Insertion in crawl-ref/source/chardump.cc at line 1059 [3.4100336]
[5.1219143]
[5.1219143]
```
    gotoxy(1,1);
```
Deletion in crawl-ref/source/chardump.cc at line 1061 [3.4100336]
B:BD[5.1219169] → [5.1219169:1219196]
```
    char buffer[24*3][45];
```

Replacement in crawl-ref/source/chardump.cc at line 1062 [3.4100336]

B:BD[5.1219201] → [5.1219201:1219643]

    get_full_detail(&buffer[0][0], false);
    for (int line = 0; line < 24; ++line ) {
	for ( int block = 0; block < 3; ++block ) {
	    const int idx = block * 24 + line;
	    if ( buffer[idx][0] ) {
		gotoxy( block == 2 ? 53 : block * 32 + 1, line+1 );
		/* FIXME - hack - magic number 14 */
		if ( block != 0 && line < 14 )
		    set_resist_dump_color(buffer[idx]);		    
		cprintf("%s", buffer[idx] );
		textcolor(LIGHTGREY);
	    }
	}

[5.1219201]

[5.1219643]

    formatted_scroller scr;
    for ( unsigned i = 0; i < vfs.size(); ++i )
    {
        scr.add_item_formatted_string(vfs[i]);

Replacement in crawl-ref/source/chardump.cc at line 1067 [3.4100336]
B:BD[5.1219649] → [5.1219649:1219663]
```
    getch();
```
[5.1219649]
[5.1219663]
```
    scr.show();
```
Deletion in crawl-ref/source/chardump.cc at line 1072 [3.4100336]
B:BD[5.1219750] → [5.1219750:1219751]
Replacement in crawl-ref/source/acr.cc at line 842 [3.4397395]
B:BD[3.4419970] → [5.1259182:1259239]
```
    /* you.paralysis check */
    if ( you.paralysis ) {
```
[3.4419970]
[5.1259239]
```
    if ( you.paralysis )
    {
```
Replacement in crawl-ref/source/acr.cc at line 854 [3.4397395]
B:BD[3.4420168] → [5.1259351:1259382]
```
    if ( you_are_delayed() ) {
```
[3.4420168]
[5.1259382]
```
    if ( you_are_delayed() )
    {
```
Replacement in crawl-ref/source/acr.cc at line 860 [3.4397395]
B:BD[3.4420414] → [5.1259429:1259496]
```
    /* Change from previous code! */
    if ( you.turn_is_over ) {
```
[3.4420414]
[5.1259496]
```
    if ( you.turn_is_over )
    {
```

Insertion in crawl-ref/source/acr.cc at line 1042 [3.4397395]

[5.1265330]

[3.4427517]

        break;
    case CMD_DISPLAY_NOTES:
        display_notes();

Insertion in crawl-ref/source/acr.cc at line 2353 [3.4397395]
[5.1274748]
[5.1274748]
```
    case '_': return CMD_DISPLAY_NOTES;
```

Redid how the resists screen works (both in-game and in-dump.)

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/overmap.cc at line 130 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 141 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 152 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 158 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 164 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 204 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 210 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 228 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 241 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 246 [3.1070017]

Replacement in crawl-ref/source/overmap.cc at line 276 [3.1070017]

Insertion in crawl-ref/source/output.h at line 16 [3.1087719]

Replacement in crawl-ref/source/output.h at line 28 [3.1087719]

Insertion in crawl-ref/source/output.cc at line 26 [3.1088282]

Replacement in crawl-ref/source/output.cc at line 555 [3.1088282]

Replacement in crawl-ref/source/output.cc at line 557 [3.1088282]

Replacement in crawl-ref/source/output.cc at line 560 [3.1088282]

Replacement in crawl-ref/source/output.cc at line 562 [3.1088282]