fiddlerwoaroof/crawl - Change FWNNTOEERPUKXPE4OC52UABFZLKIU3O5GRNNLDK4QI4HR2IOU36QC

Savefile compatibility breakage from keeping track of which spells have been

seen.

Implemented fixed-level randart spell books, which is all randart spellbooks as of now. All my attempts at sorting the spell list so that spells with the same schools group together have utterly failed.

Got rid of the hackish "non-monster origin is stored in item.orig_monnum as (-origin - 2)" logic, replaced with the slightly less hackish "-origin". Added the two enumerations IT_SRC_START and IT_SRC_SHOP to do it. Also, origin_is_god_gift() and origin_is_acquirement() can retrieve the god/source of the item so that you don't have to do the negation and typecasting yourself.

Added some new spell flags:

SPFLAG_BATTLE for non-conjuration spells which are still combat/battle related (branding spells and single school attack spells like "Pain"),
SPFLAG_CARD for spells which are card-type effects which don't show up in ordinary spellbooks (Tomb of Doroklohe and (I assume) Disintigrate)
SPFLAG_TESTING for spells which are only used for testing (Debugging Ray)
SPFLAG_DEVEL for spells that are still under development (Crush, Disrupt, and Detect Magic).

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@7742 c06c8d41-db1a-0410-9941-cceddc491573

Created by zelgadis on December 4, 2008

FWNNTOEERPUKXPE4OC52UABFZLKIU3O5GRNNLDK4QI4HR2IOU36QC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/xom.cc at line 469 [10.3]

B:BD[9.2212] → [9.2212:2283]

        god_type iorig = static_cast<god_type>(-item.orig_monnum - 2);

[9.2212]

[9.2283]

        god_type iorig = static_cast<god_type>(-item.orig_monnum);

Insertion in crawl-ref/source/tags.cc at line 1085 [11.164589]

[11.185916]

    marshallShort(th, NUM_SPELLS);
    for (j = 0; j < NUM_SPELLS; ++j)
        marshallByte(th,you.seen_spell[j]);

Insertion in crawl-ref/source/tags.cc at line 1529 [11.164589]

[11.202435]

    // how many spells?
    count_s = unmarshallShort(th);
    for (j = 0; j < count_s; ++j)
        you.seen_spell[j] = unmarshallByte(th);

Insertion in crawl-ref/source/spl-util.h at line 139 [11.242902]
[11.245620]
[11.245620]
```
int spell_skill2type (unsigned int which_skill);
```

Insertion in crawl-ref/source/spl-util.cc at line 830 [11.245665]

[11.267387]

int spell_skill2type(unsigned int skill)
{
    switch (skill)
    {
    case SK_CONJURATIONS:   return (SPTYP_CONJURATION);
    case SK_ENCHANTMENTS:   return (SPTYP_ENCHANTMENT);
    case SK_FIRE_MAGIC:     return (SPTYP_FIRE);
    case SK_ICE_MAGIC:      return (SPTYP_ICE);
    case SK_TRANSMIGRATION: return (SPTYP_TRANSMIGRATION);
    case SK_NECROMANCY:     return (SPTYP_NECROMANCY);
    case SK_SUMMONINGS:     return (SPTYP_SUMMONING);
    case SK_DIVINATIONS:    return (SPTYP_DIVINATION);
    case SK_TRANSLOCATIONS: return (SPTYP_TRANSLOCATION);
    case SK_POISON_MAGIC:   return (SPTYP_POISON);
    case SK_EARTH_MAGIC:    return (SPTYP_EARTH);
    case SK_AIR_MAGIC:      return (SPTYP_AIR);
    default:
    case SPTYP_HOLY:
#ifdef DEBUG_DIAGNOSTICS
        mprf(MSGCH_DIAGNOSTICS, "spell_skill2type: called with skill %u",
             spelltype );
#endif
        return (-1);
    }
}                               // end spell_type2skill()

Replacement in crawl-ref/source/spl-data.h at line 243 [11.268152]
B:BD[12.1358] → [12.1358:1403]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF,
```
[12.1358]
[12.1403]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 255 [11.268152]
B:BD[12.1504] → [12.1504:1549]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF,
```
[12.1504]
[12.1549]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 279 [11.268152]
B:BD[12.1761] → [12.1761:1788]
```
     SPFLAG_DIR_OR_TARGET,
```
[12.1761]
[12.1788]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 737 [11.268152]
B:BD[11.278495] → [13.2001:2036]
```
     SPFLAG_AREA | SPFLAG_NEUTRAL,
```
[11.278495]
[14.1489]
```
     SPFLAG_AREA | SPFLAG_NEUTRAL | SPFLAG_ESCAPE,
```
Replacement in crawl-ref/source/spl-data.h at line 943 [11.268152]
B:BD[11.280094] → [15.121409:121436]
```
     SPFLAG_DIR_OR_TARGET,
```
[11.280094]
[14.1843]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 990 [11.268152]
B:BD[11.280435] → [15.121494:121529]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF,
```
[11.280435]
[14.1919]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1038 [11.268152]
B:BD[11.280785] → [3.166:201]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF,
```
[11.280785]
[14.2013]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1050 [11.268152]
B:BD[11.280842] → [3.202:237]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF,
```
[11.280842]
[14.2050]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1243 [11.268152]
B:BD[11.282184] → [13.2602:2637]
```
     SPFLAG_AREA | SPFLAG_NEUTRAL,
```
[11.282184]
[14.2335]
```
     SPFLAG_AREA | SPFLAG_NEUTRAL | SPFLAG_ESCAPE,
```
Replacement in crawl-ref/source/spl-data.h at line 1435 [11.268152]
B:BD[11.283382] → [15.122347:122365]
```
     SPFLAG_NONE,
```
[11.283382]
[14.2601]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1447 [11.268152]
B:BD[11.283468] → [15.122366:122384]
```
     SPFLAG_NONE,
```
[11.283468]
[14.2620]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1459 [11.268152]
B:BD[11.283559] → [15.122385:122403]
```
     SPFLAG_NONE,
```
[11.283559]
[14.2639]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1471 [11.268152]
B:BD[11.283661] → [15.122404:122422]
```
     SPFLAG_NONE,
```
[11.283661]
[14.2658]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1483 [11.268152]
B:BD[11.283739] → [15.122450:122485]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF,
```
[11.283739]
[14.2677]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF | SPFLAG_DEVEL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1519 [11.268152]
B:BD[11.284062] → [15.122542:122560]
```
     SPFLAG_NONE,
```
[11.284062]
[16.6148]
```
     SPFLAG_CARD,
```
Replacement in crawl-ref/source/spl-data.h at line 1640 [11.268152]
B:BD[11.284935] → [13.3097:3118]
```
     SPFLAG_HELPFUL,
```
[11.284935]
[4.263]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1652 [11.268152]
B:BD[11.285081] → [13.3130:3151]
```
     SPFLAG_HELPFUL,
```
[11.285081]
[17.272]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1700 [11.268152]
B:BD[11.285413] → [15.122852:122879]
```
     SPFLAG_DIR_OR_TARGET,
```
[11.285413]
[14.2962]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_TESTING,
```
Replacement in crawl-ref/source/spl-data.h at line 1760 [11.268152]
B:BD[11.285790] → [15.122990:123017]
```
     SPFLAG_DIR_OR_TARGET,
```
[11.285790]
[14.3057]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_BATTLE | SPFLAG_DEVEL,
```
Replacement in crawl-ref/source/spl-data.h at line 1772 [11.268152]
B:BD[11.285870] → [15.123018:123063]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF,
```
[11.285870]
[14.3076]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF | SPFLAG_CARD,
```
Replacement in crawl-ref/source/spl-data.h at line 1784 [11.268152]
B:BD[11.285948] → [13.3295:3316]
```
     SPFLAG_HELPFUL,
```
[11.285948]
[14.3095]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1916 [11.268152]
B:BD[11.287042] → [3.238:273]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF,
```
[11.287042]
[14.3442]
```
     SPFLAG_DIR | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1928 [11.268152]
B:BD[11.287105] → [15.123359:123397]
```
     SPFLAG_TARGET | SPFLAG_NOT_SELF,
```
[11.287105]
[14.3461]
```
     SPFLAG_TARGET | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1964 [11.268152]
B:BD[11.287393] → [13.3641:3662]
```
     SPFLAG_HELPFUL,
```
[11.287393]
[14.3499]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 1999 [11.268152]
B:BD[11.287648] → [11.287648:287688]
```
     SPTYP_FIRE | SPTYP_TRANSMIGRATION,
```
[11.287648]
[13.3706]
```
     SPTYP_FIRE | SPTYP_TRANSMIGRATION | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 2084 [11.268152]
B:BD[11.288315] → [15.123680:123698]
```
     SPFLAG_NONE,
```
[11.288315]
[14.3689]
```
     SPFLAG_DEVEL,
```
Replacement in crawl-ref/source/spl-data.h at line 2144 [11.268152]
B:BD[11.288754] → [13.3874:3895]
```
     SPFLAG_HELPFUL,
```
[11.288754]
[14.3865]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 2204 [11.268152]
B:BD[11.289209] → [13.3999:4016]
```
     SPFLAG_DIR,
```
[11.289209]
[14.4026]
```
     SPFLAG_DIR | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 2288 [11.268152]
B:BD[11.289995] → [15.124056:124101]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF,
```
[11.289995]
[14.4232]
```
     SPFLAG_DIR_OR_TARGET | SPFLAG_NOT_SELF | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 2312 [11.268152]
B:BD[15.124162] → [13.4157:4178]
```
     SPFLAG_HELPFUL,
```
[15.124162]
[14.4270]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```
Replacement in crawl-ref/source/spl-data.h at line 2396 [11.268152]
B:BD[18.992] → [13.4307:4328]
```
     SPFLAG_HELPFUL,
```
[18.992]
[18.1010]
```
     SPFLAG_HELPFUL | SPFLAG_BATTLE,
```

Replacement in crawl-ref/source/spl-cast.h at line 17 [11.291319]

B:BD[19.45791] → [19.45791:46277]

B:BD[19.46277] → [20.223:424]

B:BD[20.424] → [13.4598:4830]

B:BD[13.4830] → [7.952:1085]

    SPFLAG_NONE                 = 0x0000,
    SPFLAG_DIR_OR_TARGET        = 0x0001,       // use DIR_NONE targeting
    SPFLAG_TARGET               = 0x0002,       // use DIR_TARGET targeting
    SPFLAG_GRID                 = 0x0004,       // use DIR_GRID targeting
    SPFLAG_DIR                  = 0x0008,       // use DIR_DIR targeting
    SPFLAG_TARGETING_MASK       = 0x000f,       // used to test for targeting
    SPFLAG_HELPFUL              = 0x0010,       // TARG_FRIENDS used
    SPFLAG_NEUTRAL              = 0x0020,       // TARG_ANY used
    SPFLAG_NOT_SELF             = 0x0040,       // aborts on isMe
    SPFLAG_UNHOLY               = 0x0080,       // counts at "unholy"
    SPFLAG_MAPPING              = 0x0100,       // a mapping spell of some kind
    SPFLAG_ESCAPE               = 0x0200,       // useful for running away
    SPFLAG_RECOVERY             = 0x0400,       // healing or recovery spell
    SPFLAG_AREA                 = 0x0800,       // area affect
    SPFLAG_MONSTER              = 0x1000        // monster-only spell

[19.45791]

[19.46413]

    SPFLAG_NONE                 = 0x00000,
    SPFLAG_DIR_OR_TARGET        = 0x00001,      // use DIR_NONE targeting
    SPFLAG_TARGET               = 0x00002,      // use DIR_TARGET targeting
    SPFLAG_GRID                 = 0x00004,      // use DIR_GRID targeting
    SPFLAG_DIR                  = 0x00008,      // use DIR_DIR targeting
    SPFLAG_TARGETING_MASK       = 0x0000f,      // used to test for targeting
    SPFLAG_HELPFUL              = 0x00010,      // TARG_FRIENDS used
    SPFLAG_NEUTRAL              = 0x00020,      // TARG_ANY used
    SPFLAG_NOT_SELF             = 0x00040,      // aborts on isMe
    SPFLAG_UNHOLY               = 0x00080,      // counts at "unholy"
    SPFLAG_MAPPING              = 0x00100,      // a mapping spell of some kind
    SPFLAG_ESCAPE               = 0x00200,      // useful for running away
    SPFLAG_RECOVERY             = 0x00400,      // healing or recovery spell
    SPFLAG_AREA                 = 0x00800,      // area affect
    SPFLAG_BATTLE               = 0x01000,      // a non-Conjuration spell that
                                                // is still a battle spell
    SPFLAG_CARD                 = 0x02000,      // a card effect spell
    SPFLAG_MONSTER              = 0x04000,      // monster-only spell
    SPFLAG_TESTING              = 0x08000,      // a testing/debugging spell
    SPFLAG_DEVEL                = 0x10000       // a spell under development

Insertion in crawl-ref/source/spl-cast.cc at line 979 [11.293070]

[15.129391]

[21.312]

    const bool wiz_cast = (crawl_state.prev_cmd == CMD_WIZARD && !allow_fail);

Replacement in crawl-ref/source/spl-cast.cc at line 986 [11.293070]
∅:D[22.288] → [14.5581:5582]
B:BD[15.129612] → [14.5581:5582]
B:BD[14.5582] → [23.2676:2713]
```
    if (_spell_is_uncastable(spell))
```
[22.288]
[14.5617]
```
    if (!wiz_cast && _spell_is_uncastable(spell))
```

Insertion in crawl-ref/source/spl-cast.cc at line 990 [11.293070]

[24.615]

[25.207]


    ASSERT(wiz_cast || !(flags & SPFLAG_TESTING));
    if ((flags & SPFLAG_TESTING) && !wiz_cast)
    {
        mprf(MSGCH_ERROR, "Spell %s is a testing spell, but you didn't use "
                          "the &Z wizard command; please file a bug report.",
             spell_title(spell));
        return (SPRET_ABORT);
    }

Deletion in crawl-ref/source/spl-book.h at line 15 [11.395672]
B:BD[11.395944] → [11.395944:395945]
B:BD[11.395945] → [7.1224:1285]
```
#define SPELLBOOK_SIZE 8
#define SPELL_LIST_KEY "spell_list"
```
Insertion in crawl-ref/source/spl-book.h at line 35 [11.395672]
[11.396673]
[11.396673]
```
void mark_had_book(const item_def &book);
void mark_had_book(int booktype);
```
Deletion in crawl-ref/source/spl-book.h at line 38 [11.395672]
B:BD[11.396674] → [26.145:179]
```
void mark_had_book(int booktype);
```

Insertion in crawl-ref/source/spl-book.h at line 68 [11.395672]

[27.189099]

[11.397570]

bool make_book_level_randart(item_def &book, int level = -1,
                             int num_spells = -1);
bool make_book_theme_randart(item_def &book,
                             int school_one = 0, int school_two = 0,
                             int num_spells = -1, int max_levels = -1);

Insertion in crawl-ref/source/spl-book.cc at line 15 [11.397614]
[11.398174]
[11.398174]
```
#include <algorithm>
```

Insertion in crawl-ref/source/spl-book.cc at line 41 [11.397614]

[11.398460]


#define SPELL_LIST_KEY "spell_list"
#define RANDART_BOOK_TYPE_KEY  "randart_book_type"
#define RANDART_BOOK_LEVEL_KEY "randart_book_level"
#define RANDART_BOOK_TYPE_LEVEL "level"
#define RANDART_BOOK_TYPE_THEME "theme"

Insertion in crawl-ref/source/spl-book.cc at line 1043 [11.397614]

[11.423091]

[26.245]


void mark_had_book(const item_def &book)
{
    ASSERT(book.base_type == OBJ_BOOKS);
    if (book.book_number() == BOOK_MANUAL
        || book.book_number() == BOOK_DESTRUCTION)
    {
        return;
    }
    for (int i = 0; i < SPELLBOOK_SIZE; i++)
    {
        spell_type stype = which_spell_in_book(book, i);
        if (stype == SPELL_NO_SPELL)
            continue;
        you.seen_spell[stype] = true;
    }

Insertion in crawl-ref/source/spl-book.cc at line 1063 [11.397614]

[26.246]

[11.423091]

    if (!book.props.exists( SPELL_LIST_KEY ))
        mark_had_book(book.book_number());
}

Insertion in crawl-ref/source/spl-book.cc at line 1069 [11.397614]

[11.423148]

[26.281]

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

Replacement in crawl-ref/source/spl-book.cc at line 1106 [11.397614]

B:BD[11.423496] → [7.2212:2289]

∅:D[7.2289] → [26.944:982]

B:BD[11.423533] → [26.944:982]

    if (book.base_type == OBJ_BOOKS && !book.props.exists( SPELL_LIST_KEY ))
        mark_had_book(book.sub_type);

[11.423496]

[11.423582]

    if (book.base_type == OBJ_BOOKS)
        mark_had_book(book);

Insertion in crawl-ref/source/spl-book.cc at line 1597 [11.397614]

[28.1931]

}
static bool _compare_spells(spell_type a, spell_type b)
{
    if (a == SPELL_NO_SPELL && b == SPELL_NO_SPELL)
        return (false);
    else if (a != SPELL_NO_SPELL && b == SPELL_NO_SPELL)
        return (true);
    else if (a == SPELL_NO_SPELL && b != SPELL_NO_SPELL)
        return (false);
    int level_a = spell_difficulty(a);
    int level_b = spell_difficulty(b);
    if (level_a != level_b)
        return (level_a < level_b);
    unsigned int schools_a = get_spell_disciplines(a);
    unsigned int schools_b = get_spell_disciplines(b);
    if (schools_a != schools_b && schools_a != 0 && schools_b != 0)
    {
        const char* a_type = NULL;
        const char* b_type = NULL;
        // Find lowest/earliest school for each spell.
        for (int i = 0; i <= SPTYP_LAST_EXPONENT; i++)
        {
            int mask = 1 << i;
            if (a_type == NULL && (schools_a & mask))
                a_type = spelltype_name(mask);
            if (b_type == NULL && (schools_b & mask))
                b_type = spelltype_name(mask);
        }
        ASSERT(a_type != NULL && b_type != NULL);
        return (strcmp(a_type, b_type));
    }
    return (strcmp(spell_title(a), spell_title(b)));
}
static bool _is_memorized(spell_type spell)
{
    for (int i = 0; i < 25; i++)
    {
        if (you.spells[i] == spell)
            return (true);
    }
    return (false);
}
bool make_book_level_randart(item_def &book, int level,
                             int num_spells)
{
    ASSERT(book.base_type == OBJ_BOOKS);
    ASSERT(book.book_number()    != BOOK_MANUAL
           && book.book_number() != BOOK_DESTRUCTION);
    ASSERT(is_random_artefact(book));
    ASSERT(!book.props.exists(SPELL_LIST_KEY));
    god_type god;
    (void) origin_is_god_gift(book, &god);
    const bool avoid_uncastable = (god != GOD_NO_GOD && god != GOD_XOM)
                                  || origin_is_acquirement(book);
    const bool track_levels_had = origin_is_acquirement(book)
                                  || god == GOD_SIF_MUNA;
    if (level == -1)
    {
        int max_level =
            avoid_uncastable ? std::min(9, you.get_experience_level())
                             : 9;
        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)
        {
            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())];
        }
    }
    ASSERT(level > 0 && level <= 9);
    if (num_spells == -1)
        num_spells = SPELLBOOK_SIZE;
    ASSERT(num_spells > 0 && num_spells <= SPELLBOOK_SIZE);
    int god_discard        = 0;
    int uncastable_discard = 0;
    std::vector<spell_type> spell_list;
    for (int i = 0; i < NUM_SPELLS; i++)
    {
        const spell_type spell = (spell_type) i;
        if (!is_valid_spell(spell))
            continue;
        if (spell_difficulty(spell) != level)
            continue;
        const unsigned int flags   = get_spell_flags(spell);
        const unsigned int schools = get_spell_disciplines(spell);
        // Don't include schoolless spells, like Smiting.
        if (schools == 0)
            continue;
        // Holy spells don't show up in books.
        if (schools & SPTYP_HOLY)
            continue;
        if (flags & (SPFLAG_MONSTER | SPFLAG_CARD | SPFLAG_TESTING))
            continue;
        // Only wizards gets spells still under development.
        if (flags & SPFLAG_DEVEL)
        {
#ifdef WIZARD
            if (!you.wizard)
                continue;
#else
            continue;
#endif
        }
        if (avoid_uncastable && undead_cannot_memorise(spell, you.is_undead))
        {
            uncastable_discard++;
            continue;
        }
        if (god_dislikes_spell_type(spell, god))
        {
            god_discard++;
            continue;
        }
        // Passed all tests.
        spell_list.push_back(spell);
    }
    if (spell_list.empty())
    {
        char buf[80];
        if (god_discard > 0 && uncastable_discard == 0)
            sprintf(buf, "%s disliked all level %d spells",
                    god_name(god).c_str(), level);
        else if (god_discard == 0 && uncastable_discard > 0)
            sprintf(buf, "No level %d spells can be cast by you", level);
        else if (god_discard > 0 && uncastable_discard > 0)
            sprintf(buf, "All level %d spells are either disliked by %s "
                         "or cannot be cast by you.",
                    level, god_name(god).c_str());
        else
            sprintf(buf, "No level %d spells?!?!?!", level);
        mprf(MSGCH_ERROR, "Could not create fixed level randart spellbook: %s",
             buf);
        return (false);
    }
    random_shuffle(spell_list.begin(), spell_list.end());
    if (num_spells > (int) spell_list.size())
    {
        num_spells = spell_list.size();
#if DEBUG || DEBUG_DIAGNOSTICS
        // Not many level 8 or 9 spells
        if (level < 8)
        {
            mprf(MSGCH_WARN, "More spells requested for fixed level (%d) "
                             "randart spellbook than there are valid spells.",
                 level);
            mprf(MSGCH_WARN, "Discarded %d spells due to being uncastable and "
                             "%d spells due to being disliked by %s.",
                 uncastable_discard, god_discard, god_name(god).c_str());
        }
#endif
    }
    std::vector<bool> spell_used(spell_list.size(), false);
    std::vector<bool> avoid_memorised(spell_list.size(), true);
    spell_type chosen_spells[SPELLBOOK_SIZE];
    for (int i = 0; i < SPELLBOOK_SIZE; i++)
    {
        chosen_spells[i] = SPELL_NO_SPELL;
    }
    int book_pos = 0;
    while (book_pos < num_spells)
    {
        int spell_pos = random2(spell_list.size());
        if (spell_used[spell_pos])
            continue;
        spell_type spell = spell_list[spell_pos];
        ASSERT(spell != SPELL_NO_SPELL);
        if (avoid_memorised[spell_pos] && _is_memorized(spell))
        {
           // Only once.
           avoid_memorised[spell_pos] = false;
           continue;
        }
        spell_used[spell_pos]     = true;
        chosen_spells[book_pos++] = spell;
    }
    std::sort(chosen_spells, chosen_spells + SPELLBOOK_SIZE,
              _compare_spells);
    ASSERT(chosen_spells[0] != SPELL_NO_SPELL);
    CrawlHashTable &props = book.props;
    if (!props.exists( SPELL_LIST_KEY ))
        props[SPELL_LIST_KEY].new_vector(SV_LONG).resize(SPELLBOOK_SIZE);
    CrawlVector &spell_vec = props[SPELL_LIST_KEY];
    spell_vec.set_max_size(SPELLBOOK_SIZE);
    for (int i = 0; i < SPELLBOOK_SIZE; i++)
        spell_vec[i] = (long) chosen_spells[i];
    if (track_levels_had)
        you.attribute[ATTR_RND_LVL_BOOKS] |= (1 << level);
    return (true);

Insertion in crawl-ref/source/religion.h at line 111 [11.800304]

[29.2915]

[6.2446]


bool god_dislikes_spell_type(spell_type spell, god_type god = you.religion);
bool god_dislikes_spell_school(int school, god_type god = you.religion);

Insertion in crawl-ref/source/religion.h at line 117 [11.800304]
[30.189]
[2.2533]
Insertion in crawl-ref/source/religion.cc at line 65 [11.804403]
[31.257]
[32.67354]
```
#include "spl-cast.h"
```

Insertion in crawl-ref/source/religion.cc at line 3440 [11.804403]

[33.3723]

            return (true);
    }
    return (false);
}
bool god_dislikes_spell_type(spell_type spell, god_type god)
{
    if (god == GOD_NO_GOD)
        return (false);
    unsigned int flags   = get_spell_flags(spell);
    unsigned int schools = get_spell_disciplines(spell);
    if (is_good_god(god))
    {
        if ((flags & SPFLAG_UNHOLY) || (schools & SPTYP_NECROMANCY))
            return (true);
    }
    switch(god)
    {
    case GOD_ZIN:
        if (spell == SPELL_POLYMORPH_OTHER || spell == SPELL_ALTER_SELF)
            return (true);
        break;
    case GOD_SHINING_ONE:
        // TSO dislikes using poison, but is fine with curing it, resisting
        // it or destroying it.
        if ((schools & SPTYP_POISON) && spell != SPELL_CURE_POISON_I
            && spell != SPELL_CURE_POISON_II && spell != SPELL_RESIST_POISON
            && spell != SPELL_IGNITE_POISON)
        {
            return (true);
        }
        // He probably also wouldn't like spells which would put enemies
        // into a state where attacking them would be unchivalrous.
        if (spell == SPELL_CAUSE_FEAR || spell == SPELL_PARALYSE
            || spell == SPELL_CONFUSE || spell == SPELL_MASS_CONFUSION
            || spell == SPELL_SLEEP   || spell == SPELL_MASS_SLEEP)
        {
            return (true);
        }
        break;
    case GOD_YREDELEMNUL:
        if (schools & SPTYP_HOLY)
            return (true);
        break;
    case GOD_XOM:
        // Ideally, Xom would only like spells which have a random effect,
        // are risky to use, or would otherwise amuse him, but that would
        // be a really small number of spells.
        // Xom would probably find these extra boring.
        if (flags & (SPFLAG_HELPFUL | SPFLAG_NEUTRAL | SPFLAG_ESCAPE
                     | SPFLAG_RECOVERY | SPFLAG_MAPPING))
        {

Insertion in crawl-ref/source/religion.cc at line 3502 [11.804403]

[33.3750]

        }
        // Things are more fun for Xom the less the player knows in
        // advance.
        if (schools & SPTYP_DIVINATION)
            return (true);
        // Holy spells are probably too useful for Xom to find them
        // interesting.
        if (schools & SPTYP_HOLY)
            return (true);
        break;
    case GOD_ELYVILON:
        // A peaceful god of healing wouldn't like combat spells.
        if (schools & SPTYP_CONJURATION)
            return (true);
        // Also doesn't like battle spells of the non-conjuration type.
        if (flags & SPFLAG_BATTLE)
            return true;
        break;
    default:
        break;

Insertion in crawl-ref/source/religion.cc at line 3531 [11.804403]

[29.3258]


bool god_dislikes_spell_school(int school, god_type god)
{
    if (god == GOD_NO_GOD)
        return (false);
    if (is_good_god(god) && school == SPTYP_NECROMANCY)
        return (true);

Insertion in crawl-ref/source/religion.cc at line 3540 [11.804403]

[29.3259]

[34.4300]

    switch(god)
    {
    case GOD_SHINING_ONE:
        return (school == SPTYP_POISON);
    case GOD_YREDELEMNUL:
        return (school == SPTYP_HOLY);
    case GOD_XOM:
        return (school == SPTYP_DIVINATION || school == SPTYP_HOLY);
    case GOD_ELYVILON:
        return (school == SPTYP_CONJURATION);
    default:
        break;
    }
    return (false);
}

Deletion in crawl-ref/source/randart.cc at line 29 [11.893152]
B:BD[7.4943] → [7.4943:4987]
```
#include "spl-cast.h"
#include "spl-util.h"
```
Insertion in crawl-ref/source/randart.cc at line 35 [11.893152]
[35.2742]
[36.2595]
```
#define SPELL_LIST_KEY "spell_list"
#define SPELLBOOK_SIZE 8
```

Replacement in crawl-ref/source/randart.cc at line 82 [11.893152]

B:BD[8.4165] → [8.4165:4218]

    case GOD_TROG: // hates anything enhancing magic

[8.4165]

[8.4218]

    case GOD_TROG:
        // Trog hates spell use.
        if (item.base_type == OBJ_BOOKS)
            type_bad = true;
        // hates anything enhancing magic

Deletion in crawl-ref/source/randart.cc at line 178 [11.893152]
B:BD[37.5345] → [37.5345:5347]
∅:D[37.5347] → [11.903224:903225]
B:BD[11.903224] → [11.903224:903225]
B:BD[11.903225] → [38.2841:2893]
∅:D[38.2893] → [37.5472:5474]
∅:D[39.2973] → [37.5472:5474]
B:BD[37.5472] → [37.5472:5474]
∅:D[40.9410] → [37.5511:5570]
B:BD[37.5511] → [37.5511:5570]
B:BD[37.5570] → [39.2974:2975]
∅:D[39.2975] → [37.5570:5756]
B:BD[37.5570] → [37.5570:5756]
B:BD[37.5756] → [39.2976:2998]
```
}
static god_type _gift_from_god(const item_def item)
{
    // maybe god gift?
    god_type god_gift = GOD_NO_GOD;
    if (item.orig_monnum < 0)
    {
        int help = -item.orig_monnum - 2;
        if (help > GOD_NO_GOD && help < NUM_GODS)
            god_gift = static_cast<god_type>(help);
    }
    return god_gift;
```

Replacement in crawl-ref/source/randart.cc at line 181 [11.893152]

B:BD[38.2960] → [38.2960:3020]

                                       const item_def item)

[38.2960]

[39.3125]

                                       const item_def& item)

Replacement in crawl-ref/source/randart.cc at line 185 [11.893152]

B:BD[39.3160] → [38.3021:3067]

    god_type god_gift = _gift_from_god(item);

[39.3160]

[11.904871]

    god_type god_gift;
    (void) origin_is_god_gift(item, &god_gift);

Replacement in crawl-ref/source/randart.cc at line 1125 [11.893152]

B:BD[7.5101] → [7.5101:5168]

static bool _compare_spell_dificulties(spell_type a, spell_type b)

[7.5101]

[7.5168]

static bool _init_randart_book(item_def &book)

Replacement in crawl-ref/source/randart.cc at line 1127 [11.893152]

B:BD[7.5170] → [7.5170:6301]

∅:D[7.6301] → [41.4178:4184]

B:BD[42.2727] → [41.4178:4184]

B:BD[41.4184] → [7.6302:6719]

    return (spell_difficulty(a) < spell_difficulty(b));
}
static void _init_randart_book(item_def &book)
{
    spell_type spells[SPELLBOOK_SIZE];
    int        spell_count = 0;
    while(spell_count < SPELLBOOK_SIZE)
    {
        spell_type spl = static_cast<spell_type>(random2(NUM_SPELLS));
        if (!is_valid_spell(spl))
            continue;
        // Skip monster only spells.
        if (get_spell_flags(spl) & SPFLAG_MONSTER)
            continue;
        // Holy spells don't show up in books.
        if (spell_typematch(spl, SPTYP_HOLY))
            continue;
        // Don't include schoolless spells, like Smiting.
        if (get_spell_disciplines(spl) == 0)
            continue;
        // This spell passes all of the other checks.
        if (spl == SPELL_DEBUGGING_RAY)
            continue;
        // No duplicate spells.
        bool present = false;
        for (int i = 0; i < spell_count; i++)
            if (spells[i] == spl)
            {
                present = true;
                break;
            }
        if (present)
            continue;
        spells[spell_count++] = spl;
    }
    std::sort(spells, spells + SPELLBOOK_SIZE, _compare_spell_dificulties);
    CrawlHashTable &props = book.props;
    if (!props.exists( SPELL_LIST_KEY ))
        props[SPELL_LIST_KEY].new_vector(SV_LONG).resize(SPELLBOOK_SIZE);
    CrawlVector &spell_vec = props[SPELL_LIST_KEY];
    spell_vec.set_max_size(SPELLBOOK_SIZE);
    for (int i = 0; i < SPELLBOOK_SIZE; i++)
        spell_vec[i] = (long) spells[i];

[7.5170]

[35.2868]

    return make_book_level_randart(book, -1, 8);

Replacement in crawl-ref/source/randart.cc at line 1130 [11.893152]
B:BD[41.4185] → [35.2871:2924]
```
void static _init_randart_properties(item_def &item)
```
[41.4185]
[35.2924]
```
static bool _init_randart_properties(item_def &item)
```
Replacement in crawl-ref/source/randart.cc at line 1150 [11.893152]
B:BD[35.3500] → [35.3500:3516]
```
        return;
```
[35.3500]
[35.3516]
```
        return (true);
```

Replacement in crawl-ref/source/randart.cc at line 1154 [11.893152]

B:BD[7.6757] → [7.6757:6819]

    {
        _init_randart_book(item);
        return;
    }

[7.6757]

[7.6819]

        return _init_randart_book(item);

Insertion in crawl-ref/source/randart.cc at line 1161 [11.893152]
[35.3631]
[41.4265]
```
    return (true);
```
Replacement in crawl-ref/source/randart.cc at line 1371 [11.893152]
B:BD[37.9067] → [37.9067:9107]
```
            item_orig = -item_orig - 2;
```
[37.9067]
[11.928364]
```
            item_orig = -item_orig;
```

Replacement in crawl-ref/source/randart.cc at line 2050 [11.893152]

B:BD[43.2772] → [38.5355:5401]

    god_type god_gift = _gift_from_god(item);

[43.2772]

[39.3500]

    god_type god_gift;
    (void) origin_is_god_gift(item, &god_gift);

Replacement in crawl-ref/source/randart.cc at line 2057 [11.893152]

B:BD[41.6713] → [41.6713:6753]

        _init_randart_properties(item);

[41.6713]

[43.2918]

        if (!_init_randart_properties(item))
        {
            // Something went wrong that no amount of changing
            // item.special will fix.
            item.special = 0;
            item.props.erase(RANDART_PROPS_KEY);
            item.props.erase(KNOWN_PROPS_KEY);
            item.flags &= ~ISFLAG_RANDART;
            return (false);
        }

Replacement in crawl-ref/source/newgame.cc at line 862 [11.1132300]
B:BD[44.3849] → [26.1061:1109]
```
            mark_had_book(you.inv[i].sub_type);
```
[44.3849]
[44.4565]
```
            mark_had_book(you.inv[i]);
```

Replacement in crawl-ref/source/items.h at line 15 [11.2580284]

B:BD[19.73895] → [19.73895:73970]

// Various ways to get the acquirement effect.
enum acquirement_agent_type

[19.73895]

[19.73970]

// Ways to get items, other than finding them on the ground or looting them
// from slain monsters.
enum item_source_type

Replacement in crawl-ref/source/items.h at line 19 [11.2580284]
B:BD[19.73972] → [19.73972:73993]
```
    AQ_SCROLL   = 0,
```
[19.73972]
[45.2630]
```
    IT_SRC_NONE   = 0,
```
Replacement in crawl-ref/source/items.h at line 23 [11.2580284]
∅:D[45.2633] → [19.74035:74060]
B:BD[19.74035] → [19.74035:74060]
```
    AQ_CARD_GENIE = 100,
```
[45.2633]
[11.2580692]
```
    AQ_SCROLL     = 100,
    AQ_CARD_GENIE,
    IT_SRC_START,
    IT_SRC_SHOP,
```

Replacement in crawl-ref/source/items.h at line 28 [11.2580284]

B:BD[11.2580693] → [19.74061:74091]

    AQ_WIZMODE          = 200

[11.2580693]

[19.74091]

    // Empty space for new non-wizmode acquisition methods
    AQ_WIZMODE    = 200

Replacement in crawl-ref/source/items.h at line 144 [11.2580284]

B:BD[27.342698] → [46.2543:2590]

bool origin_is_god_gift(const item_def& item);

[27.342698]

[47.3609]

bool origin_is_god_gift(const item_def& item, god_type *god = NULL);
bool origin_is_acquirement(const item_def& item,
                           item_source_type *type = NULL);

Replacement in crawl-ref/source/items.cc at line 875 [11.2584728]
B:BD[27.344972] → [27.344972:345003]
```
        item.orig_monnum = -1;
```
[27.344972]
[27.345003]
```
        item.orig_monnum = -IT_SRC_START;
```
Replacement in crawl-ref/source/items.cc at line 903 [11.2584728]
∅:D[48.4651] → [27.345400:345444]
B:BD[27.345400] → [27.345400:345444]
```
    // Hackiness
    item.orig_monnum = -1;
```
[48.4651]
[27.345444]
```
    item.orig_monnum = -IT_SRC_SHOP;
```
Replacement in crawl-ref/source/items.cc at line 911 [11.2584728]
∅:D[48.4688] → [27.345605:345657]
B:BD[27.345605] → [27.345605:345657]
```
    // Hackiness
    item.orig_monnum = -2 - agent;
```
[48.4688]
[27.345657]
```
    item.orig_monnum = -agent;
```

Replacement in crawl-ref/source/items.cc at line 1067 [11.2584728]

B:BD[27.349031] → [27.349031:349098]

    return (item.orig_place == 0xFFFFU && item.orig_monnum == -1);

[27.349031]

[27.349098]

    return (item.orig_place == 0xFFFFU && item.orig_monnum == -IT_SRC_START);

Replacement in crawl-ref/source/items.cc at line 1070 [11.2584728]
B:BD[27.349101] → [46.2592:2638]
```
bool origin_is_god_gift(const item_def& item)
```
[27.349101]
[46.2638]
```
bool origin_is_god_gift(const item_def& item, god_type *god)
```

Replacement in crawl-ref/source/items.cc at line 1072 [11.2584728]

B:BD[46.2640] → [46.2640:2697]

    if (!origin_describable(item))
        return false;

[46.2640]

[49.6858]

    god_type junk;
    if (god == NULL)
        god = &junk;
    *god = GOD_NO_GOD;
    const int iorig = -item.orig_monnum;
    if (iorig > GOD_NO_GOD && iorig < NUM_GODS)
    {
        *god = static_cast<god_type>(iorig);
        return(true);
    }

Replacement in crawl-ref/source/items.cc at line 1084 [11.2584728]

∅:D[49.6859] → [46.2702:2765]

B:BD[46.2702] → [46.2702:2765]

    if (_origin_is_original_equip(item))
        return false;

[49.6859]

[49.6860]

    return (false);
}
bool origin_is_acquirement(const item_def& item, item_source_type *type)
{
    item_source_type junk;
    if (type == NULL)
        type = &junk;
    *type = IT_SRC_NONE;

Replacement in crawl-ref/source/items.cc at line 1094 [11.2584728]

∅:D[49.6861] → [46.2770:2823]

B:BD[46.2770] → [46.2770:2823]

    if (item.orig_monnum >= 0)
        return false;

[49.6861]

[46.2823]

    const int iorig = -item.orig_monnum;
    if (iorig == AQ_SCROLL || iorig == AQ_CARD_GENIE
        || iorig == AQ_WIZMODE)
    {
        *type = static_cast<item_source_type>(iorig);
        return (true);
    }

Replacement in crawl-ref/source/items.cc at line 1102 [11.2584728]

B:BD[46.2824] → [46.2824:2926]

    const int iorig = -item.orig_monnum - 2;
    return (iorig > AQ_SCROLL && iorig < AQ_CARD_GENIE);

[46.2824]

[46.2926]

    return (false);

Replacement in crawl-ref/source/items.cc at line 1118 [11.2584728]
B:BD[27.349382] → [27.349382:349429]
```
            int iorig = -item.orig_monnum - 2;
```
[27.349382]
[27.349429]
```
            int iorig = -item.orig_monnum;
```
Replacement in crawl-ref/source/items.cc at line 1121 [11.2584728]
B:BD[27.349470] → [27.349470:349491]
```
            case -1:
```
[27.349470]
[50.7643]
```
            case IT_SRC_SHOP:
```

Insertion in crawl-ref/source/items.cc at line 1124 [11.2584728]

[27.349588]

            case IT_SRC_START:
                desc += "Buggy Original Equipment: ";
                break;

Replacement in crawl-ref/source/externs.h at line 879 [11.3270163]

B:BD[11.3279029] → [51.14556:14597]

  FixedVector<bool, NUM_BOOKS> had_book;

[11.3279029]

[11.3279072]

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

Insertion in crawl-ref/source/enum.h at line 168 [11.3287960]

[52.3549]

[51.14625]

    ATTR_RND_LVL_BOOKS,        // Bitfield of level-type randart spellbooks
                               // player has seen.

Replacement in crawl-ref/source/effects.cc at line 1580 [11.3382105]
B:BD[11.3418037] → [26.2055:2098]
```
            mark_had_book(thing.sub_type);
```
[15.942375]
[15.942727]
```
            mark_had_book(thing);
```

Replacement in crawl-ref/source/effects.cc at line 1705 [11.3382105]

B:BD[11.3424704] → [53.3200:3256]

        if (agent > AQ_SCROLL && agent == you.religion)

[11.3424704]

[54.6351]

        if (agent > GOD_NO_GOD && agent < NUM_GODS && agent == you.religion)

Replacement in crawl-ref/source/describe.cc at line 2071 [11.3736416]

B:BD[55.1426] → [55.1426:1488]

        which_spell_in_book(item.book_number(), spell_index);

[55.1426]

[55.1488]

        which_spell_in_book(item, spell_index);

Insertion in crawl-ref/source/dat/descript/spells.txt at line 177 [56.2853]
[56.9614]
[56.9614]
```
%%%%
Debugging Ray
A ray which does massive damage (1500 hp) and always hits.
```

Replacement in crawl-ref/source/command.cc at line 1053 [11.4082507]

B:BD[57.1818] → [58.6775:6826]

    return (spell_by_name(key) == SPELL_NO_SPELL);

[57.1818]

[59.51401]

    spell_type spell = spell_by_name(key);
    if (spell == SPELL_NO_SPELL)
        return (true);
    if (get_spell_flags(spell) & (SPFLAG_MONSTER | SPFLAG_TESTING
                                  | SPFLAG_DEVEL))
    {
#ifdef WIZARD
        return (!you.wizard);
#else
        return (true);
#endif
    }
    return (false);

Insertion in crawl-ref/source/command.cc at line 1122 [11.4082507]

[60.2799]

    }
}
// Extra info on this item wasn't found anywhere else.
static void _append_non_item(std::string &desc, std::string key)
{
    spell_type type = spell_by_name(key, true);
    if (type == SPELL_NO_SPELL)
        return;
    unsigned int flags = get_spell_flags(type);
    if (flags & SPFLAG_DEVEL)
        desc += "$This spell is still being developped, and is only avaible "
                "via the &Z wizard command.";
    else if (flags & SPFLAG_TESTING)
        desc += "$This is a testing spell, only avaible via the "
                "&Z wizard command.";
    else if (flags & SPFLAG_MONSTER)
        desc += "$This is a monster-only spell, only avaible via the "
                "&Z wizard command.";
    else if (flags & SPFLAG_CARD)
        desc += "$This is a card-effect spell, unavailable in ordinary "
                "spellbooks.";
    else
        desc += "$Odd, this spell can't be found anywhere.  Please "
                "file a bug report.";
#ifdef WIZARD
    if (!you.wizard)
#else
    if (true)
#endif
    {
        if (flags & (SPFLAG_TESTING | SPFLAG_MONSTER | SPFLAG_DEVEL))
            desc += "$$You aren't in wizard mode, so you shouldn't be "
                    "seeing this entry.  Please file a bug report.";

Deletion in crawl-ref/source/command.cc at line 1219 [11.4082507]
B:BD[60.3810] → [60.3810:3874]
```
    if (books.empty() && rods.empty())
        return (false);
```

Insertion in crawl-ref/source/command.cc at line 1412 [11.4082507]

[5.5776]

[61.13106]

                else
                    _append_non_item(desc, key);

Replacement in crawl-ref/source/acr.cc at line 517 [11.4397395]

B:BD[62.4400] → [63.26393:26456]

        if (!_item_type_can_be_artefact(you.inv[i].base_type))

[62.4400]

[62.4552]

        item_def &item(you.inv[i]);
        if (!_item_type_can_be_artefact(item.base_type))

Replacement in crawl-ref/source/acr.cc at line 534 [11.4397395]

B:BD[11.4410268] → [11.4410268:4410322]

                if (is_random_artefact( you.inv[i] ))

[11.4410268]

[11.4410322]

                if (is_random_artefact( item ))

Replacement in crawl-ref/source/acr.cc at line 540 [11.4397395]

B:BD[11.4410411] → [7.8383:8429]

        if (!make_item_randart( you.inv[i] ))

[11.4410411]

[7.8429]

        if (is_random_artefact(item))
        {
            if (!yesno("Is already a randart; wipe and re-use?"))
            {
                canned_msg( MSG_OK );
                // If equipped, re-apply benefits.
                if (j != NUM_EQUIP)
                    use_randart( i );
                return;
            }
            item.special = 0;
            item.flags  &= ~ISFLAG_RANDART;
            item.props.clear();
        }
  
        if (!make_item_randart( item ))

Replacement in crawl-ref/source/acr.cc at line 564 [11.4397395]
B:BD[64.7889] → [64.7889:7933]
```
            add_autoinscription(you.inv[i],
```
[64.7889]
[64.7933]
```
            add_autoinscription(item,
```

Replacement in crawl-ref/source/acr.cc at line 572 [11.4397395]

B:BD[11.4410562] → [65.31247:31309]

        mpr( you.inv[i].name(DESC_INVENTORY_EQUIP).c_str() );

[11.4410562]

[11.4410644]

        mpr( item.name(DESC_INVENTORY_EQUIP).c_str() );

Savefile compatibility breakage from keeping track of which spells have been

Dependencies

In channels

Change contents

Replacement in crawl-ref/source/xom.cc at line 469 [10.3]

Insertion in crawl-ref/source/tags.cc at line 1085 [11.164589]

Insertion in crawl-ref/source/tags.cc at line 1529 [11.164589]

Insertion in crawl-ref/source/spl-util.h at line 139 [11.242902]

Insertion in crawl-ref/source/spl-util.cc at line 830 [11.245665]

Replacement in crawl-ref/source/spl-data.h at line 243 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 255 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 279 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 737 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 943 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 990 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1038 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1050 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1243 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1435 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1447 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1459 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1471 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1483 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1519 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1640 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1652 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1700 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1760 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1772 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1784 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1916 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1928 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1964 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 1999 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 2084 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 2144 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 2204 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 2288 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 2312 [11.268152]

Replacement in crawl-ref/source/spl-data.h at line 2396 [11.268152]

Replacement in crawl-ref/source/spl-cast.h at line 17 [11.291319]

Insertion in crawl-ref/source/spl-cast.cc at line 979 [11.293070]

Replacement in crawl-ref/source/spl-cast.cc at line 986 [11.293070]

Insertion in crawl-ref/source/spl-cast.cc at line 990 [11.293070]

Deletion in crawl-ref/source/spl-book.h at line 15 [11.395672]

Insertion in crawl-ref/source/spl-book.h at line 35 [11.395672]

Deletion in crawl-ref/source/spl-book.h at line 38 [11.395672]

Insertion in crawl-ref/source/spl-book.h at line 68 [11.395672]

Insertion in crawl-ref/source/spl-book.cc at line 15 [11.397614]

Insertion in crawl-ref/source/spl-book.cc at line 41 [11.397614]

Insertion in crawl-ref/source/spl-book.cc at line 1043 [11.397614]

Insertion in crawl-ref/source/spl-book.cc at line 1063 [11.397614]

Insertion in crawl-ref/source/spl-book.cc at line 1069 [11.397614]

Replacement in crawl-ref/source/spl-book.cc at line 1106 [11.397614]

Insertion in crawl-ref/source/spl-book.cc at line 1597 [11.397614]

Insertion in crawl-ref/source/religion.h at line 111 [11.800304]

Insertion in crawl-ref/source/religion.h at line 117 [11.800304]

Insertion in crawl-ref/source/religion.cc at line 65 [11.804403]

Insertion in crawl-ref/source/religion.cc at line 3440 [11.804403]

Insertion in crawl-ref/source/religion.cc at line 3502 [11.804403]

Insertion in crawl-ref/source/religion.cc at line 3531 [11.804403]

Insertion in crawl-ref/source/religion.cc at line 3540 [11.804403]

Deletion in crawl-ref/source/randart.cc at line 29 [11.893152]

Insertion in crawl-ref/source/randart.cc at line 35 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 82 [11.893152]

Deletion in crawl-ref/source/randart.cc at line 178 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 181 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 185 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 1125 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 1127 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 1130 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 1150 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 1154 [11.893152]

Insertion in crawl-ref/source/randart.cc at line 1161 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 1371 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 2050 [11.893152]

Replacement in crawl-ref/source/randart.cc at line 2057 [11.893152]

Replacement in crawl-ref/source/newgame.cc at line 862 [11.1132300]

Replacement in crawl-ref/source/items.h at line 15 [11.2580284]

Replacement in crawl-ref/source/items.h at line 19 [11.2580284]