{
            out << m_mon->name(DESC_PLAIN);
            if (!(m_mon->mname).empty() && m_mon->type != MONS_PLAYER_GHOST)
                out << " the " << mons_type_name(m_mon->type, DESC_PLAIN);
        }

            out << m_mon->full_name(DESC_PLAIN);

                                      int i)

                                      int i, bool polymorph)

    int type = monster->type;
    // Treat whatever the Royal Jelly polymorphed into as if it were still
    // the Royal Jelly.
    if (monster->mname == "shaped Royal Jelly")
        type = MONS_ROYAL_JELLY;

    if (killer != KILL_RESET)

    if (killer == KILL_RESET)

        dungeon_events.fire_event(
            dgn_event(DET_MONSTER_DIED, monster->pos(), 0,
                      monster_index(monster), killer));

        // Give player a hint that banishing the Royal Jelly means the
        // Slime:6 vaults stay locked.
        if (type == MONS_ROYAL_JELLY)
        {
            if (you.can_see(monster))
                mpr("You feel a great sense of loss.");
            else
                mpr("You feel a great sense of loss, and the brush of the "
                    "Abyss.");
        }
        return;
    }
    dungeon_events.fire_event(
        dgn_event(DET_MONSTER_DIED, monster->pos(), 0,
                  monster_index(monster), killer));

        if (monster->type == MONS_ROYAL_JELLY)

    // Don't unlock the Slime:6 vaults if the "death" was actually the
    // Royal Jelly polymorphing into something else; the player still
    // has to kill whatever it polymorphed into.
    if (type == MONS_ROYAL_JELLY && !polymorph)
    {
        const level_id target(BRANCH_SLIME_PITS, 6);
        if (is_existing_level(target))

            const level_id target(BRANCH_SLIME_PITS, 6);
            if (is_existing_level(target))
            {
                apply_to_level(
                    target,
                    true,
                    target == level_id::current() ? _slime_pit_unlock_onlevel
                                                  : _slime_pit_unlock_offlevel);
            }

            apply_to_level(
                target,
                true,
                target == level_id::current() ? _slime_pit_unlock_onlevel
                                              : _slime_pit_unlock_offlevel);

    _fire_monster_death_event(monster, killer, killer_index);

    _fire_monster_death_event(monster, killer, killer_index, false);

    ASSERT(!(monster->flags & MF_TAKING_STAIRS));
    ASSERT(!(monster->flags & MF_BANISHED) || you.level_type == LEVEL_ABYSS);

    // Inform listeners that the original monster is gone (and
    // unlock the vaults on Slime:6 if it's the Royal Jelly which
    // was changed).
    _fire_monster_death_event(monster, KILL_MISC, NON_MONSTER);

    // Inform listeners that the original monster is gone.
    _fire_monster_death_event(monster, KILL_MISC, NON_MONSTER, true);

    unsigned long flags =
        monster->flags & ~(MF_INTERESTING | MF_SEEN | MF_ATT_CHANGE_ATTEMPT
                           | MF_WAS_IN_VIEW | MF_BAND_MEMBER
                           | MF_HONORARY_UNDEAD);
    std::string name;
    // Preserve the names of uniques and named monsters.
    if (!monster->mname.empty())
        name = monster->mname;
    else if (mons_is_unique(monster->type))
    {
        flags |= MF_INTERESTING;
        name = monster->name(DESC_PLAIN, true);
        if (monster->type == MONS_ROYAL_JELLY)
        {
            name   = "shaped Royal Jelly";
            flags |= MF_NAME_SUFFIX;
        }
        // "Blork the orc" and similar.
        const size_t the_pos = name.find(" the ");
        if (the_pos != std::string::npos)
            name = name.substr(0, the_pos);
    }

    // deal with mons_sec
    monster->type         = targetc;
    monster->base_monster = MONS_PROGRAM_BUG;
    monster->number       = 0;

    // deal with mons_sec
    monster->type         = targetc;
    monster->base_monster = MONS_PROGRAM_BUG;
    monster->number       = 0;

    monster->flags = flags;
    monster->mname = name;

    if (mons_class_flag(monster->type, M_SPEAKS)

    if ((mons_class_flag(monster->type, M_SPEAKS)
         || !monster->mname.empty())

// If the monster was originally a unique which has been polymorphed into
// a non-unique, is its current monter type capable of using it's old
// speech?
static bool _polyd_can_speak(const monsters* monster)
{
    // Wizard and priest monsters can always speak.
    if (mons_class_flag(monster->type, M_ACTUAL_SPELLS | M_PRIEST))
        return (true);
    // Silent or non-sentient monsters can't use the original speech.
    if (mons_intel(monster) < I_NORMAL
        || mons_shouts(monster->type) == S_SILENT)
    {
        return (false);
    }

    // Does it have the proper vocal equipment?
    const mon_body_shape shape = get_mon_shape(monster);
    return (shape >= MON_SHAPE_HUMANOID && shape <= MON_SHAPE_NAGA);
}

        msg = _get_speak_string(prefixes, monster->name(DESC_PLAIN), monster);

    {
        if (!monster->mname.empty() && _polyd_can_speak(monster))
            msg = _get_speak_string(prefixes, monster->name(DESC_PLAIN),
                                    monster);
        if (msg.empty())
            msg = _get_speak_string(prefixes, monster->base_name(DESC_PLAIN),
                                    monster);
    }

    std::string monnam = _str_monam(*this, desc, force_vis);

    std::string monnam;
    if ((flags & MF_NAME_MASK) && (force_vis || you.can_see(this)))
        monnam = full_name(desc);
    else
        monnam = _str_monam(*this, desc, force_vis);

std::string monsters::full_name(description_level_type desc,
                                bool use_comma) const
{
    std::string title = _str_monam(*this, desc, true);

    if (has_base_name())
    {
        const unsigned long flag = flags & MF_NAME_MASK;
        if (flag == MF_NAME_SUFFIX)
        {
            title  = base_name(desc, true);
            title += " ";
            title += mname;
        }
        else if (flag == MF_NAME_NO_THE)
        {
            title += " ";
            title += base_name(DESC_PLAIN, true);
        }
        else if (flag == MF_NAME_REPLACE)
            ;
        else
        {
            if (use_comma)
                title += ",";
            title += " ";
            title += base_name(DESC_NOCAP_THE, true);
        }
    }
    return (title);
}

    std::string name =
        monster->is_named()? monster->name(DESC_CAP_THE) : "";

    if (monster->is_named() && player_monster_visible(monster))
    {
        std::string name = monster->name(DESC_CAP_THE);

    if (!name.empty() && player_monster_visible(monster))
    {

        if (monster->has_base_name())
            death_source_name +=
                ", " + monster->base_name(desc, death);

        if (death || you.can_see(monster))
            death_source_name = monster->full_name(desc, true);

    // Full name of the monster.  For an orc priest named Arbolt, full_name()
    // will return "Arbolt the orc priest".
    std::string full_name(description_level_type type,
                          bool use_comma = false) const;

    MF_ENSLAVED_SOUL      = 0x8000   // An undead monster soul enslaved by

    MF_ENSLAVED_SOUL      = 0x8000,  // An undead monster soul enslaved by

    MF_NAME_SUFFIX        = 0x10000, // mname is a suffix.
    MF_NAME_NO_THE        = 0x20000, // mname is a prefix with no "the"
                                     // between it and the monster type name.
    MF_NAME_REPLACE       = 0x30000, // mname entirely replaces normal monster
                                     // name.
    MF_NAME_MASK          = 0x30000

    bool is_feature = false;

    {

    }

    {

    }

            is_feature = true;

        {

        }

    else if (mgrd(gc) != NON_MONSTER)

    else if (mgrd(gc) != NON_MONSTER && you.can_see(&menv[mgrd(gc)]))

        {
            desc = mons.name(DESC_PLAIN);
            if (mons.has_base_name())
            {
                desc += ", ";
                desc += mons.base_name(DESC_NOCAP_THE);
            }
        }

            desc = mons.full_name(DESC_PLAIN, true);

    {

    }

    {

        is_feature = true;
    }

        desc = mon->name(mondtype);
        // For named monsters also mention the base type in the form of
        // "Morbeogh the orc priest", "Sigmund the human zombie".
        // Note that the only difference between DESC_BASENAME and DESC_PLAIN
        // is that basename will ignore mname, so the monster _must_ be named
        // for this to make any sense.
        if (mon->has_base_name())
            desc += " the " + mon->name(DESC_BASENAME);

        desc = mon->full_name(mondtype);

    const std::string capname = mons.name(DESC_CAP_A);
    title = capname;
    if (mons.has_base_name())
    {
        title += ", ";
        title += mons.base_name(DESC_NOCAP_THE, false);
    }

    title = mons.full_name(DESC_CAP_A, true);

# In case Blork ends up polymorphed.
Blork
@Blork the orc@
%%%%