fiddlerwoaroof/crawl - Change 2BGXBH5OMEFAX2XTS2OWIRODUGW6V2FJR4QRJIQTV4C2WIJI22BQC

Move monster_pane_info out into mon-info.cc and rename.

I plan to use monster_info to get monster data out to the player safely via Lua.

Created by Robert Vollmert on October 27, 2009

2BGXBH5OMEFAX2XTS2OWIRODUGW6V2FJR4QRJIQTV4C2WIJI22BQC

Dependencies

In channels

main

Change contents

Deletion in crawl-ref/source/output.h at line 62 [7.1087719]

∅:D[5.2598] → [6.500:501]

B:BD[6.500] → [6.500:501]

B:BD[8.2633] → [8.2633:2898]

B:BD[8.2898] → [9.2571:2698]


// Monster info used by the pane; precomputes some data
// to help with sorting and rendering.
class monster_pane_info
{
 public:
    static bool less_than(const monster_pane_info& m1,
                          const monster_pane_info& m2, bool zombified = true);
    static bool less_than_wrapper(const monster_pane_info& m1,
                                  const monster_pane_info& m2);

Deletion in crawl-ref/source/output.h at line 63 [7.1087719]
∅:D[9.2699] → [8.2898:2940]
B:BD[8.2898] → [8.2898:2940]
```
    monster_pane_info(const monsters* m);
```

Deletion in crawl-ref/source/output.h at line 64 [7.1087719]

B:BD[8.2941] → [8.2941:3207]

B:BD[7.1088247] → [8.3208:3209]

    void to_string(int count, std::string& desc, int& desc_color) const;
    const monsters* m_mon;
    mon_attitude_type m_attitude;
    int m_difficulty;
    int m_brands;
    bool m_fullname;
};
void get_monster_pane_info(std::vector<monster_pane_info>& mons);

Insertion in crawl-ref/source/output.cc at line 37 [7.1088282]
[10.2587]
[11.2525]
```
#include "mon-info.h"
```

Replacement in crawl-ref/source/output.cc at line 1085 [7.1088282]

B:BD[12.2922] → [13.2735:2800]

static std::string _get_monster_name(const monster_pane_info& m,

[12.2922]

[13.2800]

static std::string _get_monster_name(const monster_info& m,

Replacement in crawl-ref/source/output.cc at line 1153 [7.1088282]

B:BD[13.3564] → [13.3564:3638]

    std::vector<monster_pane_info> mons;
    get_monster_pane_info(mons);

[13.3564]

[12.4734]

    std::vector<monster_info> mons;
    get_monster_info(mons);

Replacement in crawl-ref/source/output.cc at line 1166 [7.1088282]

B:BD[12.5391] → [13.3824:3903]

    std::sort(mons.begin(), mons.end(), monster_pane_info::less_than_wrapper);

[12.5391]

[13.3903]

    std::sort(mons.begin(), mons.end(), monster_info::less_than_wrapper);

Replacement in crawl-ref/source/output.cc at line 1172 [7.1088282]

B:BD[12.5551] → [13.3995:4066]

        if (i > 0 && monster_pane_info::less_than(mons[i-1], mons[i]))

[12.5551]

[12.5620]

        if (i > 0 && monster_info::less_than(mons[i-1], mons[i]))

Deletion in crawl-ref/source/output.cc at line 1193 [7.1088282]

B:BD[12.7068] → [12.7068:7071]

B:BD[10.2771] → [8.3218:3274]

B:BD[8.3274] → [14.2595:2689]

∅:D[14.2689] → [10.2891:2893]

∅:D[8.3289] → [10.2891:2893]

B:BD[10.2891] → [10.2891:2893]

B:BD[10.2893] → [8.3290:3569]

∅:D[8.3569] → [10.3814:3815]

B:BD[10.3814] → [10.3814:3815]

B:BD[10.3815] → [15.2659:2684]

B:BD[15.2684] → [13.4225:4262]

∅:D[13.4262] → [15.2723:2755]

B:BD[15.2723] → [15.2723:2755]

B:BD[15.2755] → [16.6632:6732]

∅:D[8.3802] → [10.3888:3889]

∅:D[16.6732] → [10.3888:3889]

B:BD[10.3888] → [10.3888:3889]

B:BD[10.3889] → [14.2769:2810]

∅:D[14.2810] → [8.3821:3973]

B:BD[8.3821] → [8.3821:3973]

∅:D[8.3973] → [10.3993:3994]

B:BD[10.3993] → [10.3993:3994]

B:BD[10.3994] → [9.2701:3221]

∅:D[17.2705] → [10.4197:4238]

∅:D[9.3221] → [10.4197:4238]

B:BD[10.4197] → [10.4197:4238]

B:BD[10.4238] → [17.2706:2729]

∅:D[17.2729] → [10.4259:4303]

B:BD[10.4259] → [10.4259:4303]

B:BD[10.4303] → [18.3337:3362]

B:BD[18.3362] → [15.2883:3008]

B:BD[15.3008] → [13.4263:4301]

∅:D[13.4301] → [15.3048:3080]

B:BD[15.3048] → [15.3048:3080]

B:BD[15.3080] → [13.4302:4340]

∅:D[13.4340] → [15.3120:3153]

B:BD[15.3120] → [15.3120:3153]

∅:D[15.3153] → [18.3362:3460]

B:BD[18.3362] → [18.3362:3460]

B:BD[18.3460] → [15.3154:3320]

∅:D[15.3320] → [18.3658:3664]

B:BD[18.3658] → [18.3658:3664]

∅:D[18.3664] → [17.2730:2754]

B:BD[10.4303] → [17.2730:2754]

B:BD[17.2754] → [18.3665:3671]

∅:D[17.2754] → [10.4325:4401]

∅:D[18.3671] → [10.4325:4401]

B:BD[10.4325] → [10.4325:4401]

B:BD[10.4401] → [17.2755:2778]

∅:D[17.2778] → [10.4422:4470]

B:BD[10.4422] → [10.4422:4470]

B:BD[10.4470] → [17.2779:2803]

∅:D[17.2803] → [10.4492:4493]

B:BD[10.4492] → [10.4492:4493]

B:BD[10.4493] → [19.2551:2623]

B:BD[19.2623] → [15.3321:3377]

∅:D[15.3377] → [19.2709:2733]

B:BD[19.2709] → [19.2709:2733]

B:BD[19.2739] → [19.2739:2740]

B:BD[19.2740] → [15.3378:3403]

∅:D[15.3403] → [17.2804:2827]

B:BD[10.4534] → [17.2804:2827]

B:BD[17.2827] → [15.3404:3434]

∅:D[15.3434] → [19.2741:2889]

B:BD[10.4601] → [19.2741:2889]

B:BD[19.2889] → [15.3435:3474]

∅:D[19.2936] → [17.2828:2853]

∅:D[15.3474] → [17.2828:2853]

B:BD[10.4601] → [17.2828:2853]

B:BD[17.2853] → [20.5275:5294]

∅:D[20.5294] → [17.3081:3087]

B:BD[17.3081] → [17.3081:3087]

B:BD[17.3087] → [18.3672:3799]

∅:D[18.3799] → [20.5422:5799]

B:BD[20.5422] → [20.5422:5799]

∅:D[20.5799] → [17.3110:3116]

B:BD[17.3110] → [17.3110:3116]

∅:D[17.3116] → [10.4623:4624]

B:BD[10.4623] → [10.4623:4624]

B:BD[10.4624] → [15.3475:3546]

∅:D[19.3016] → [21.2752:2827]

∅:D[15.3546] → [21.2752:2827]

B:BD[21.2752] → [21.2752:2827]

∅:D[21.2827] → [22.2527:2567]

B:BD[10.4624] → [22.2527:2567]

∅:D[22.2567] → [10.4624:4718]

B:BD[10.4624] → [10.4624:4718]

B:BD[10.4718] → [23.17522:17545]

∅:D[23.17545] → [10.4739:4779]

B:BD[10.4739] → [10.4739:4779]

B:BD[10.4779] → [23.17546:17570]

∅:D[23.17570] → [22.2568:2575]

B:BD[10.4801] → [22.2568:2575]

∅:D[22.2575] → [10.4801:4802]

B:BD[10.4801] → [10.4801:4802]

B:BD[10.4802] → [17.3117:3137]

B:BD[17.3137] → [24.2610:3149]

B:BD[24.3149] → [25.2646:2656]

B:BD[25.2656] → [26.2847:2945]

∅:D[26.2945] → [25.2756:2819]

B:BD[25.2756] → [25.2756:2819]

B:BD[25.2819] → [2.2646:2684]

∅:D[2.2684] → [25.2857:2937]

B:BD[25.2857] → [25.2857:2937]

B:BD[25.2937] → [27.15936:16139]

∅:D[28.2673] → [24.3218:3254]

∅:D[27.16139] → [24.3218:3254]

B:BD[24.3218] → [24.3218:3254]

B:BD[24.3254] → [27.16140:16150]

∅:D[27.16150] → [24.3254:3640]

B:BD[24.3254] → [24.3254:3640]

}
monster_pane_info::monster_pane_info(const monsters *m)
    : m_mon(m), m_attitude(ATT_HOSTILE), m_difficulty(0),
      m_brands(0), m_fullname(true)
{
    // XXX: this doesn't take into account ENCH_NEUTRAL, but that's probably
    // a bug for mons_attitude, not this.
    // XXX: also, mons_attitude_type should be sorted hostile/neutral/friendly;
    // will break saves a little bit though.
    m_attitude = mons_attitude(m);
    int mtype = m->type;
    if (mtype == MONS_RAKSHASA_FAKE)
        mtype = MONS_RAKSHASA;
    // Currently, difficulty is defined as "average hp".
    m_difficulty = mons_difficulty(mtype);
    // [ds] XXX: Kill the magic numbers.
    if (mons_looks_stabbable(m))   m_brands |= 1;
    if (mons_looks_distracted(m))  m_brands |= 2;
    if (m->has_ench(ENCH_BERSERK)) m_brands |= 4;
}
// Needed because gcc 4.3 sort does not like comparison functions that take
// more than 2 arguments.
bool monster_pane_info::less_than_wrapper(const monster_pane_info& m1,
                                          const monster_pane_info& m2)
{
    return monster_pane_info::less_than(m1, m2, true);
}
// Sort monsters by (in that order):    attitude, difficulty, type, brand
bool monster_pane_info::less_than(const monster_pane_info& m1,
                                  const monster_pane_info& m2, bool zombified)
{
    if (m1.m_attitude < m2.m_attitude)
        return (true);
    else if (m1.m_attitude > m2.m_attitude)
        return (false);
    int m1type = m1.m_mon->type;
    int m2type = m2.m_mon->type;
    // Don't differentiate real rakshasas from fake ones.
    if (m1type == MONS_RAKSHASA_FAKE)
        m1type = MONS_RAKSHASA;
    if (m2type == MONS_RAKSHASA_FAKE)
        m2type = MONS_RAKSHASA;
    // Force plain but different coloured draconians to be treated like the
    // same sub-type.
    if (!zombified && m1type >= MONS_DRACONIAN
        && m1type <= MONS_PALE_DRACONIAN
        && m2type >= MONS_DRACONIAN
        && m2type <= MONS_PALE_DRACONIAN)
    {
        return (false);
    }
    // By descending difficulty
    if (m1.m_difficulty > m2.m_difficulty)
        return (true);
    else if (m1.m_difficulty < m2.m_difficulty)
        return (false);
    // Force mimics of different types to be treated like the same one.
    if (mons_is_mimic(m1type) && mons_is_mimic(m2type))
        return (false);
    if (m1type < m2type)
        return (true);
    else if (m1type > m2type)
        return (false);
    // Never distinguish between dancing weapons.
    // The above checks guarantee that *both* monsters are of this type.
    if (m1type == MONS_DANCING_WEAPON)
        return (false);
    if (zombified)
    {
        // Because of the type checks above, if one of the two is zombified, so
        // is the other, and of the same type.
        if (mons_is_zombified(m1.m_mon)
            && m1.m_mon->base_monster < m2.m_mon->base_monster)
        {
            return (true);
        }
        // Both monsters are hydras or hydra zombies, sort by number of heads.
        if (m1.m_mon->has_hydra_multi_attack()
            && m1.m_mon->number > m2.m_mon->number)
        {
            return (true);
        }
    }
    if (m1.m_fullname && m2.m_fullname || m1type == MONS_PLAYER_GHOST)
        return (m1.m_mon->name(DESC_PLAIN) < m1.m_mon->name(DESC_PLAIN));
#if 0 // for now, sort brands together.
    // By descending brands, so no brands sorts to the end
    if (m1.m_brands > m2.m_brands)
        return (true);
    else if (m1.m_brands < m2.m_brands)
        return (false);
#endif
    return (false);
}
static std::string _verbose_info(const monsters* m)
{
    if (mons_is_caught(m))
        return (" (caught)");
    if (mons_behaviour_perceptible(m))
    {
        if (mons_is_petrified(m))
            return(" (petrified)");
        if (mons_is_paralysed(m))
            return(" (paralysed)");
        if (mons_is_petrifying(m))
            return(" (petrifying)");
        if (mons_is_confused(m))
            return(" (confused)");
        if (mons_is_fleeing(m))
            return(" (fleeing)");
        if (mons_is_sleeping(m))
        {
            if (mons_holiness(m) == MH_UNDEAD
                || mons_holiness(m) == MH_NONLIVING
                || mons_holiness(m) == MH_PLANT)
            {
                return(" (dormant)");
            }
            else
                return(" (sleeping)");
        }
        if (mons_is_wandering(m) && !mons_is_batty(m)
            && !(m->attitude == ATT_STRICT_NEUTRAL))
        {
            // Labeling strictly neutral monsters as fellow slimes is more important.
            return(" (wandering)");
        }
        if (m->foe == MHITNOT && !mons_is_batty(m) && !mons_neutral(m)
            && !mons_friendly(m))
        {
            return (" (unaware)");
        }
    }
    if (m->has_ench(ENCH_STICKY_FLAME))
        return (" (burning)");
    if (m->has_ench(ENCH_ROT))
        return (" (rotting)");
    if (m->has_ench(ENCH_INVIS))
        return (" (invisible)");
    return ("");

Deletion in crawl-ref/source/output.cc at line 1194 [7.1088282]
B:BD[10.4822] → [29.3268:3269]
B:BD[29.3269] → [4.2950:3071]
∅:D[4.3071] → [10.4963:4993]
∅:D[12.7345] → [10.4963:4993]
B:BD[10.4963] → [10.4963:4993]
```
void monster_pane_info::to_string(int count, std::string& desc,
                                  int& desc_color) const
{
    std::ostringstream out;
```

Deletion in crawl-ref/source/output.cc at line 1195 [7.1088282]

∅:D[22.2577] → [10.4993:5019]

B:BD[10.4993] → [10.4993:5019]

B:BD[10.5019] → [30.2659:2772]

B:BD[30.2772] → [31.2513:2562]

∅:D[31.2562] → [10.5075:5096]

∅:D[22.2634] → [10.5075:5096]

∅:D[21.2969] → [10.5075:5096]

B:BD[10.5075] → [10.5075:5096]

B:BD[10.5096] → [32.2668:3009]

B:BD[32.3009] → [4.3072:3200]

∅:D[4.3200] → [32.3087:3115]

B:BD[19.3169] → [32.3087:3115]

∅:D[32.3115] → [19.3192:3242]

B:BD[19.3192] → [19.3192:3242]

B:BD[19.3242] → [18.3879:3936]

B:BD[18.3936] → [4.3201:3298]

∅:D[4.3298] → [33.3086:3166]

∅:D[18.3936] → [33.3086:3166]

B:BD[19.3242] → [33.3086:3166]

∅:D[33.3166] → [17.3138:3148]

∅:D[19.3286] → [17.3138:3148]

B:BD[21.2994] → [17.3138:3148]

∅:D[17.3148] → [21.2994:3081]

B:BD[21.2994] → [21.2994:3081]

B:BD[21.3081] → [17.3149:3159]

B:BD[17.3159] → [18.3937:4166]

∅:D[17.3159] → [21.3081:3094]

∅:D[18.4166] → [21.3081:3094]

B:BD[21.3081] → [21.3081:3094]

B:BD[21.3094] → [17.3160:3170]

∅:D[17.3170] → [21.3094:3197]

B:BD[21.3094] → [21.3094:3197]

B:BD[21.3197] → [17.3171:3181]

∅:D[17.3181] → [10.5191:5330]

∅:D[21.3197] → [10.5191:5330]

B:BD[10.5191] → [10.5191:5330]

B:BD[10.5330] → [22.2635:2655]

∅:D[22.2655] → [10.5665:5671]

B:BD[10.5665] → [10.5665:5671]

B:BD[10.5671] → [22.2656:2732]

B:BD[22.2732] → [24.3641:3729]

∅:D[24.3729] → [22.2732:2975]

B:BD[22.2732] → [22.2732:2975]

∅:D[22.2975] → [10.5896:6051]

B:BD[10.5896] → [10.5896:6051]

B:BD[10.6051] → [34.7217:7244]

∅:D[34.7244] → [10.6051:6147]

B:BD[10.6051] → [10.6051:6147]

B:BD[10.6147] → [27.16151:16260]

∅:D[27.16260] → [10.6147:6233]

B:BD[10.6147] → [10.6147:6233]

B:BD[10.6233] → [35.2618:2921]

B:BD[35.2921] → [36.2618:2664]

∅:D[36.2664] → [35.2955:2993]

B:BD[35.2955] → [35.2955:2993]

∅:D[35.2993] → [10.6233:6277]

B:BD[10.6233] → [10.6233:6277]

B:BD[10.6277] → [37.2573:2576]

    if (count == 1)
    {
        if (mons_is_mimic(m_mon->type))
            out << mons_type_name(m_mon->type, DESC_PLAIN);
        else
            out << m_mon->full_name(DESC_PLAIN);
    }
    else
    {
        // Don't pluralise uniques, ever.  Multiple copies of the same unique
        // are unlikely in the dungeon currently, but quite common in the
        // arena.  This prevens "4 Gra", etc. {due}
        if (mons_is_unique(m_mon->type))
        {
            out << count << " "
                << m_mon->name(DESC_PLAIN);
        }
        // Don't differentiate between dancing weapons, mimics, (very)
        // ugly things or draconians of different types.
        else if (m_fullname
            && m_mon->type != MONS_DANCING_WEAPON
            && mons_genus(m_mon->type) != MONS_DRACONIAN
            && m_mon->type != MONS_UGLY_THING
            && m_mon->type != MONS_VERY_UGLY_THING
            && !mons_is_mimic(m_mon->type)
            && m_mon->mname.empty())
        {
            out << count << " "
                << pluralise(m_mon->name(DESC_PLAIN));
        }
        else if (m_mon->type >= MONS_DRACONIAN
                 && m_mon->type <= MONS_PALE_DRACONIAN)
        {
            out << count << " "
                << pluralise(mons_type_name(MONS_DRACONIAN, DESC_PLAIN));
        }
        else
        {
            out << count << " "
                << pluralise(mons_type_name(m_mon->type, DESC_PLAIN));
        }
    }
#if DEBUG_DIAGNOSTICS
    out << " av" << m_difficulty << " "
        << m_mon->hit_points << "/" << m_mon->max_hit_points;
#endif
    if (count == 1)
    {
        if (m_mon->has_ench(ENCH_BERSERK))
            out << " (berserk)";
        else if (Options.verbose_monster_pane)
            out << _verbose_info(m_mon);
        else if (mons_looks_stabbable(m_mon))
            out << " (resting)";
        else if (mons_looks_distracted(m_mon))
            out << " (distracted)";
        else if (m_mon->has_ench(ENCH_INVIS))
            out << " (invisible)";
    }
    // Friendliness
    switch (m_attitude)
    {
    case ATT_FRIENDLY:
        //out << " (friendly)";
        desc_color = GREEN;
        break;
    case ATT_GOOD_NEUTRAL:
    case ATT_NEUTRAL:
        //out << " (neutral)";
        desc_color = BROWN;
        break;
    case ATT_STRICT_NEUTRAL:
         out << " (fellow slime)";
         desc_color = BROWN;
         break;
    case ATT_HOSTILE:
        // out << " (hostile)";
        desc_color = LIGHTGREY;
        break;
    }
    // Evilness of attacking
    switch (m_attitude)
    {
    case ATT_NEUTRAL:
    case ATT_HOSTILE:
        if (count == 1 && you.religion == GOD_SHINING_ONE
            && !tso_unchivalric_attack_safe_monster(m_mon)
            && is_unchivalric_attack(&you, m_mon))
        {
            desc_color = Options.evil_colour;
        }
        break;
    default:
        break;
    }
    desc = out.str();
}

Replacement in crawl-ref/source/output.cc at line 1214 [7.1088282]

B:BD[10.6280] → [8.3974:4055]

static void _print_next_monster_desc(const std::vector<monster_pane_info>& mons,

[10.6280]

[8.4055]

static void _print_next_monster_desc(const std::vector<monster_info>& mons,

Replacement in crawl-ref/source/output.cc at line 1223 [7.1088282]

B:BD[5.3226] → [17.3362:3439]

        if (monster_pane_info::less_than(mons[start], mons[end], zombified))

[5.3226]

[10.6656]

        if (monster_info::less_than(mons[start], mons[end], zombified))

Deletion in crawl-ref/source/output.cc at line 1327 [7.1088282]

B:BD[10.7608] → [8.4392:4459]

B:BD[8.4459] → [38.2660:2720]

∅:D[38.2720] → [8.4536:4632]

B:BD[8.4536] → [8.4536:4632]

B:BD[8.4632] → [3.3104:3228]

∅:D[3.3228] → [8.4700:4785]

B:BD[8.4700] → [8.4700:4785]

B:BD[8.4785] → [9.3222:3301]

∅:D[9.3301] → [8.4856:4859]

B:BD[8.4856] → [8.4856:4859]

void get_monster_pane_info(std::vector<monster_pane_info>& mons)
{
    std::vector<monsters*> visible = get_nearby_monsters();
    for (unsigned int i = 0; i < visible.size(); i++)
    {
        if (Options.target_zero_exp
            || !mons_class_flag( visible[i]->type, M_NO_EXP_GAIN )
            || visible[i]->type == MONS_KRAKEN_TENTACLE)
        {
            mons.push_back(monster_pane_info(visible[i]));
        }
    }
    std::sort(mons.begin(), mons.end(), monster_pane_info::less_than_wrapper);
}

Replacement in crawl-ref/source/output.cc at line 1342 [7.1088282]

B:BD[10.7959] → [10.7959:8000]

B:BD[10.8000] → [8.4860:4893]

B:BD[8.4893] → [9.3302:3381]

    std::vector<monster_pane_info> mons;
    get_monster_pane_info(mons);
    std::sort(mons.begin(), mons.end(), monster_pane_info::less_than_wrapper);

[10.7959]

[39.2566]

    std::vector<monster_info> mons;
    get_monster_info(mons);
    std::sort(mons.begin(), mons.end(), monster_info::less_than_wrapper);

Replacement in crawl-ref/source/output.cc at line 1349 [7.1088282]

B:BD[17.3580] → [17.3580:3643]

        if (!monster_pane_info::less_than(mons[i-1], mons[i]))

[17.3580]

[17.3643]

        if (!monster_info::less_than(mons[i-1], mons[i]))

Replacement in crawl-ref/source/output.cc at line 1363 [7.1088282]

B:BD[9.3426] → [9.3426:3483]

                  monster_pane_info::less_than_wrapper);

[9.3426]

[9.3483]

                  monster_info::less_than_wrapper);

Replacement in crawl-ref/source/output.cc at line 1367 [7.1088282]

B:BD[17.3840] → [17.3840:3914]

            if (!monster_pane_info::less_than(mons[i-1], mons[i], false))

[17.3840]

[17.3914]

            if (!monster_info::less_than(mons[i-1], mons[i], false))

File addition: mon-info.h (----------)

[40.24]

#ifndef MON_INFO_H
#define MON_INFO_H
// Monster info used by the pane; precomputes some data
// to help with sorting and rendering.
class monster_info
{
 public:
    static bool less_than(const monster_info& m1,
                          const monster_info& m2, bool zombified = true);
    static bool less_than_wrapper(const monster_info& m1,
                                  const monster_info& m2);
    monster_info(const monsters* m);
    void to_string(int count, std::string& desc, int& desc_color) const;
    const monsters* m_mon;
    mon_attitude_type m_attitude;
    int m_difficulty;
    int m_brands;
    bool m_fullname;
};
void get_monster_info(std::vector<monster_info>& mons);
#endif

File addition: mon-info.cc (----------)

[40.24]

#include "AppHdr.h"
#include "mon-info.h"
#include "fight.h"
#include "misc.h"
#include "mon-util.h"
#include "monster.h"
#include "religion.h"
#include <sstream>
enum monster_info_brands
{
    MB_STABBABLE,
    MB_DISTRACTED,
    MB_BERSERK
};
monster_info::monster_info(const monsters *m)
    : m_mon(m), m_attitude(ATT_HOSTILE), m_difficulty(0),
      m_brands(0), m_fullname(true)
{
    // XXX: this doesn't take into account ENCH_NEUTRAL, but that's probably
    // a bug for mons_attitude, not this.
    // XXX: also, mons_attitude_type should be sorted hostile/neutral/friendly;
    // will break saves a little bit though.
    m_attitude = mons_attitude(m);
    int mtype = m->type;
    if (mtype == MONS_RAKSHASA_FAKE)
        mtype = MONS_RAKSHASA;
    // Currently, difficulty is defined as "average hp".
    m_difficulty = mons_difficulty(mtype);
    if (mons_looks_stabbable(m))   m_brands |= (1 << MB_STABBABLE);
    if (mons_looks_distracted(m))  m_brands |= (1 << MB_DISTRACTED);
    if (m->has_ench(ENCH_BERSERK)) m_brands |= (1 << MB_BERSERK);
}
// Needed because gcc 4.3 sort does not like comparison functions that take
// more than 2 arguments.
bool monster_info::less_than_wrapper(const monster_info& m1,
                                          const monster_info& m2)
{
    return monster_info::less_than(m1, m2, true);
}
// Sort monsters by (in that order):    attitude, difficulty, type, brand
bool monster_info::less_than(const monster_info& m1,
                                  const monster_info& m2, bool zombified)
{
    if (m1.m_attitude < m2.m_attitude)
        return (true);
    else if (m1.m_attitude > m2.m_attitude)
        return (false);
    int m1type = m1.m_mon->type;
    int m2type = m2.m_mon->type;
    // Don't differentiate real rakshasas from fake ones.
    if (m1type == MONS_RAKSHASA_FAKE)
        m1type = MONS_RAKSHASA;
    if (m2type == MONS_RAKSHASA_FAKE)
        m2type = MONS_RAKSHASA;
    // Force plain but different coloured draconians to be treated like the
    // same sub-type.
    if (!zombified && m1type >= MONS_DRACONIAN
        && m1type <= MONS_PALE_DRACONIAN
        && m2type >= MONS_DRACONIAN
        && m2type <= MONS_PALE_DRACONIAN)
    {
        return (false);
    }
    // By descending difficulty
    if (m1.m_difficulty > m2.m_difficulty)
        return (true);
    else if (m1.m_difficulty < m2.m_difficulty)
        return (false);
    // Force mimics of different types to be treated like the same one.
    if (mons_is_mimic(m1type) && mons_is_mimic(m2type))
        return (false);
    if (m1type < m2type)
        return (true);
    else if (m1type > m2type)
        return (false);
    // Never distinguish between dancing weapons.
    // The above checks guarantee that *both* monsters are of this type.
    if (m1type == MONS_DANCING_WEAPON)
        return (false);
    if (zombified)
    {
        // Because of the type checks above, if one of the two is zombified, so
        // is the other, and of the same type.
        if (mons_is_zombified(m1.m_mon)
            && m1.m_mon->base_monster < m2.m_mon->base_monster)
        {
            return (true);
        }
        // Both monsters are hydras or hydra zombies, sort by number of heads.
        if (m1.m_mon->has_hydra_multi_attack()
            && m1.m_mon->number > m2.m_mon->number)
        {
            return (true);
        }
    }
    if (m1.m_fullname && m2.m_fullname || m1type == MONS_PLAYER_GHOST)
        return (m1.m_mon->name(DESC_PLAIN) < m1.m_mon->name(DESC_PLAIN));
#if 0 // for now, sort brands together.
    // By descending brands, so no brands sorts to the end
    if (m1.m_brands > m2.m_brands)
        return (true);
    else if (m1.m_brands < m2.m_brands)
        return (false);
#endif
    return (false);
}
static std::string _verbose_info(const monsters* m)
{
    if (mons_is_caught(m))
        return (" (caught)");
    if (mons_behaviour_perceptible(m))
    {
        if (mons_is_petrified(m))
            return(" (petrified)");
        if (mons_is_paralysed(m))
            return(" (paralysed)");
        if (mons_is_petrifying(m))
            return(" (petrifying)");
        if (mons_is_confused(m))
            return(" (confused)");
        if (mons_is_fleeing(m))
            return(" (fleeing)");
        if (mons_is_sleeping(m))
        {
            if (mons_holiness(m) == MH_UNDEAD
                || mons_holiness(m) == MH_NONLIVING
                || mons_holiness(m) == MH_PLANT)
            {
                return(" (dormant)");
            }
            else
                return(" (sleeping)");
        }
        if (mons_is_wandering(m) && !mons_is_batty(m)
            && !(m->attitude == ATT_STRICT_NEUTRAL))
        {
            // Labeling strictly neutral monsters as fellow slimes is more important.
            return(" (wandering)");
        }
        if (m->foe == MHITNOT && !mons_is_batty(m) && !mons_neutral(m)
            && !mons_friendly(m))
        {
            return (" (unaware)");
        }
    }
    if (m->has_ench(ENCH_STICKY_FLAME))
        return (" (burning)");
    if (m->has_ench(ENCH_ROT))
        return (" (rotting)");
    if (m->has_ench(ENCH_INVIS))
        return (" (invisible)");
    return ("");
}
void monster_info::to_string(int count, std::string& desc,
                                  int& desc_color) const
{
    std::ostringstream out;
    if (count == 1)
    {
        if (mons_is_mimic(m_mon->type))
            out << mons_type_name(m_mon->type, DESC_PLAIN);
        else
            out << m_mon->full_name(DESC_PLAIN);
    }
    else
    {
        // Don't pluralise uniques, ever.  Multiple copies of the same unique
        // are unlikely in the dungeon currently, but quite common in the
        // arena.  This prevens "4 Gra", etc. {due}
        if (mons_is_unique(m_mon->type))
        {
            out << count << " "
                << m_mon->name(DESC_PLAIN);
        }
        // Don't differentiate between dancing weapons, mimics, (very)
        // ugly things or draconians of different types.
        else if (m_fullname
            && m_mon->type != MONS_DANCING_WEAPON
            && mons_genus(m_mon->type) != MONS_DRACONIAN
            && m_mon->type != MONS_UGLY_THING
            && m_mon->type != MONS_VERY_UGLY_THING
            && !mons_is_mimic(m_mon->type)
            && m_mon->mname.empty())
        {
            out << count << " "
                << pluralise(m_mon->name(DESC_PLAIN));
        }
        else if (m_mon->type >= MONS_DRACONIAN
                 && m_mon->type <= MONS_PALE_DRACONIAN)
        {
            out << count << " "
                << pluralise(mons_type_name(MONS_DRACONIAN, DESC_PLAIN));
        }
        else
        {
            out << count << " "
                << pluralise(mons_type_name(m_mon->type, DESC_PLAIN));
        }
    }
#if DEBUG_DIAGNOSTICS
    out << " av" << m_difficulty << " "
        << m_mon->hit_points << "/" << m_mon->max_hit_points;
#endif
    if (count == 1)
    {
        if (m_mon->has_ench(ENCH_BERSERK))
            out << " (berserk)";
        else if (Options.verbose_monster_pane)
            out << _verbose_info(m_mon);
        else if (mons_looks_stabbable(m_mon))
            out << " (resting)";
        else if (mons_looks_distracted(m_mon))
            out << " (distracted)";
        else if (m_mon->has_ench(ENCH_INVIS))
            out << " (invisible)";
    }
    // Friendliness
    switch (m_attitude)
    {
    case ATT_FRIENDLY:
        //out << " (friendly)";
        desc_color = GREEN;
        break;
    case ATT_GOOD_NEUTRAL:
    case ATT_NEUTRAL:
        //out << " (neutral)";
        desc_color = BROWN;
        break;
    case ATT_STRICT_NEUTRAL:
         out << " (fellow slime)";
         desc_color = BROWN;
         break;
    case ATT_HOSTILE:
        // out << " (hostile)";
        desc_color = LIGHTGREY;
        break;
    }
    // Evilness of attacking
    switch (m_attitude)
    {
    case ATT_NEUTRAL:
    case ATT_HOSTILE:
        if (count == 1 && you.religion == GOD_SHINING_ONE
            && !tso_unchivalric_attack_safe_monster(m_mon)
            && is_unchivalric_attack(&you, m_mon))
        {
            desc_color = Options.evil_colour;
        }
        break;
    default:
        break;
    }
    desc = out.str();
}
void get_monster_info(std::vector<monster_info>& mons)
{
    std::vector<monsters*> visible = get_nearby_monsters();
    for (unsigned int i = 0; i < visible.size(); i++)
    {
        if (Options.target_zero_exp
            || !mons_class_flag( visible[i]->type, M_NO_EXP_GAIN )
            || visible[i]->type == MONS_KRAKEN_TENTACLE)
        {
            mons.push_back(monster_info(visible[i]));
        }
    }
    std::sort(mons.begin(), mons.end(), monster_info::less_than_wrapper);
}

Insertion in crawl-ref/source/makefile.obj at line 81 [41.79]
[41.447]
[41.460]
```
mon-info.o \
```
Insertion in crawl-ref/source/directn.cc at line 42 [7.3697945]
[7.3698760]
[7.3698760]
```
#include "mon-info.h"
```

Replacement in crawl-ref/source/directn.cc at line 519 [7.3697945]

B:BD[42.5035] → [13.4702:4924]

    // Get monsters via the monster_pane_info, sorted by difficulty.
    std::vector<monster_pane_info> mons;
    get_monster_pane_info(mons);
    std::sort(mons.begin(), mons.end(), monster_pane_info::less_than_wrapper);

[42.5035]

[13.4924]

    // Get monsters via the monster_info, sorted by difficulty.
    std::vector<monster_info> mons;
    get_monster_info(mons);
    std::sort(mons.begin(), mons.end(), monster_info::less_than_wrapper);

Replacement in crawl-ref/source/directn.cc at line 831 [7.3697945]
∅:D[43.2982] → [8.6352:6390]
B:BD[8.6352] → [8.6352:6390]
```
std::vector<monster_pane_info> mlist;
```
[43.2982]
[43.2983]
```
std::vector<monster_info> mlist;
```

Replacement in crawl-ref/source/directn.cc at line 834 [7.3697945]

B:BD[8.6429] → [8.6429:6503]

    std::vector<monster_pane_info> temp;
    get_monster_pane_info(temp);

[8.6429]

[43.3031]

    std::vector<monster_info> temp;
    get_monster_info(temp);

Replacement in crawl-ref/source/directn.cc at line 846 [7.3697945]

B:BD[43.3075] → [43.3075:3144]

            if (monster_pane_info::less_than(temp[start], temp[end],

[43.3075]

[43.3144]

            if (monster_info::less_than(temp[start], temp[end],

Replacement in crawl-ref/source/directn.cc at line 1998 [7.3697945]

B:BD[8.9030] → [43.4219:4301]

        if (!monster_pane_info::less_than(mlist[i], mlist[i+1], mlist_full_info))

[8.9030]

[8.9160]

        if (!monster_info::less_than(mlist[i], mlist[i+1], mlist_full_info))