std::string player::arm_name(bool plural, bool *can_plural) const
{
    if (transform_changed_physiology())
        return hand_name(plural, can_plural);
    if (can_plural != NULL)
        *can_plural = true;
    std::string str = "arm";

    if (player_genus(GENPC_DRACONIAN) || you.species == SP_NAGA)
        str = "scaled arm";
    else if (you.species == SP_KENKU)
        str = "feathered arm";
    else if (you.species == SP_MUMMY)
        str = "bandaged wrapped arm";
    if (plural)
        str = pluralise(str);
    return (str);
}

    const bool unseen = !you.can_see(monster);
    const bool silent = silenced(monster->pos()) || force_silent;

    const bool unseen    = !you.can_see(monster);
    const bool silent    = silenced(monster->pos()) || force_silent;
    const bool no_silent = mons_class_flag(monster->type, M_SPELL_NO_SILENT);

    if (unseen && silent)

    if (unseen && silent || silent && no_silent)

    const bool innate = !(priest || wizard) || (flags & SPFLAG_INNATE);

    const bool innate = !(priest || wizard || no_silent)
                       || (flags & SPFLAG_INNATE);

           && !mons_class_flag(monster->type, M_SPELL_NO_SILENT
                                            | M_NOISY_SPELLS)
           && !(flags & SPFLAG_NOISY)))

           && !mons_class_flag(monster->type, M_NOISY_SPELLS)
           && !(flags & SPFLAG_NOISY)
           && mons_genus(monster->type) != MONS_DRAGON))

    std::string suffix;
    if (silent)
        suffix = " silent";
    else if (unseen)
        suffix = " unseen";

    std::string key;

    const std::string    spell_name = spell_title(real_spell);
    const mon_body_shape shape      = get_mon_shape(monster);

    // First try the individual spell.
    key             = spell_title(real_spell) + cast_str;
    std::string msg = getSpeakString(key + suffix);

    std::vector<std::string> key_list;

    if (msg.empty() && silent)
        msg = getSpeakString(key);
    // Second, try the individual monster.
    if (msg.empty())

    // First try the spells name.
    if (shape <= MON_SHAPE_NAGA && !innate)

        key  = mons_type_name(monster->type, DESC_PLAIN);
        key += cast_str;
        msg  = getSpeakString(key + suffix);
        if (msg.empty() && silent)
            msg = getSpeakString(key);

        if (priest || wizard)
            key_list.push_back(spell_name + cast_str + " real");
        if (mons_intel(monster) >= I_NORMAL)
            key_list.push_back(spell_name + cast_str + " gestures");

    key_list.push_back(spell_name + cast_str);

    // Third, try generic priest or wizard messages.
    if (msg.empty() && !innate)
    {
        if (priest)
            key = "priest";
        else
            key = "wizard";

    const unsigned int num_spell_keys = key_list.size();

        key += cast_str;
        msg  = getSpeakString(key + suffix);

    // Next the monster type name, then species name, then genus name.
    key_list.push_back(mons_type_name(monster->type, DESC_PLAIN) + cast_str);
    key_list.push_back(mons_type_name(mons_species(monster->type), DESC_PLAIN)
                       + cast_str);
    key_list.push_back(mons_type_name(mons_genus(monster->type), DESC_PLAIN)
                       + cast_str);

        if (msg.empty() && silent)
            msg = getSpeakString(key);
    }

    // Last, generic wizard, priest or demon.
    if (wizard)
        key_list.push_back("wizard" + cast_str);
    else if (priest)
        key_list.push_back("priest" + cast_str);
    else if (mons_is_demon(monster->type))
        key_list.push_back("demon" + cast_str);

    // Fourth, try the monster's species.
    if (msg.empty())

    // For targeted spells, try with the targeted suffix first.
    if (in_bounds(pbolt.target) && pbolt.target != monster->pos()
        && (flags & SPFLAG_TARGETING_MASK))

        key  = mons_type_name(mons_species(monster->type), DESC_PLAIN);
        key += cast_str;
        msg  = getSpeakString(key + suffix);
        if (msg.empty() && silent)
            msg = getSpeakString(key);

        for (unsigned int i = key_list.size() - 1; i >= num_spell_keys; i--)
        {
            std::string str = key_list[i] + " targeted";
            key_list.insert(key_list.begin() + i, str);
        }

    // Fifth, try the monster's genus.
    if (msg.empty())

    std::string prefix;
    if (silent)
        prefix = "silent ";
    else if (unseen)
        prefix = "unseen ";
    std::string msg;
    for (unsigned int i = 0; i < key_list.size(); i++)

        key  = mons_type_name(mons_genus(monster->type), DESC_PLAIN);
        key += cast_str;
        msg  = getSpeakString(key + suffix);

        const std::string key = key_list[i];

        if (msg.empty() && silent)
            msg = getSpeakString(key);
    }

        msg = getSpeakString(prefix + key);
        if (msg == "__NONE")
        {
            msg = "";
            break;
        }
        else if (msg == "__NEXT")
        {
            msg = "";
            if (i < num_spell_keys)
                i = num_spell_keys - 1;
            else if (ends_with(key, " targeted"))
                i++;
            continue;
        }
        else if (!msg.empty())
            break;

    // Lastly, maybe it's a demon.
    if (msg.empty() && mons_is_demon(monster->type))
    {
        key  = "demon";
        key += cast_str;
        msg  = getSpeakString(key + suffix);

        // If we got no message and we're using the silent prefix, then
        // try again without the prefix.
        if (prefix != "silent")
            continue;

        if (msg.empty() && silent)
            msg = getSpeakString(key);

        msg = getSpeakString(key);
        if (msg == "__NONE")
        {
            msg = "";
            break;
        }
        else if (msg == "__NEXT")
        {
            msg = "";
            if (i < num_spell_keys)
                i = num_spell_keys - 1;
            else if (ends_with(key, " targeted"))
                i++;
            continue;
        }
        else if (!msg.empty())
            break;

    /////////////////////
    // We have a message.
    /////////////////////

    if (pbolt.target == you.pos())

    if (!(flags & SPFLAG_TARGETING_MASK) || !in_bounds(pbolt.target))
        target = "NO TARGET";
    else if (pbolt.target == you.pos())

    else if (pbolt.target == monster->pos())
        target = monster->pronoun(PRONOUN_REFLEXIVE);

        || pbolt.flavour >= NUM_BEAMS

        || pbolt.flavour > BEAM_LAST_REAL

    else if (pbolt.type == 0 || pbolt.name[0] == '0')

    else if (pbolt.type == 0 || pbolt.type == ' ' || pbolt.name[0] == '0'
             || pbolt.is_enchantment())
    {

    }

    if (msg.find(" roar") != std::string::npos)
        noise = get_shout_noise_level(S_ROAR);
    else if (msg.find(" breathes") != std::string::npos)
    {
        shout_type type = mons_shouts(monster->type);
        if(type == S_SILENT)
            type = S_ROAR;
        noise = get_shout_noise_level(type);
    }

std::string monsters::arm_name(bool plural, bool *can_plural) const
{
    mon_body_shape shape = get_mon_shape(this);
    if (shape > MON_SHAPE_NAGA)
        return hand_name(plural, can_plural);

    if (can_plural != NULL)
        *can_plural = true;
    std::string str;
    switch(mons_genus(type))
    {
    case MONS_NAGA:
    case MONS_DRACONIAN: str = "scaled arm"; break;
    case MONS_MUMMY: str = "bandaged wrapped arm"; break;
    case MONS_SKELETAL_WARRIOR:
    case MONS_LICH:  str = "bony arm"; break;
    default: str = "arm"; break;
    }
   if (plural)
       str = pluralise(str);
   return (str);
}

    // Body parts.
    bool        can_plural = false;
    std::string part_str   = monster->hand_name(false, &can_plural);
    msg = replace_all(msg, "@hand@", part_str);
    msg = replace_all(msg, "@Hand@", upcase_first(part_str));
    if (!can_plural)
        part_str = "NO PLURAL HANDS";
    else
        part_str = monster->hand_name(true);
    msg = replace_all(msg, "@hands@", part_str);
    msg = replace_all(msg, "@Hands@", upcase_first(part_str));
    can_plural = false;
    part_str   = monster->arm_name(false, &can_plural);
    msg = replace_all(msg, "@arm@", part_str);
    msg = replace_all(msg, "@Arm@", upcase_first(part_str));
    if (!can_plural)
        part_str = "NO PLURAL ARMS";
    else
        part_str = monster->arm_name(true);
    msg = replace_all(msg, "@arms@", part_str);
    msg = replace_all(msg, "@Arms@", upcase_first(part_str));
    can_plural = false;
    part_str   = monster->foot_name(false, &can_plural);
    msg = replace_all(msg, "@foot@", part_str);
    msg = replace_all(msg, "@Foot@", upcase_first(part_str));
    if (!can_plural)
        part_str = "NO PLURAL FOOT";
    else
        part_str = monster->foot_name(true);
    msg = replace_all(msg, "@feet@", part_str);
    msg = replace_all(msg, "@Feet@", upcase_first(part_str));

    virtual std::string arm_name(bool plural,
                                 bool *can_plural = NULL) const = 0;

    virtual bool cannot_act() const = 0;

    std::string arm_name(bool plural, bool *can_plural = NULL) const;

    bool cannot_act() const;

    bool cannot_act() const;

    std::string arm_name(bool plural, bool *can_plural = NULL) const;

# This file contains the messages used to "announce" a spell, like
# "The wizard mumbles some strange words."  The messages are looked
# up in the following order by the following keys:
#
# 1) The name of the spell being cast:
#   a) If being cast by a wizard or priest monster with arms, first try
#      with the suffix "real".
#   b) If being cast by a monster of normal or higher intelligence with arms,
#      try with the suffix "gestures".
#   c) Next, try without any suffix.
# 2) The name of the monster's type.
# 3) The name of the monster's species.
# 4) The name of the monster's genus.
# 5) "priest" if the monster is a priest type, "wizard" if it's a wizard type,
#    or "demon" if it's demonic.
#
# For 2 to 5, if the spell has a target it will first add the suffix
# "targeted" to the lookup key before trying without the suffix.
#
# For all lookups, if the monster is unseen by the player it will add the
# prefix "unseen" to the key, or if the player or monster is silenced
# it will prefix "silent" to the key (if the monster is both unseen and
# unheard no message is ever given).  If using the prefix "silent" gives
# no results it will try again without the prefix, assuming that the
# spell has no sound component.
#
# To give no message use the string "__NONE", and to skip the current
# lookup method and move onto the next one use the string "__NEXT".

%%%%
unseen Animate Dead cast real
You hear @something@ calling out to the dead.
%%%%
Animate Dead cast real
@The_monster@ gestures at the surounding area while chanting.
@The_monster@ throws @possessive@ @arms@ wide while chanting.

Animate Dead cast gestures
@The_monster@ gestures at the surounding.
@The_monster@ throws @possessive@ @arms@ wide.
%%%%
Symbol of Torment cast
@The_monster@ calls on the powers of Hell!
%%%%
unseen Symbol of Torment cast
@The_something@ calls on the powers of Hell!
#####################################################
# Individual innate spells (breathing and spitting).
#####################################################
%%%%

Acid Splash cast unseen

unseen Acid Splash cast

Draconian Breath cast unseen

unseen Draconian Breath cast

Poison Splash cast unseen

unseen Poison Splash cast

Sticky Flame Splash cast unseen

unseen Sticky Flame Splash cast

########################################################################
# Individual monsters
########################################################################

Symbol of Torment cast

Geryon cast

@The_monster@ calls on the powers of Hell!

@The_monster@ winds a great silver horn.

Symbol of Torment cast unseen

unseen Geryon cast

@The_something@ calls on the powers of Hell!
#####################################################
# Priest and wizard casting messages.
#####################################################

You hear a weird and mournful sound.
%%%%
giant orange brain cast
@The_monster@ pulsates.

priest cast

orb of fire cast
@The_monster@ glows yellow.

@The_monster@ prays.

@The_monster@ glows bright magenta.

@The_monster@ mumbles some strange prayers.

@The_monster@ glows deep purple.

@The_monster@ utters an invocation.
%%%%
priest cast unseen

@The_monster@ glows red.

You hear some strange, mumbled prayers.

@The_monster@ emits a lurid red light.

wizard cast
@The_monster@ gestures wildly.

# Sphinxes can't gesture or point.
sphinx cast

%%%%
wizard cast unseen
You hear some strange, mumbled words.

# Monster genus and species messages.

# Monster species and genus messages.

demon cast

dragon cast targeted

@The_monster@ gestures.

@The_monster@ breathes @beam@ at @target@.

@The_monster@ breathes @beam@ at @target@.

@The_monster@ USED A NON-TARGETED DRAGON SPELL.  Please file a bug report.

dragon cast unseen

unseen dragon cast

curse skull cast unseen

unseen curse skull cast

giant eyeball cast targeted
@The_monster@ gazes at @target@.
%%%%

@The_monster@ gazes.
########################################################################
# Individual monsters
########################################################################

@The_monster@ looks around.
######################################################
# Generic priest, wizard and demonic casting messages.
######################################################

Geryon cast

priest cast targeted

@The_monster@ winds a great silver horn.

@The_monster@ prays against @target@.
@The_monster@ mumbles some strange prayers against @target@.
@The_monster@ utters an invocation against @target@.

Geryon cast unseen

priest cast
@The_monster@ prays.
@The_monster@ mumbles some strange prayers.

You hear a weird and mournful sound.

@The_monster@ utters an invocation.

giant orange brain cast

unseen priest cast

@The_monster@ pulsates.

You hear some strange, mumbled prayers.

orb of fire cast

wizard cast targeted

@The_monster@ glows yellow.

@The_monster@ gestures at @target@ while chanting.

@The_monster@ glows bright magenta.

@The_monster@ points at @target@ and mumbles some strange words.

@The_monster@ glows deep purple.

@The_monster@ casts a spell at @target@.
%%%%
wizard cast

@The_monster@ glows red.

@The_monster@ gestures wildly while chanting.
@The_monster@ mumbles some strange words.

@The_monster@ emits a lurid red light.

@The_monster@ casts a spell.
%%%%
unseen wizard cast
You hear some strange, mumbled words.

demon cast targeted
@The_monster@ gestures at @target@.
%%%%
demon cast
@The_monster@ gestures.
%%%%