marshallByte(th, NUM_BOOKS);
    for (j = 0; j < NUM_BOOKS; ++j)

    marshallByte(th, NUM_FIXED_BOOKS);
    for (j = 0; j < NUM_FIXED_BOOKS; ++j)

    ASSERT(beg < end);

    int count = 0, result = 0;

    int count = 0, result = 0, times_set = 0;

        {

            times_set++;
        }

    ASSERT(times_set > 0);

#include "database.h"

    for (int i = 0; i < NUM_BOOKS; i++)

    for (int i = 0; i < NUM_FIXED_BOOKS; i++)

    if (book.sub_type == BOOK_RANDART_LEVEL)
    {
        god_type god;
        int      level = book.plus;
        ASSERT(level > 0 && level <= 9);
        if (origin_is_acquirement(book) ||
            origin_is_god_gift(book, &god) && god == GOD_SIF_MUNA)
        {
            you.attribute[ATTR_RND_LVL_BOOKS] |= (1 << level);
        }
    }

    ASSERT(booktype >= 0 && booktype < NUM_BOOKS);
    if (booktype == BOOK_MANUAL || booktype == BOOK_DESTRUCTION)
    {
        return;
    }

    ASSERT(booktype >= 0 && booktype <= MAX_FIXED_BOOK);

static bool _is_memorized(spell_type spell)

static bool _is_memorised(spell_type spell)

    ASSERT(book.book_number()    != BOOK_MANUAL
           && book.book_number() != BOOK_DESTRUCTION);
    ASSERT(is_random_artefact(book));
    ASSERT(!book.props.exists(SPELL_LIST_KEY));

    const bool track_levels_had = origin_is_acquirement(book)
                                  || god == GOD_SIF_MUNA;

    if (level == -1)

    if (!is_random_artefact(book))

        int max_level =
            completely_random ? 9 : std::min(9, you.get_experience_level());
        level = random_range(1, max_level);
        // Give a book of a level not seen before, preferably one with
        // spells of a low enough level for the player to cast, or the
        // lowest aviable level if all levels which the player can cast
        // have already been given.
        if (track_levels_had)

        // Stuf parameters into book.plus and book.plus2, then call
        // make_item_randart(), which will call us back.
        if (level == -1)

            unsigned int seen_levels = you.attribute[ATTR_RND_LVL_BOOKS];
            std::vector<int> vec;
            for (int i = 1; i <= 9 && (vec.empty() || i <= max_level); i++)
            {
                if (!(seen_levels & (1 << i)))
                    vec.push_back(i);
            }
            if (vec.size() > 0)
                level = vec[random2(vec.size())];

            int max_level =
                completely_random ? 9 : std::min(9, you.get_experience_level());
            level = random_range(1, max_level);

        ASSERT(level > 0 && level <= 9);
        if (num_spells == -1)
            num_spells = SPELLBOOK_SIZE;
        ASSERT(num_spells > 0 && num_spells <= SPELLBOOK_SIZE);
        book.plus  = level;
        book.plus2 = num_spells;
        book.sub_type = BOOK_RANDART_LEVEL;
        return (make_item_randart(book));

    // Being called from make_item_randart()
    ASSERT(book.sub_type == BOOK_RANDART_LEVEL);
    ASSERT(level == -1 && num_spells == -1);
    level = book.plus;

    if (num_spells == -1)
        num_spells = SPELLBOOK_SIZE;

    num_spells = book.plus2;

        if (avoid_memorised[spell_pos] && _is_memorized(spell))

        if (avoid_memorised[spell_pos] && _is_memorised(spell))

    props.erase(SPELL_LIST_KEY);

    if (track_levels_had)
        you.attribute[ATTR_RND_LVL_BOOKS] |= (1 << level);

    set_randart_name(book, getRandNameString("level book"));

            else if (!_is_memorized(spell))

            else if (!_is_memorised(spell))

    ASSERT(book.book_number()    != BOOK_MANUAL
           && book.book_number() != BOOK_DESTRUCTION);
    ASSERT(is_random_artefact(book));
    ASSERT(!book.props.exists(SPELL_LIST_KEY));

    if (num_spells == -1)
        num_spells = SPELLBOOK_SIZE;

    if (!is_random_artefact(book))
    {
        // Stuff parameters into book.plus and book.plus2, then call
        // make_item_randart(), which will then call us back.
        if (num_spells == -1)
            num_spells = SPELLBOOK_SIZE;
        ASSERT(num_spells > 0 && num_spells <= SPELLBOOK_SIZE);
        if (max_levels == -1)
            max_levels = 255;
        if (disc1 == 0 && disc2 == 0)
        {
            if (!_get_weighted_discs(completely_random, god, disc1, disc2))
                return (false);
        }
        else if (disc2 == 0)
            disc2 = disc1;
        ASSERT(disc1 < (1 << (SPTYP_LAST_EXPONENT + 1)));
        ASSERT(disc2 < (1 << (SPTYP_LAST_EXPONENT + 1)));
        ASSERT(count_bits(disc1) == 1 && count_bits(disc2) == 1);
        int disc1_pos = 0, disc2_pos = 0;
        for (int i = 0; i <= SPTYP_LAST_EXPONENT; i++)
        {
            if (disc1 & (1 << i))
                disc1_pos = i;
            if (disc2 & (1 << i))
                disc2_pos = i;
        }
        book.plus  = num_spells | (max_levels << 8);
        book.plus2 = disc1_pos  | (disc2_pos  << 8);
        book.sub_type = BOOK_RANDART_THEME;
        return (make_item_randart(book));
    }
    // We're being called from make_item_randart()
    ASSERT(book.sub_type == BOOK_RANDART_THEME);
    ASSERT(disc1 == 0 && disc2 == 0);
    ASSERT(num_spells == -1 && max_levels == -1);
    num_spells = book.plus & 0xFF;

    if (max_levels == -1)
        max_levels = INT_MAX;

    max_levels = (book.plus >> 8) & 0xFF;

    if (disc1 == 0 && disc2 == 0)
    {
        if (!_get_weighted_discs(completely_random, god, disc1, disc2))
            return (false);
    }
    else if (disc2 == 0)
        disc2 = disc1;

    int disc1_pos = book.plus2 & 0xFF;
    ASSERT(disc1_pos <= SPTYP_LAST_EXPONENT);
    disc1 = 1 << disc1_pos;

    ASSERT(disc1 < (1 << (SPTYP_LAST_EXPONENT + 1)));
    ASSERT(disc2 < (1 << (SPTYP_LAST_EXPONENT + 1)));
    ASSERT(count_bits(disc1) == 1 && count_bits(disc2) == 1);

    int disc2_pos = (book.plus2 >> 8) & 0xFF;
    ASSERT(disc2_pos <= SPTYP_LAST_EXPONENT);
    disc2 = 1 << disc2_pos;

    props.erase(SPELL_LIST_KEY);

        name += god_name(god, false) + "'s book ";

        name += god_name(god, false) + "'s ";

    name += "of ";

    name += getRandNameString("book_noun");
    name += " of ";

    book.plus  = disc1;
    book.plus2 = disc2;

        // A peaceful god of healing wouldn't like combat spells.  All

        // A peaceful god of healing wouldn't like combat spells.

static bool _redo_book(item_def &book)
{
    int num_spells  = 0;
    int num_unknown = 0;
    for (int i = 0; i < SPELLBOOK_SIZE; i++)
    {
        spell_type spell = which_spell_in_book(book, i);
        if (spell == SPELL_NO_SPELL)
            continue;
        num_spells++;
        if (!you.seen_spell[spell])
            num_unknown++;
    }
    if (num_spells <= 5 && num_unknown == 0)
        return (true);
    else if (num_spells > 5 && num_unknown <= 1)
        return (true);
    return (false);
}

    return make_book_theme_randart(book);

    ASSERT(book.sub_type == BOOK_RANDART_LEVEL
           || book.sub_type == BOOK_RANDART_THEME);
    ASSERT(book.plus != 0);
    god_type god;
    bool redo = !origin_is_god_gift(book, &god) || god != GOD_XOM;
    // Plus and plus2 contain paramaters to make_book_foo_randart()
    // which might get changed after the book has been made into a
    // randart, so reset them on each iteration of the loop.
    int  plus  = book.plus;
    int  plus2 = book.plus2;
    bool book_good;
    for (int i = 0; i < 4; i++)
    {
        book.plus  = plus;
        book.plus2 = plus2;
        if (book.sub_type == BOOK_RANDART_LEVEL)
            book_good = make_book_level_randart(book);
        else
            book_good = make_book_theme_randart(book);
        if (!book_good)
            continue;
        if (redo && _redo_book(book))
            continue;
        break;
    }
    return (book_good);

       if (item.sub_type == BOOK_MANUAL || item.sub_type == BOOK_DESTRUCTION)
           return (false);

        if (item.sub_type != BOOK_RANDART_LEVEL
            && item.sub_type != BOOK_RANDART_THEME)
        {
            return (false);
        }

        spec.sub_type = BOOK_MANUAL;
        spec.plus = -1;

        spec.sub_type  = BOOK_MANUAL;
        spec.plus      = -1;
        return;
    }
    else if (c == "fixed theme book")
    {
        spec.base_type = OBJ_BOOKS;
        spec.sub_type  = BOOK_RANDART_THEME;
        spec.plus      = -1;

    else if (c == "fixed level book")
    {
        spec.base_type = OBJ_BOOKS;
        spec.sub_type  = BOOK_RANDART_LEVEL;
        spec.plus      = -1;
        return;
    }

static void _generate_book_item(item_def& item, int force_type,
                                int item_level)

static void _generate_book_item(item_def& item, int allow_uniques,
                                int force_type, int item_level)

            item.sub_type = random2(NUM_BOOKS);

            item.sub_type = random2(NUM_NORMAL_BOOKS);

            if (item.sub_type != BOOK_DESTRUCTION
                && item.sub_type != BOOK_MANUAL
                && book_rarity(item.sub_type) != 100

            if (book_rarity(item.sub_type) != 100

        while (item.sub_type == BOOK_DESTRUCTION
               || item.sub_type == BOOK_MANUAL
               || book_rarity(item.sub_type) == 100);

        while (book_rarity(item.sub_type) == 100);

    }
    // Manuals and books of destruction are rare enough without replacing
    // them with randart books.
    if (item.sub_type == BOOK_MANUAL || item.sub_type == BOOK_DESTRUCTION)
        return;
    // Only randomly generate randart books for OBJ_RANDOM, since randart
    // spellbooks aren't merely of-the-same-type-but-better, but
    // have an entirely different set of spells.
    if (allow_uniques && item_level > 2 && force_type == OBJ_RANDOM
        && x_chance_in_y(101 + item_level * 3, 4000))
    {
        // Same relative weights as acquirement
        int choice = random_choose_weighted(
            55, BOOK_RANDART_THEME,
            12, BOOK_RANDART_LEVEL,
             0);
        item.sub_type = choice;

    if (item.sub_type == BOOK_RANDART_THEME)
        make_book_theme_randart(item, 0, 0, 7, 25);
    else if (item.sub_type == BOOK_RANDART_LEVEL)
    {
        int max_level   = std::min( 9, std::max(1, item_level / 3) );
        int spell_level = random_range(1, max_level);
        int num_spells  = 7 - (spell_level + 1) / 2 + random_range(1, 2);
        make_book_level_randart(item, spell_level, num_spells);
    }

        _generate_book_item(item, force_type, item_level);

        _generate_book_item(item, allow_uniques, force_type, item_level);

    case BOOK_RANDART_LEVEL:          return "Fixed Level";
    case BOOK_RANDART_THEME:          return "Fixed Theme";
    case BOOK_CARD_EFFECT:            return "Card Effects";

            if (know_type)
            {
                if (book_has_title(*this))
                    buff << get_artefact_name(*this);
                else
                    buff << "book " << get_artefact_name(*this);
            }
            else
                buff << get_artefact_name(*this) << "book";

            buff << get_artefact_name(*this);
            if (!know_type)
                buff << "book";

                        || item->base_type == OBJ_ARMOUR))));

                        || item->base_type == OBJ_ARMOUR
                        || item->base_type == OBJ_BOOKS))));

  FixedVector<bool, NUM_BOOKS>  had_book;
  FixedVector<bool, NUM_SPELLS> seen_spell;

  FixedVector<bool, NUM_FIXED_BOOKS> had_book;
  FixedVector<bool, NUM_SPELLS>      seen_spell;

    BEAM_NONE,

    BEAM_NONE,                    // 0

    BEAM_MAGIC,

    BEAM_MAGIC,                   // 5

    BEAM_MIASMA,

    BEAM_MIASMA,                  // 10

    BEAM_STEAM,

    BEAM_STEAM,                   // 15

    BEAM_LAVA,

    BEAM_LAVA,                    // 20

    BEAM_RANDOM,                  // 25 - currently translates into FIRE..ACID

    BEAM_RANDOM,                  // currently translates into FIRE..ACID
    // 24

    BEAM_FIRST_ENCHANTMENT,

    BEAM_FIRST_ENCHANTMENT = 25,  // 25

    BEAM_INVISIBILITY,

    BEAM_INVISIBILITY,            // 30

    BEAM_BANISH,

    BEAM_BANISH,                  // 35

    BEAM_DISPEL_UNDEAD,

    BEAM_DISPEL_UNDEAD,           // 40

    BEAM_BACKLIGHT,

    BEAM_BACKLIGHT,               // 45

    BEAM_POTION_STINKING_CLOUD,

    BEAM_POTION_STINKING_CLOUD,   // 47

    BEAM_POTION_STEAM,

    BEAM_POTION_STEAM,            // 50

    BEAM_POTION_BLUE_SMOKE,

    BEAM_POTION_BLUE_SMOKE,       // 55

    BEAM_LINE_OF_SIGHT          // only used for checking monster LOS

    BEAM_LINE_OF_SIGHT,         // 60 - only used for checking monster LOS
    NUM_BEAMS

    BOOK_NECRONOMICON,
    BOOK_CALLINGS,                     //   25
    BOOK_CHARMS,
    BOOK_DEMONOLOGY,

    BOOK_CALLINGS,
    BOOK_CHARMS,                       //   25

    BOOK_DIVINATIONS,                  //   30

    BOOK_DIVINATIONS,

    BOOK_ENVENOMATIONS,
    BOOK_ANNIHILATIONS,

    BOOK_ENVENOMATIONS,                //   30

    BOOK_DESTRUCTION,                  //   35

    BOOK_GEOMANCY,
    BOOK_EARTH,                        //   40
    BOOK_MANUAL,

    BOOK_GEOMANCY,                     //   35
    BOOK_EARTH,

    BOOK_PARTY_TRICKS,           // 45 //jmf: 04jan2000

    BOOK_PARTY_TRICKS,           // 40 //jmf: 04jan2000

    MAX_NORMAL_BOOK = BOOK_STALKING,
    MIN_GOD_ONLY_BOOK,                      // 43
    BOOK_ANNIHILATIONS = MIN_GOD_ONLY_BOOK, // 43
    BOOK_DEMONOLOGY,
    BOOK_NECRONOMICON,                      // 45
    MAX_GOD_ONLY_BOOK = BOOK_NECRONOMICON,
    MAX_FIXED_BOOK = MAX_GOD_ONLY_BOOK,
    BOOK_RANDART_LEVEL,                     // 46
    BOOK_RANDART_THEME,
    BOOK_CARD_EFFECT,
    MAX_MEMORISABLE_BOOK = BOOK_CARD_EFFECT,
    BOOK_MANUAL,
    BOOK_DESTRUCTION,                       // 50

#define NUM_NORMAL_BOOKS     (MAX_NORMAL_BOOK + 1)
#define NUM_FIXED_BOOKS      (MAX_FIXED_BOOK + 1)
#define NUM_MEMORISABLE_BOOK (MAX_MEMORISABLE_BOOK + 1)

                if (type_wanted == NUM_BOOKS)

                if (type_wanted > MAX_FIXED_BOOK)

                        type_wanted = random2(NUM_BOOKS);

                        type_wanted = random2(NUM_NORMAL_BOOKS);

                while (book_rarity(type_wanted) == 100
                       || type_wanted == BOOK_DESTRUCTION
                       || type_wanted == BOOK_MANUAL)
                {
                    type_wanted = random2(NUM_BOOKS);
                }

                while (book_rarity(type_wanted) == 100)
                    type_wanted = random2(NUM_NORMAL_BOOKS);

static void _do_book_acquirement(item_def &book, int agent)
{
    // items() shouldn't make book a randart for acquirement items.
    ASSERT(!is_random_artefact(book));
    // Non-normal books are rare enough without turning them into
    // randart books.
    if (book.sub_type > MAX_NORMAL_BOOK)
        return;
    int          level       = (you.skills[SK_SPELLCASTING] + 2) / 3;
    unsigned int seen_levels = you.attribute[ATTR_RND_LVL_BOOKS];
    if (agent == GOD_XOM)
        level = random_range(1, 9);
    else if (seen_levels & (1 << level))
    {
        // Give a book of a level not seen before, preferably one with
        // spells of a low enough level for the player to cast, or the
        // lowest aviable level if all levels which the player can cast
        // have already been given.
        int max_level = std::min(9, you.get_experience_level());
       
        std::vector<int> vec;
        for (int i = 1; i <= 9 && (vec.empty() || i <= max_level); i++)
        {
            if (!(seen_levels & (1 << i)))
                vec.push_back(i);
        }
        if (vec.size() > 0)
            level = vec[random2(vec.size())];
        else
            level = -1;
    }
    int choice = random_choose_weighted(
                               55, 0, // fixed themed
                               24, 1, // leave alone
             level == -1 ? 0 : 12, 2, // fixed level
        agent == GOD_XOM ? 0 :  6, 3, // manual (too useful for Xom)
                                0);
    switch(choice)
    {
    case 0:
        make_book_theme_randart(book, 0, 0, 7, 25);
        break;
    case 1:
        // Leave alone
        break;
    case 2:
    {
        int num_spells = 7 - (level + 1) / 2 + random_range(1, 2);
        make_book_level_randart(book, level, num_spells);
        break;
    }
    // Spell discipline manual
    case 3:
    {
        int weights[SK_POISON_MAGIC - SK_CONJURATIONS + 1];
        for (int i = SK_CONJURATIONS; i <= SK_POISON_MAGIC; i++)
        {
            int w = std::max(0, 24 - you.skills[i])
                * 100 / species_skills(i, you.species);
            weights[i - SK_CONJURATIONS] = w;
        }
        int skill = choose_random_weighted(weights,
                                           weights + ARRAYSZ(weights));
        skill += SK_CONJURATIONS;
        book.sub_type = BOOK_MANUAL;
        book.plus = skill;
        // Set number of reads possible before it "crumbles to dust".
        book.plus2 = 3 + random2(15);
        break;
    }
    default:
        ASSERT(false);
    }
}

        default: break;

        default:
            // Lets wizards escape out of accidently choosing acquirement.
            if (agent == AQ_WIZMODE)
            {
                canned_msg(MSG_OK);
                return (false);
            }
            break;

    const bool god_agent = agent > GOD_NO_GOD && agent < NUM_GODS;

        if (agent > GOD_NO_GOD && agent < NUM_GODS)

        if (god_agent)

            thing_created = items( 1, class_wanted, type_wanted, true,

            // Don't generate randart books in items(), we do that
            // ourselves.
            int want_arts = class_wanted == OBJ_BOOKS ? 0 : 1;
            thing_created = items( want_arts, class_wanted, type_wanted, true,

        {
            _do_book_acquirement(thing, agent);

        }

    for (int i = 0; i < NUM_BOOKS; i++)

    for (int i = 0; i < NUM_FIXED_BOOKS; i++)

        else if (type_wanted == BOOK_RANDART_THEME)
            make_book_theme_randart(*item);
        else if (type_wanted == BOOK_RANDART_LEVEL)
            make_book_level_randart(*item);

A book of magic spells. Beware, for some of the more powerful
grimoires are not to be toyed with.
%%%%
book of card effects

book of fixed level
A book of magic spells. Beware, for some of the more powerful
grimoires are not to be toyed with.
%%%%
book of fixed theme
A book of magic spells. Beware, for some of the more powerful
grimoires are not to be toyed with.
%%%%

# Books (NOTE: just a placeholder for now)

# Books

book_noun
Book
Tome
Grimoir
Almanach
Guide
Volume
Compendium
Handbook
%%%%
book_adjective
glistering
levitating
droning
conspicuous
inconspicuous
%%%%
book_magic
Magic
Casting
Wizardry
Bewitchment
Sorcery
%%%%
level book
"@book_magic@ 101"
"Easy @book_magic@"
"@book_magic@ in Simple Steps"
"Thorough Guide to @book_magic@"
"Last Secrets of @book_magic@"
%%%%
# Book name should be set in make_book_level_randart() or
# make_book_theme_randart(), so if this gets picked there's a bug.

@armour@

Book of Bugginess

@armour appearance@

@book_adjective@

    for (int i = 0; i < NUM_BOOKS; i++)

    for (int i = 0; i < NUM_FIXED_BOOKS; i++)

}
static bool _make_book_randart(item_def &book)
{
    char type;
    do
    {
        mpr("Make book fixed [t]heme or fixed [l]evel? ", MSGCH_PROMPT);
        type = tolower(getch());
    } while (type != 't' && type != 'l');
    if (type == 'l')
        return make_book_level_randart(book);
    else
        return make_book_theme_randart(book);

 
        if (!make_item_randart( item ))

        if (item.base_type == OBJ_BOOKS)
        {
            if (!_make_book_randart(item))
            {
                mpr("Failed to turn book into randart.");
                break;
            }
        } 
        else if (!make_item_randart( item ))