bool can_learn_spell(bool silent = false);

bool learn_spell(spell_type spell, const item_def &book,
                 bool is_safest_book);

        out.cprintf( "Select a spell to read its description." EOL );

        if (book.base_type == OBJ_BOOKS && in_inventory(book))
            out.cprintf( "Select a spell to read its description or to "
                         "memorise it." EOL );
        else
            out.cprintf( "Select a spell to read its description." EOL );

    std::string more_str = make_stringf("%d spell level%s left",

    std::string more_str = make_stringf("<lightgreen>%d spell level%s left"
                                        "<lightgreen>",

        more_str += make_stringf(", %u unreadable spellbook%s",

        more_str += make_stringf(", <lightmagenta>%u unreadable spellbook%s"
                                   "</lightmagenta>",

        more_str += make_stringf(", %u spell%s unmemorizable", num_race,

        more_str += make_stringf(", <lightred>%u spell%s unmemorizable"
                                   "</lightred>",
                                 num_race,

    spell_menu.set_more(formatted_string(more_str));

    spell_menu.set_more(formatted_string::parse_string(more_str));

bool learn_spell()

bool can_learn_spell(bool silent)

        canned_msg(MSG_PRESENT_FORM);

        if (!silent)
            canned_msg(MSG_PRESENT_FORM);

        mpr("You can't use spell magic! I'm afraid it's scrolls only for now.");

        if (!silent)
            mpr("You can't use spell magic! I'm afraid it's scrolls only "
                "for now.");

        mpr("You are too confused!");

        if (!silent)
            mpr("You are too confused!");

        canned_msg(MSG_TOO_BERSERK);

        if (!silent)
            canned_msg(MSG_TOO_BERSERK);

    return (true);
}

bool learn_spell()
{
    if (!can_learn_spell())
        return (false);

    // MATT

    if (player_spell_levels() < spell_levels_required(specspell))

    spells_to_books::iterator it = book_hash.find(specspell);
    item_def book;
    book.base_type = OBJ_BOOKS;
    book.sub_type  = it->second;
    book.quantity  = 1;
    book.flags    |= ISFLAG_IDENT_MASK;
    return learn_spell(specspell, book, true);
}
bool learn_spell(spell_type specspell, const item_def &book,
                 bool is_safest_book)
{
    if (!can_learn_spell())
        return (false);
    if (you_cannot_memorise(specspell))

        mpr("You can't memorise that many levels of magic yet!");

        mprf("You cannot memorise that spell because you are a %s.",
             lowercase_string(species_name(you.species, 0)).c_str());
        return (false);
    }
    if (player_knows_spell(specspell))
    {
        mpr("You already know that spell!");
        return (false);
    }
    if (you.spell_no >= 21 && specspell != SPELL_SELECTIVE_AMNESIA)
    {
        mpr("Your head is already too full of spells!");

    int chance = spell_fail(specspell);

    if (player_spell_levels() < spell_levels_required(specspell))
    {
        mpr("You can't memorise that many levels of magic yet!");
        return (false);
    }

    spells_to_books::iterator it = book_hash.find(specspell);

    int chance = spell_fail(specspell);

    if (chance > 0 && is_dangerous_spellbook(it->second))

    if (chance > 0 && is_dangerous_spellbook(book))

        item_def book;
        book.base_type = OBJ_BOOKS;
        book.sub_type  = it->second;
        book.quantity  = 1;
        book.flags    |= ISFLAG_IDENT_MASK;

        std::string prompt;

        char buf[180];

        if (is_safest_book)
            prompt = "The only spellbook you have which contains that spell ";
        else
            prompt = "The spellbook you are reading from ";
        prompt += make_stringf("is %s, a dangerous spellbook which will "
                               "strike back at you if your memorisation "
                               "attempt fails. Attempt to memorise anyway?",
                               book.name(DESC_NOCAP_THE).c_str());

        sprintf(buf, "The only spellbook you have which contains that spell "
                "is %s, a dangerous spellbook which will strike back at you "
                "if your memorisation attempt fails. Attempt to memorise "
                "anyway?",
                book.name(DESC_NOCAP_THE).c_str());
        if (!yesno(buf, false, 'n'))

        if (!yesno(prompt.c_str(), false, 'n'))

        if (it->second == BOOK_NECRONOMICON)

        if (book.sub_type == BOOK_NECRONOMICON)

        else if (it->second == BOOK_DEMONOLOGY)

        else if (book.sub_type == BOOK_DEMONOLOGY)

        else if (it->second == BOOK_ANNIHILATIONS)

        else if (book.sub_type == BOOK_ANNIHILATIONS)

        describe_spell(spell, &book);

        describe_spell(spell);

        // Player memorised spell which was being looked at.
        if (you.turn_is_over)
            return;

#include "invent.h"

    describe_spell( nthing );

    describe_spell( nthing, &item );

        // Memorised spell while reading a spellbook.
        if (you.turn_is_over)
            return;

            cprintf("Select a spell to read its description.");

            if (item.base_type == OBJ_BOOKS && in_inventory(item))
                cprintf("Select a spell to read its description or to "
                        "memorize it.");
            else
                cprintf("Select a spell to read its description.");

void describe_spell(spell_type spelled)

void describe_spell(spell_type spelled, const item_def* item)

    bool can_mem = false;

    else if (item && item->base_type == OBJ_BOOKS && in_inventory(*item))
    {
        can_mem = true;
        description += "$$";
        description += "(M)emorise this spell.";
    }

    if (getch() == 0)
        getch();

    char ch;
    if ((ch = getch()) == 0)
        ch = getch();
    if (can_mem && toupper(ch) == 'M')
    {
        if (!learn_spell(spelled, *item, false) || !you.turn_is_over)
            more();
        redraw_screen();
    }