fiddlerwoaroof/crawl - Change E76RRHMXEPJCNDNKMI3AP7OI7IOMXXRHVYWRIYA75BQMMIST2XRAC

Slightly reduce religion.cc by yanking item-handling stuff to goditem.cc

Created by Adam Borowski on October 21, 2009

E76RRHMXEPJCNDNKMI3AP7OI7IOMXXRHVYWRIYA75BQMMIST2XRAC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/xom.cc at line 17 [11.3]
[11.247]
[11.247]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/view.cc at line 36 [14.16817]
[12.27]
[13.1534]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/spl-cast.cc at line 21 [14.293070]
[15.330]
[16.186]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/spl-book.cc at line 29 [14.397614]
[17.327]
[14.398273]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/spells3.cc at line 29 [14.531613]
[18.46771]
[14.532213]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/spells2.cc at line 27 [14.569242]
[14.570207]
[19.318]
```
#include "goditem.h"
```

Deletion in crawl-ref/source/religion.h at line 126 [14.800304]

∅:D[20.4325] → [21.2615:2656]

∅:D[22.5052] → [21.2615:2656]

∅:D[7.10479] → [21.2615:2656]

B:BD[23.2622] → [21.2615:2656]

∅:D[23.2622] → [24.2557:2598]

∅:D[21.2656] → [24.2557:2598]

B:BD[25.442] → [24.2557:2598]

B:BD[24.2598] → [26.10918:10962]

B:BD[26.10962] → [27.2687:2967]

B:BD[27.2967] → [28.2797:2863]

∅:D[28.2863] → [27.2967:3403]

B:BD[27.2967] → [27.2967:3403]

B:BD[27.3403] → [29.2695:2743]

∅:D[29.2743] → [27.3454:3577]

B:BD[27.3454] → [27.3454:3577]

B:BD[27.3577] → [29.2744:2786]

B:BD[29.2786] → [30.3216:3341]

∅:D[30.3341] → [29.2895:2969]

B:BD[29.2895] → [29.2895:2969]

bool is_holy_item(const item_def& item);
bool is_evil_item(const item_def& item);
bool is_chaotic_item(const item_def& item);
bool is_holy_discipline(int discipline);
bool is_evil_discipline(int discipline);
bool is_holy_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_evil_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_chaotic_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_hasty_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_any_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_spellbook_type(const item_def& item, bool book_or_rod,
                       bool (*suitable)(spell_type spell, god_type god) =
                           is_any_spell,
                       god_type god = you.religion);
bool is_holy_spellbook(const item_def& item);
bool is_evil_spellbook(const item_def& item);
bool is_chaotic_spellbook(const item_def& item);
bool god_hates_spellbook(const item_def& item);
bool is_holy_rod(const item_def& item);
bool is_evil_rod(const item_def& item);
bool is_chaotic_rod(const item_def& item);
bool god_hates_rod(const item_def& item);
conduct_type good_god_hates_item_handling(const item_def &item);
conduct_type god_hates_item_handling(const item_def &item);
bool god_hates_spell_type(spell_type spell, god_type god = you.religion);

Deletion in crawl-ref/source/religion.h at line 127 [14.800304]

B:BD[31.15806] → [32.12930:13037]

∅:D[32.13037] → [31.15806:15883]

B:BD[31.15806] → [31.15806:15883]

B:BD[31.15883] → [27.3623:3704]

B:BD[27.3704] → [8.3175:3176]

// NOTE: As of now, these two functions only say if a god won't give a
// spell/school when giving a gift.
bool god_dislikes_spell_type(spell_type spell, god_type god = you.religion);
bool god_dislikes_spell_discipline(int discipline, god_type god = you.religion);

Insertion in crawl-ref/source/religion.cc at line 39 [14.804403]
[14.805453]
[4.2647]
```
#include "goditem.h"
```
Deletion in crawl-ref/source/religion.cc at line 70 [14.804403]
∅:D[33.2530] → [34.235:257]
B:BD[14.805742] → [34.235:257]
B:BD[34.257] → [31.15961:15983]
```
#include "spl-book.h"
#include "spl-cast.h"
```
Deletion in crawl-ref/source/religion.cc at line 71 [14.804403]
∅:D[35.67375] → [18.47108:47130]
B:BD[14.805764] → [18.47108:47130]
```
#include "spl-util.h"
```

Deletion in crawl-ref/source/religion.cc at line 3854 [14.804403]

B:BD[36.7334] → [21.3165:3235]

B:BD[21.3235] → [37.6905:7014]

B:BD[37.7014] → [3.2626:2671]

∅:D[3.2671] → [37.7060:7093]

B:BD[37.7060] → [37.7060:7093]

∅:D[37.7093] → [21.3235:3292]

B:BD[21.3235] → [21.3235:3292]

B:BD[21.3292] → [38.2597:2704]

∅:D[38.2704] → [21.3409:3424]

∅:D[26.11663] → [21.3409:3424]

B:BD[21.3409] → [21.3409:3424]

B:BD[21.3434] → [21.3434:3507]

B:BD[21.3507] → [27.3706:3855]

∅:D[27.3855] → [21.3507:3522]

B:BD[21.3507] → [21.3507:3522]

∅:D[39.2513] → [21.3522:3578]

B:BD[21.3522] → [21.3522:3578]

∅:D[40.444] → [41.5267:5269]

∅:D[42.3340] → [41.5267:5269]

∅:D[21.3578] → [41.5267:5269]

∅:D[36.7334] → [41.5267:5269]

B:BD[13.191649] → [41.5267:5269]

∅:D[41.5269] → [14.849711:849712]

∅:D[13.191702] → [14.849711:849712]

B:BD[14.849711] → [14.849711:849712]

B:BD[14.849712] → [24.2600:2640]

∅:D[43.262] → [44.215:217]

∅:D[24.2640] → [44.215:217]

∅:D[45.5461] → [44.215:217]

B:BD[44.215] → [44.215:217]

B:BD[44.217] → [24.2641:2666]

B:BD[24.2666] → [37.7094:7281]

∅:D[37.7281] → [24.2666:2733]

B:BD[24.2666] → [24.2666:2733]

B:BD[24.2733] → [46.2534:2589]

∅:D[44.278] → [34.750:751]

∅:D[46.2651] → [34.750:751]

∅:D[24.2838] → [34.750:751]

B:BD[34.750] → [34.750:751]

B:BD[34.751] → [24.2839:2874]

B:BD[47.2854] → [47.2854:2950]

B:BD[47.2950] → [48.2596:2699]

∅:D[48.2699] → [24.3306:3331]

∅:D[49.2947] → [24.3306:3331]

∅:D[47.3005] → [24.3306:3331]

B:BD[24.3306] → [24.3306:3331]

B:BD[24.3331] → [48.2700:2868]

∅:D[48.2868] → [24.3331:3439]

B:BD[24.3331] → [24.3331:3439]

B:BD[24.3439] → [2.2528:2629]

∅:D[2.2629] → [49.2948:2985]

B:BD[24.3488] → [49.2948:2985]

B:BD[49.2985] → [50.2626:2666]

∅:D[50.2666] → [24.3488:3503]

∅:D[47.3067] → [24.3488:3503]

∅:D[49.3085] → [24.3488:3503]

B:BD[24.3488] → [24.3488:3503]

B:BD[24.3503] → [51.2509:2529]

B:BD[51.2529] → [27.3856:3898]

∅:D[47.3279] → [51.2799:2814]

∅:D[27.3898] → [51.2799:2814]

B:BD[51.2799] → [51.2799:2814]

∅:D[51.2814] → [24.3503:3524]

B:BD[24.3503] → [24.3503:3524]

B:BD[24.3524] → [27.3899:3969]

∅:D[49.3137] → [24.3623:3663]

∅:D[47.3337] → [24.3623:3663]

∅:D[27.3969] → [24.3623:3663]

B:BD[24.3623] → [24.3623:3663]

B:BD[24.3663] → [52.2528:2647]

B:BD[52.2647] → [26.11664:11809]

B:BD[26.11809] → [37.7282:7472]

∅:D[37.7472] → [26.11809:12143]

B:BD[26.11809] → [26.11809:12143]

∅:D[52.2647] → [24.3724:3739]

∅:D[26.12143] → [24.3724:3739]

B:BD[24.3724] → [24.3724:3739]

B:BD[24.3739] → [26.12144:12324]

B:BD[26.12324] → [27.3970:4125]

∅:D[27.4125] → [24.3739:3773]

∅:D[26.12324] → [24.3739:3773]

B:BD[24.3739] → [24.3739:3773]

∅:D[53.2540] → [54.2617:2618]

∅:D[55.2547] → [54.2617:2618]

∅:D[24.3773] → [54.2617:2618]

B:BD[54.2617] → [54.2617:2618]

B:BD[54.2618] → [56.25519:25593]

∅:D[57.5585] → [26.12404:12428]

∅:D[56.25593] → [26.12404:12428]

B:BD[26.12404] → [26.12404:12428]

∅:D[26.12428] → [58.2551:2572]

B:BD[54.2618] → [58.2551:2572]

B:BD[58.2572] → [28.3377:3583]

B:BD[28.3583] → [10.2889:2916]

∅:D[10.2916] → [28.3608:3763]

B:BD[28.3608] → [28.3608:3763]

B:BD[28.3763] → [10.2917:2944]

∅:D[10.2944] → [28.3788:3876]

B:BD[28.3788] → [28.3788:3876]

B:BD[28.3876] → [10.2945:2972]

∅:D[10.2972] → [28.3901:4015]

B:BD[28.3901] → [28.3901:4015]

B:BD[28.4015] → [10.2973:3000]

∅:D[10.3000] → [28.4040:4169]

B:BD[28.4040] → [28.4040:4169]

B:BD[28.4169] → [10.3001:3028]

∅:D[10.3028] → [28.4194:4243]

B:BD[28.4194] → [28.4194:4243]

B:BD[28.4243] → [10.3029:3049]

∅:D[10.3049] → [27.4126:4298]

∅:D[28.4261] → [27.4126:4298]

B:BD[58.2572] → [27.4126:4298]

∅:D[58.2572] → [59.4297:4299]

∅:D[27.4298] → [59.4297:4299]

B:BD[24.3793] → [59.4297:4299]

B:BD[59.4299] → [27.4299:4432]

∅:D[27.4432] → [59.4299:4300]

B:BD[59.4299] → [59.4299:4300]

B:BD[59.4300] → [27.4433:4822]

B:BD[27.4822] → [60.2916:3050]

B:BD[60.3050] → [28.4262:4457]

∅:D[60.3050] → [27.4896:6352]

∅:D[28.4457] → [27.4896:6352]

B:BD[27.4896] → [27.4896:6352]

}
bool is_holy_item(const item_def& item)
{
    bool retval = false;
    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_HOLY)
            return (true);
    }
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        retval = (is_blessed_blade(item)
                  || get_weapon_brand(item) == SPWPN_HOLY_WRATH);
        break;
    case OBJ_SCROLLS:
        retval = (item.sub_type == SCR_HOLY_WORD);
        break;
    case OBJ_BOOKS:
        retval = is_holy_spellbook(item);
        break;
    case OBJ_STAVES:
        retval = is_holy_rod(item);
        break;
    default:
        break;
    }
    return (retval);
}
bool is_evil_item(const item_def& item)
{
    bool retval = false;
    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_EVIL)
            return (true);
    }
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        {
        const int item_brand = get_weapon_brand(item);
        retval = (is_demonic(item)
                  || item_brand == SPWPN_DRAINING
                  || item_brand == SPWPN_PAIN
                  || item_brand == SPWPN_VAMPIRICISM
                  || item_brand == SPWPN_SHADOW);
        }
        break;
    case OBJ_MISSILES:
    {
        const int item_brand = get_ammo_brand(item);
        retval = is_demonic(item) || item_brand == SPMSL_SHADOW;
        break;
    }
    case OBJ_WANDS:
        retval = (item.sub_type == WAND_DRAINING);
        break;
    case OBJ_SCROLLS:
        retval = (item.sub_type == SCR_SUMMONING
                  || item.sub_type == SCR_TORMENT);
        break;
    case OBJ_POTIONS:
        retval = is_blood_potion(item);
        break;
    case OBJ_BOOKS:
        retval = is_evil_spellbook(item);
        break;
    case OBJ_STAVES:
        retval = (item.sub_type == STAFF_DEATH || is_evil_rod(item));
        break;
    case OBJ_MISCELLANY:
        retval = (item.sub_type == MISC_BOTTLED_EFREET
                  || item.sub_type == MISC_LANTERN_OF_SHADOWS);
        break;
    default:
        break;
    }
    return (retval);
}
bool is_chaotic_item(const item_def& item)
{
    bool retval = false;
    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_CHAOTIC)
            return (true);
    }
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        {
        const int item_brand = get_weapon_brand(item);
        retval = (item_brand == SPWPN_CHAOS);
        }
        break;
    case OBJ_MISSILES:
        {
        const int item_brand = get_ammo_brand(item);
        retval = (item_brand == SPMSL_CHAOS);
        }
        break;
    case OBJ_WANDS:
        retval = (item.sub_type == WAND_POLYMORPH_OTHER);
        break;
    case OBJ_POTIONS:
        retval = (item.sub_type == POT_MUTATION);
        break;
    case OBJ_BOOKS:
        retval = is_chaotic_spellbook(item);
        break;
    case OBJ_STAVES:
        retval = is_chaotic_rod(item);
        break;
    default:
        break;
    }
    if (is_artefact(item) && artefact_wpn_property(item, ARTP_MUTAGENIC))
        retval = true;
    return (retval);
}
bool is_hasty_item(const item_def& item)
{
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        {
        const int item_brand = get_weapon_brand(item);
        if (item_brand == SPWPN_SPEED)
            return (true);
        }
        break;
    case OBJ_ARMOUR:
        {
        const int item_brand = get_armour_ego_type(item);
        if (item_brand == SPARM_RUNNING)
            return (true);
        }
        break;
    case OBJ_WANDS:
        if (item.sub_type == WAND_HASTING)
            return (true);
        break;
    case OBJ_POTIONS:
        if (item.sub_type == POT_SPEED || item.sub_type == POT_BERSERK_RAGE)
            return (true);
        break;
    case OBJ_JEWELLERY:
        // should this include AMU_RESIST_SLOWING?
        if (item.sub_type == AMU_RAGE)
            return (true);
        break;
    default:
        break;
    }
    return (false);
}
bool is_holy_discipline(int discipline)
{
    return (discipline & SPTYP_HOLY);
}
bool is_evil_discipline(int discipline)
{
    return (discipline & SPTYP_NECROMANCY);
}
bool is_holy_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    unsigned int disciplines = get_spell_disciplines(spell);
    return (is_holy_discipline(disciplines));
}
bool is_evil_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    unsigned int flags       = get_spell_flags(spell);
    unsigned int disciplines = get_spell_disciplines(spell);
    return ((flags & SPFLAG_UNHOLY) || (is_evil_discipline(disciplines)));
}
bool is_chaotic_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    return (spell == SPELL_POLYMORPH_OTHER
            || spell == SPELL_ALTER_SELF
            || spell == SPELL_SUMMON_UGLY_THING);
}
bool is_hasty_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    return (spell == SPELL_HASTE
            || spell == SPELL_SWIFTNESS
            || spell == SPELL_BERSERKER_RAGE);
}
// The default suitable() function for is_spellbook_type().
bool is_any_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    return (true);
}
// If book_or_rod is false, only look at actual spellbooks.  Otherwise,
// only look at rods.
bool is_spellbook_type(const item_def& item, bool book_or_rod,
                       bool (*suitable)(spell_type spell, god_type god),
                       god_type god)
{
    const bool is_spellbook = (item.base_type == OBJ_BOOKS
                                  && item.sub_type != BOOK_MANUAL
                                  && item.sub_type != BOOK_DESTRUCTION);
    const bool is_rod = item_is_rod(item);
    if (!is_spellbook && !is_rod)
        return (false);
    if (!book_or_rod && is_rod)
        return (false);
    int total       = 0;
    int total_liked = 0;
    for (int i = 0; i < SPELLBOOK_SIZE; ++i)
    {
        spell_type spell = which_spell_in_book(item, i);
        if (spell == SPELL_NO_SPELL)
            continue;
        total++;
        if (suitable(spell, god))
            total_liked++;
    }
    // If at least half of the available spells are suitable, the whole
    // spellbook or rod is, too.
    return (total_liked >= (total / 2) + 1);
}
bool is_holy_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, is_holy_spell));
}
bool is_evil_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, is_evil_spell));

Deletion in crawl-ref/source/religion.cc at line 3856 [14.804403]

B:BD[27.6355] → [27.6355:6471]

B:BD[27.6471] → [29.2971:3018]

∅:D[29.3018] → [27.6521:6523]

B:BD[27.6521] → [27.6521:6523]

B:BD[27.6523] → [29.3019:3086]

∅:D[29.3086] → [27.6593:6911]

B:BD[27.6593] → [27.6593:6911]

B:BD[27.6911] → [29.3087:3128]

∅:D[29.3128] → [27.6955:6957]

B:BD[27.6955] → [27.6955:6957]

B:BD[27.6957] → [29.3129:3195]

∅:D[29.3195] → [27.7026:7029]

B:BD[27.7026] → [27.7026:7029]

B:BD[27.7029] → [30.3343:3407]

∅:D[29.3252] → [61.2661:2663]

∅:D[30.3407] → [61.2661:2663]

B:BD[61.2661] → [61.2661:2663]

B:BD[61.2663] → [30.3408:3467]

B:BD[30.3467] → [9.3212:3243]

∅:D[9.3243] → [30.3495:3521]

B:BD[30.3495] → [30.3495:3521]

B:BD[30.3521] → [9.3244:3471]

∅:D[9.3471] → [61.2784:2787]

∅:D[30.3634] → [61.2784:2787]

B:BD[61.2784] → [61.2784:2787]

B:BD[61.2787] → [30.3635:3694]

∅:D[29.3304] → [62.2971:2973]

∅:D[30.3694] → [62.2971:2973]

B:BD[62.2971] → [62.2971:2973]

∅:D[63.2654] → [27.7030:7056]

B:BD[62.2973] → [27.7030:7056]

∅:D[27.7056] → [64.33253:33259]

B:BD[64.33253] → [64.33253:33259]

B:BD[64.33259] → [27.7057:7075]

∅:D[27.7075] → [26.12429:12489]

B:BD[65.2631] → [26.12429:12489]

B:BD[26.12489] → [30.3695:3727]

∅:D[30.3727] → [27.7076:7091]

B:BD[66.2571] → [27.7076:7091]

∅:D[27.7091] → [64.33460:33461]

B:BD[64.33460] → [64.33460:33461]

B:BD[64.33461] → [67.2927:2947]

B:BD[67.2947] → [9.3472:3542]

∅:D[9.3542] → [68.2999:3134]

B:BD[68.2999] → [68.2999:3134]

B:BD[68.3134] → [9.3543:3553]

∅:D[68.3134] → [30.3728:3765]

∅:D[9.3553] → [30.3728:3765]

B:BD[67.3004] → [30.3728:3765]

B:BD[30.3765] → [9.3554:3564]

∅:D[9.3564] → [67.3031:3047]

∅:D[30.3765] → [67.3031:3047]

B:BD[67.3031] → [67.3031:3047]

∅:D[67.3047] → [27.7092:7118]

B:BD[64.33461] → [27.7092:7118]

∅:D[27.7118] → [46.2930:2936]

B:BD[46.2930] → [46.2930:2936]

B:BD[46.2936] → [58.2758:2794]

B:BD[58.2794] → [30.3766:3800]

∅:D[30.3800] → [58.2822:2823]

B:BD[58.2822] → [58.2822:2823]

B:BD[58.2823] → [27.7119:7187]

∅:D[27.7187] → [46.2979:3048]

B:BD[46.2979] → [46.2979:3048]

B:BD[46.3049] → [58.2824:2867]

B:BD[58.2867] → [30.3801:3838]

∅:D[30.3838] → [27.7188:7207]

B:BD[46.3123] → [27.7188:7207]

∅:D[27.7207] → [46.3123:3133]

B:BD[46.3123] → [46.3123:3133]

B:BD[46.3133] → [27.7208:7236]

∅:D[27.7236] → [46.3182:3192]

B:BD[46.3182] → [46.3182:3192]

B:BD[46.3192] → [69.2534:2591]

B:BD[46.3252] → [70.2594:2670]

B:BD[70.2670] → [30.3839:3876]

∅:D[30.3876] → [27.7237:7256]

B:BD[46.3440] → [27.7237:7256]

∅:D[27.7256] → [46.3454:3464]

∅:D[26.12519] → [46.3454:3464]

B:BD[46.3454] → [46.3454:3464]

B:BD[46.3464] → [27.7257:7330]

B:BD[27.7330] → [30.3877:3914]

∅:D[30.3914] → [27.7361:7417]

B:BD[27.7361] → [27.7361:7417]

∅:D[27.7417] → [71.2798:2808]

B:BD[71.2798] → [71.2798:2808]

B:BD[71.2808] → [27.7418:7433]

∅:D[71.2808] → [46.3464:3471]

∅:D[27.7433] → [46.3464:3471]

B:BD[46.3464] → [46.3464:3471]

B:BD[46.3471] → [27.7434:7517]

B:BD[27.7517] → [30.3915:3946]

∅:D[30.3946] → [27.7544:7559]

B:BD[27.7544] → [27.7544:7559]

∅:D[27.7559] → [21.3690:3691]

B:BD[21.3690] → [21.3690:3691]

B:BD[21.3691] → [27.7560:7723]

B:BD[27.7723] → [30.3947:3988]

∅:D[30.3988] → [27.7724:7734]

B:BD[31.16011] → [27.7724:7734]

B:BD[27.7734] → [28.4458:4586]

∅:D[28.4586] → [27.7734:7778]

B:BD[27.7734] → [27.7734:7778]

∅:D[27.7778] → [31.16011:16018]

B:BD[31.16011] → [31.16011:16018]

B:BD[31.16018] → [72.2606:2705]

B:BD[72.2705] → [30.3989:4131]

∅:D[72.2712] → [27.7866:7867]

∅:D[30.4131] → [27.7866:7867]

B:BD[27.7866] → [27.7866:7867]

B:BD[27.7867] → [30.4132:4158]

∅:D[30.4158] → [31.16038:16041]

B:BD[31.16038] → [31.16038:16041]

B:BD[31.16041] → [29.3364:3422]

∅:D[29.3422] → [31.16102:16104]

B:BD[31.16102] → [31.16102:16104]

B:BD[31.16104] → [27.7868:7941]

∅:D[27.7941] → [31.16155:16156]

B:BD[31.16155] → [31.16155:16156]

B:BD[32.13944] → [32.13944:14005]

∅:D[32.14005] → [31.16264:16265]

B:BD[31.16264] → [31.16264:16265]

B:BD[31.16265] → [27.7942:7959]

∅:D[27.7959] → [31.16416:16440]

B:BD[31.16416] → [31.16416:16440]

B:BD[31.16440] → [27.7960:7997]

∅:D[27.7997] → [31.16513:16582]

B:BD[31.16513] → [31.16513:16582]

B:BD[31.16582] → [29.3423:3529]

B:BD[29.3529] → [73.4051:4199]

∅:D[73.4199] → [31.16881:16929]

B:BD[31.16881] → [31.16881:16929]

B:BD[31.16929] → [29.3607:3710]

B:BD[29.3710] → [28.4587:4687]

∅:D[28.4687] → [29.3710:4132]

B:BD[29.3710] → [29.3710:4132]

∅:D[29.4132] → [31.17002:17337]

B:BD[31.17002] → [31.17002:17337]

B:BD[31.17440] → [31.17440:17847]

∅:D[31.17847] → [21.3723:3750]

B:BD[21.3723] → [21.3723:3750]

B:BD[21.3750] → [31.17848:17947]

B:BD[31.17947] → [32.14193:14237]

∅:D[32.14237] → [31.17987:18107]

B:BD[31.17987] → [31.17987:18107]

B:BD[31.18107] → [32.14238:14276]

∅:D[32.14276] → [31.18141:18207]

B:BD[31.18141] → [31.18141:18207]

B:BD[31.18207] → [74.6240:6306]

∅:D[74.6306] → [32.14348:14393]

B:BD[32.14348] → [32.14348:14393]

∅:D[32.14393] → [31.18314:18449]

B:BD[31.18314] → [31.18314:18449]

B:BD[31.18449] → [27.8033:8060]

∅:D[27.8060] → [31.18474:18518]

B:BD[31.18474] → [31.18474:18518]

∅:D[31.18518] → [21.3750:3757]

B:BD[21.3750] → [21.3750:3757]

∅:D[21.3757] → [61.2788:2808]

B:BD[46.3471] → [61.2788:2808]

∅:D[61.2808] → [62.3256:3258]

∅:D[46.3533] → [62.3256:3258]

∅:D[64.33560] → [62.3256:3258]

B:BD[62.3256] → [62.3256:3258]

B:BD[62.3258] → [31.18519:18520]

B:BD[31.18520] → [32.14394:14459]

∅:D[32.14459] → [31.18577:18579]

B:BD[31.18577] → [31.18577:18579]

B:BD[31.18579] → [32.14460:14519]

B:BD[31.18630] → [31.18630:18631]

B:BD[31.18631] → [27.8061:8121]

∅:D[27.8121] → [31.18687:18710]

∅:D[32.14582] → [31.18687:18710]

B:BD[31.18687] → [31.18687:18710]

∅:D[31.18710] → [62.3258:3259]

B:BD[62.3258] → [62.3258:3259]

B:BD[62.3259] → [27.8122:8139]

∅:D[27.8139] → [31.18727:18759]

B:BD[31.18727] → [31.18727:18759]

B:BD[31.18759] → [32.14583:14627]

∅:D[32.14627] → [31.18800:18827]

B:BD[31.18800] → [31.18800:18827]

B:BD[31.18827] → [32.14628:14670]

∅:D[32.14670] → [31.18866:18885]

B:BD[31.18866] → [31.18866:18885]

B:BD[31.18885] → [32.14671:14734]

∅:D[32.14734] → [31.18954:18978]

B:BD[31.18954] → [31.18954:18978]

B:BD[31.18978] → [32.14735:14804]

∅:D[32.14804] → [31.19024:19083]

B:BD[31.19024] → [31.19024:19083]

bool is_chaotic_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, is_chaotic_spell));
}
bool god_hates_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, god_hates_spell_type));
}
bool is_holy_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, is_holy_spell));
}
bool is_evil_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, is_evil_spell));
}
bool is_chaotic_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, is_chaotic_spell));
}
bool god_hates_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, god_hates_spell_type));
}
conduct_type good_god_hates_item_handling(const item_def &item)
{
    if (!is_good_god(you.religion) || !is_evil_item(item))
        return (DID_NOTHING);
    if (is_demonic(item))
        return (DID_UNHOLY);
    if (item_type_known(item)
        || item.base_type == OBJ_WEAPONS
            && get_weapon_brand(item) == SPWPN_CHAOS)
    {
        return (DID_NECROMANCY);
    }
    return (DID_NOTHING);
}
conduct_type god_hates_item_handling(const item_def &item)
{
    switch (you.religion)
    {
    case GOD_ZIN:
        if (item_type_known(item) && is_chaotic_item(item))
            return (DID_CHAOS);
        break;
    case GOD_FEAWN:
        if (!item_type_known(item))
            return (DID_NOTHING);
        if (is_evil_item(item)
            || item.base_type == OBJ_WEAPONS
                && get_weapon_brand(item) == SPWPN_CHAOS)
        {
            return (DID_NECROMANCY);
        }
        break;
    case GOD_SHINING_ONE:
    {
        if (!item_type_known(item))
            return (DID_NOTHING);
        switch (item.base_type)
        {
        case OBJ_WEAPONS:
        {
            const int item_brand = get_weapon_brand(item);
            if (item_brand == SPWPN_VENOM)
                return (DID_POISON);
            break;
        }
        case OBJ_MISSILES:
        {
            const int item_brand = get_ammo_brand(item);
            if (item_brand == SPMSL_POISONED || item_brand == SPMSL_CURARE)
                return (DID_POISON);
            break;
        }
        case OBJ_STAVES:
            if (item.sub_type == STAFF_POISON)
                return (DID_POISON);
            break;
        default:
            break;
        }
        break;
    }
    case GOD_YREDELEMNUL:
        if (item_type_known(item) && is_holy_item(item))
            return (DID_HOLY);
        break;
    case GOD_TROG:
        if (item.base_type == OBJ_BOOKS
            && item.sub_type != BOOK_MANUAL
            && item.sub_type != BOOK_DESTRUCTION)
        {
            return (DID_SPELL_MEMORISE);
        }
        break;
    case GOD_CHRONOS:
        if (item_type_known(item) && is_hasty_item(item))
            return (DID_HASTY);
        break;
    default:
        break;
    }
    if (item_type_known(item)
        && (god_hates_spellbook(item) || god_hates_rod(item)))
    {
        return (NUM_CONDUCTS); // FIXME: get the specific reason, if it
    }                          // will ever be needed for spellbooks.
    return (DID_NOTHING);
}
bool god_hates_spell_type(spell_type spell, god_type god)
{
    if (is_good_god(god) && is_evil_spell(spell))
        return (true);
    unsigned int disciplines = get_spell_disciplines(spell);
    switch (god)
    {
    case GOD_ZIN:
        if (is_chaotic_spell(spell))
            return (true);
        break;
    case GOD_SHINING_ONE:
        // TSO hates using poison, but is fine with curing it, resisting
        // it, or destroying it.
        if ((disciplines & SPTYP_POISON) && spell != SPELL_CURE_POISON
            && spell != SPELL_RESIST_POISON && spell != SPELL_IGNITE_POISON)
        {
            return (true);
        }
    case GOD_YREDELEMNUL:
        if (is_holy_spell(spell))
            return (true);
        break;
    case GOD_CHRONOS:
        if (is_hasty_spell(spell))
            return (true);
        break;
    default:
        break;
    }
    return (false);
}
bool god_dislikes_spell_type(spell_type spell, god_type god)
{
    if (god_hates_spell_type(spell, god))
        return (true);
    unsigned int flags       = get_spell_flags(spell);
    unsigned int disciplines = get_spell_disciplines(spell);
    switch (god)
    {
    case GOD_SHINING_ONE:
        // TSO probably 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_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))
        {
            return (true);
        }
        // Things are more fun for Xom the less the player knows in
        // advance.
        if (disciplines & SPTYP_DIVINATION)
            return (true);
        // Holy spells are probably too useful for Xom to find them
        // interesting.
        if (disciplines & SPTYP_HOLY)
            return (true);
        break;
    case GOD_ELYVILON:
        // A peaceful god of healing wouldn't like combat spells.
        if (disciplines & SPTYP_CONJURATION)
            return (true);
        // Also doesn't like battle spells of the non-conjuration type.
        if (flags & SPFLAG_BATTLE)
            return (true);
        break;
    default:
        break;
    }
    return (false);
}
bool god_dislikes_spell_discipline(int discipline, god_type god)
{
    ASSERT(discipline < (1 << (SPTYP_LAST_EXPONENT + 1)));
    if (is_good_god(god) && is_evil_discipline(discipline))
        return (true);
    switch (god)
    {
    case GOD_SHINING_ONE:
        return (discipline & SPTYP_POISON);
    case GOD_YREDELEMNUL:
        return (discipline & SPTYP_HOLY);
    case GOD_XOM:
        return (discipline & (SPTYP_DIVINATION | SPTYP_HOLY));
    case GOD_ELYVILON:
        return (discipline & (SPTYP_CONJURATION | SPTYP_SUMMONING));
    default:
        break;
    }
    return (false);
}

Insertion in crawl-ref/source/player.cc at line 32 [14.962854]
[75.1945]
[14.963673]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/mon-util.cc at line 34 [14.1699344]
[12.11611]
[14.1700083]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/makefile.obj at line 32 [77.79]
[76.9534]
[77.274]
```
goditem.o \
```
Insertion in crawl-ref/source/itemname.cc at line 26 [14.2667494]
[18.90153]
[78.4975]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/itemname.cc at line 37 [14.2667494]
[79.3455]
[80.7601]
```
#include "religion.h"
```
Deletion in crawl-ref/source/itemname.cc at line 39 [14.2667494]
B:BD[14.2668179] → [81.2896:2918]
```
#include "religion.h"
```
Insertion in crawl-ref/source/item_use.cc at line 32 [14.2781507]
[14.2782957]
[14.2782957]
```
#include "goditem.h"
```

File addition: goditem.h (----------)

[82.24]

#ifndef GODITEM_H
#define GODITEM_H
#include "enum.h"
#include "externs.h"
#include "artefact.h"
#include "itemname.h"
#include "spl-book.h"
#include "spl-cast.h"
#include "spl-util.h"
bool is_holy_item(const item_def& item);
bool is_evil_item(const item_def& item);
bool is_chaotic_item(const item_def& item);
bool is_holy_discipline(int discipline);
bool is_evil_discipline(int discipline);
bool is_holy_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_evil_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_chaotic_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_hasty_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_any_spell(spell_type spell, god_type god = GOD_NO_GOD);
bool is_spellbook_type(const item_def& item, bool book_or_rod,
                       bool (*suitable)(spell_type spell, god_type god) =
                           is_any_spell,
                       god_type god = you.religion);
bool is_holy_spellbook(const item_def& item);
bool is_evil_spellbook(const item_def& item);
bool is_chaotic_spellbook(const item_def& item);
bool god_hates_spellbook(const item_def& item);
bool is_holy_rod(const item_def& item);
bool is_evil_rod(const item_def& item);
bool is_chaotic_rod(const item_def& item);
bool god_hates_rod(const item_def& item);
conduct_type good_god_hates_item_handling(const item_def &item);
conduct_type god_hates_item_handling(const item_def &item);
bool god_hates_spell_type(spell_type spell, god_type god = you.religion);
// NOTE: As of now, these two functions only say if a god won't give a
// spell/school when giving a gift.
bool god_dislikes_spell_type(spell_type spell, god_type god = you.religion);
bool god_dislikes_spell_discipline(int discipline, god_type god = you.religion);
#endif

File addition: goditem.cc (----------)

[82.24]

/*
 *  File:       goditem.cc
 *  Summary:    Gods' attitude towards items.
 */
#include "AppHdr.h"
#include "religion.h"
#include "goditem.h"
#include <algorithm>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include "externs.h"
bool is_holy_item(const item_def& item)
{
    bool retval = false;
    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_HOLY)
            return (true);
    }
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        retval = (is_blessed_blade(item)
                  || get_weapon_brand(item) == SPWPN_HOLY_WRATH);
        break;
    case OBJ_SCROLLS:
        retval = (item.sub_type == SCR_HOLY_WORD);
        break;
    case OBJ_BOOKS:
        retval = is_holy_spellbook(item);
        break;
    case OBJ_STAVES:
        retval = is_holy_rod(item);
        break;
    default:
        break;
    }
    return (retval);
}
bool is_evil_item(const item_def& item)
{
    bool retval = false;
    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_EVIL)
            return (true);
    }
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        {
        const int item_brand = get_weapon_brand(item);
        retval = (is_demonic(item)
                  || item_brand == SPWPN_DRAINING
                  || item_brand == SPWPN_PAIN
                  || item_brand == SPWPN_VAMPIRICISM
                  || item_brand == SPWPN_SHADOW);
        }
        break;
    case OBJ_MISSILES:
    {
        const int item_brand = get_ammo_brand(item);
        retval = is_demonic(item) || item_brand == SPMSL_SHADOW;
        break;
    }
    case OBJ_WANDS:
        retval = (item.sub_type == WAND_DRAINING);
        break;
    case OBJ_SCROLLS:
        retval = (item.sub_type == SCR_SUMMONING
                  || item.sub_type == SCR_TORMENT);
        break;
    case OBJ_POTIONS:
        retval = is_blood_potion(item);
        break;
    case OBJ_BOOKS:
        retval = is_evil_spellbook(item);
        break;
    case OBJ_STAVES:
        retval = (item.sub_type == STAFF_DEATH || is_evil_rod(item));
        break;
    case OBJ_MISCELLANY:
        retval = (item.sub_type == MISC_BOTTLED_EFREET
                  || item.sub_type == MISC_LANTERN_OF_SHADOWS);
        break;
    default:
        break;
    }
    return (retval);
}
bool is_chaotic_item(const item_def& item)
{
    bool retval = false;
    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_CHAOTIC)
            return (true);
    }
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        {
        const int item_brand = get_weapon_brand(item);
        retval = (item_brand == SPWPN_CHAOS);
        }
        break;
    case OBJ_MISSILES:
        {
        const int item_brand = get_ammo_brand(item);
        retval = (item_brand == SPMSL_CHAOS);
        }
        break;
    case OBJ_WANDS:
        retval = (item.sub_type == WAND_POLYMORPH_OTHER);
        break;
    case OBJ_POTIONS:
        retval = (item.sub_type == POT_MUTATION);
        break;
    case OBJ_BOOKS:
        retval = is_chaotic_spellbook(item);
        break;
    case OBJ_STAVES:
        retval = is_chaotic_rod(item);
        break;
    default:
        break;
    }
    if (is_artefact(item) && artefact_wpn_property(item, ARTP_MUTAGENIC))
        retval = true;
    return (retval);
}
bool is_hasty_item(const item_def& item)
{
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        {
        const int item_brand = get_weapon_brand(item);
        if (item_brand == SPWPN_SPEED)
            return (true);
        }
        break;
    case OBJ_ARMOUR:
        {
        const int item_brand = get_armour_ego_type(item);
        if (item_brand == SPARM_RUNNING)
            return (true);
        }
        break;
    case OBJ_WANDS:
        if (item.sub_type == WAND_HASTING)
            return (true);
        break;
    case OBJ_POTIONS:
        if (item.sub_type == POT_SPEED || item.sub_type == POT_BERSERK_RAGE)
            return (true);
        break;
    case OBJ_JEWELLERY:
        // should this include AMU_RESIST_SLOWING?
        if (item.sub_type == AMU_RAGE)
            return (true);
        break;
    default:
        break;
    }
    return (false);
}
bool is_holy_discipline(int discipline)
{
    return (discipline & SPTYP_HOLY);
}
bool is_evil_discipline(int discipline)
{
    return (discipline & SPTYP_NECROMANCY);
}
bool is_holy_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    unsigned int disciplines = get_spell_disciplines(spell);
    return (is_holy_discipline(disciplines));
}
bool is_evil_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    unsigned int flags       = get_spell_flags(spell);
    unsigned int disciplines = get_spell_disciplines(spell);
    return ((flags & SPFLAG_UNHOLY) || (is_evil_discipline(disciplines)));
}
bool is_chaotic_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    return (spell == SPELL_POLYMORPH_OTHER
            || spell == SPELL_ALTER_SELF
            || spell == SPELL_SUMMON_UGLY_THING);
}
bool is_hasty_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    return (spell == SPELL_HASTE
            || spell == SPELL_SWIFTNESS
            || spell == SPELL_BERSERKER_RAGE);
}
// The default suitable() function for is_spellbook_type().
bool is_any_spell(spell_type spell, god_type god)
{
    UNUSED(god);
    return (true);
}
// If book_or_rod is false, only look at actual spellbooks.  Otherwise,
// only look at rods.
bool is_spellbook_type(const item_def& item, bool book_or_rod,
                       bool (*suitable)(spell_type spell, god_type god),
                       god_type god)
{
    const bool is_spellbook = (item.base_type == OBJ_BOOKS
                                  && item.sub_type != BOOK_MANUAL
                                  && item.sub_type != BOOK_DESTRUCTION);
    const bool is_rod = item_is_rod(item);
    if (!is_spellbook && !is_rod)
        return (false);
    if (!book_or_rod && is_rod)
        return (false);
    int total       = 0;
    int total_liked = 0;
    for (int i = 0; i < SPELLBOOK_SIZE; ++i)
    {
        spell_type spell = which_spell_in_book(item, i);
        if (spell == SPELL_NO_SPELL)
            continue;
        total++;
        if (suitable(spell, god))
            total_liked++;
    }
    // If at least half of the available spells are suitable, the whole
    // spellbook or rod is, too.
    return (total_liked >= (total / 2) + 1);
}
bool is_holy_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, is_holy_spell));
}
bool is_evil_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, is_evil_spell));
}
bool is_chaotic_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, is_chaotic_spell));
}
bool god_hates_spellbook(const item_def& item)
{
    return (is_spellbook_type(item, false, god_hates_spell_type));
}
bool is_holy_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, is_holy_spell));
}
bool is_evil_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, is_evil_spell));
}
bool is_chaotic_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, is_chaotic_spell));
}
bool god_hates_rod(const item_def& item)
{
    return (is_spellbook_type(item, true, god_hates_spell_type));
}
conduct_type good_god_hates_item_handling(const item_def &item)
{
    if (!is_good_god(you.religion) || !is_evil_item(item))
        return (DID_NOTHING);
    if (is_demonic(item))
        return (DID_UNHOLY);
    if (item_type_known(item)
        || item.base_type == OBJ_WEAPONS
            && get_weapon_brand(item) == SPWPN_CHAOS)
    {
        return (DID_NECROMANCY);
    }
    return (DID_NOTHING);
}
conduct_type god_hates_item_handling(const item_def &item)
{
    switch (you.religion)
    {
    case GOD_ZIN:
        if (item_type_known(item) && is_chaotic_item(item))
            return (DID_CHAOS);
        break;
    case GOD_FEAWN:
        if (!item_type_known(item))
            return (DID_NOTHING);
        if (is_evil_item(item)
            || item.base_type == OBJ_WEAPONS
                && get_weapon_brand(item) == SPWPN_CHAOS)
        {
            return (DID_NECROMANCY);
        }
        break;
    case GOD_SHINING_ONE:
    {
        if (!item_type_known(item))
            return (DID_NOTHING);
        switch (item.base_type)
        {
        case OBJ_WEAPONS:
        {
            const int item_brand = get_weapon_brand(item);
            if (item_brand == SPWPN_VENOM)
                return (DID_POISON);
            break;
        }
        case OBJ_MISSILES:
        {
            const int item_brand = get_ammo_brand(item);
            if (item_brand == SPMSL_POISONED || item_brand == SPMSL_CURARE)
                return (DID_POISON);
            break;
        }
        case OBJ_STAVES:
            if (item.sub_type == STAFF_POISON)
                return (DID_POISON);
            break;
        default:
            break;
        }
        break;
    }
    case GOD_YREDELEMNUL:
        if (item_type_known(item) && is_holy_item(item))
            return (DID_HOLY);
        break;
    case GOD_TROG:
        if (item.base_type == OBJ_BOOKS
            && item.sub_type != BOOK_MANUAL
            && item.sub_type != BOOK_DESTRUCTION)
        {
            return (DID_SPELL_MEMORISE);
        }
        break;
    case GOD_CHRONOS:
        if (item_type_known(item) && is_hasty_item(item))
            return (DID_HASTY);
        break;
    default:
        break;
    }
    if (item_type_known(item)
        && (god_hates_spellbook(item) || god_hates_rod(item)))
    {
        return (NUM_CONDUCTS); // FIXME: get the specific reason, if it
    }                          // will ever be needed for spellbooks.
    return (DID_NOTHING);
}
bool god_hates_spell_type(spell_type spell, god_type god)
{
    if (is_good_god(god) && is_evil_spell(spell))
        return (true);
    unsigned int disciplines = get_spell_disciplines(spell);
    switch (god)
    {
    case GOD_ZIN:
        if (is_chaotic_spell(spell))
            return (true);
        break;
    case GOD_SHINING_ONE:
        // TSO hates using poison, but is fine with curing it, resisting
        // it, or destroying it.
        if ((disciplines & SPTYP_POISON) && spell != SPELL_CURE_POISON
            && spell != SPELL_RESIST_POISON && spell != SPELL_IGNITE_POISON)
        {
            return (true);
        }
    case GOD_YREDELEMNUL:
        if (is_holy_spell(spell))
            return (true);
        break;
    case GOD_CHRONOS:
        if (is_hasty_spell(spell))
            return (true);
        break;
    default:
        break;
    }
    return (false);
}
bool god_dislikes_spell_type(spell_type spell, god_type god)
{
    if (god_hates_spell_type(spell, god))
        return (true);
    unsigned int flags       = get_spell_flags(spell);
    unsigned int disciplines = get_spell_disciplines(spell);
    switch (god)
    {
    case GOD_SHINING_ONE:
        // TSO probably 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_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))
        {
            return (true);
        }
        // Things are more fun for Xom the less the player knows in
        // advance.
        if (disciplines & SPTYP_DIVINATION)
            return (true);
        // Holy spells are probably too useful for Xom to find them
        // interesting.
        if (disciplines & SPTYP_HOLY)
            return (true);
        break;
    case GOD_ELYVILON:
        // A peaceful god of healing wouldn't like combat spells.
        if (disciplines & SPTYP_CONJURATION)
            return (true);
        // Also doesn't like battle spells of the non-conjuration type.
        if (flags & SPFLAG_BATTLE)
            return (true);
        break;
    default:
        break;
    }
    return (false);
}
bool god_dislikes_spell_discipline(int discipline, god_type god)
{
    ASSERT(discipline < (1 << (SPTYP_LAST_EXPONENT + 1)));
    if (is_good_god(god) && is_evil_discipline(discipline))
        return (true);
    switch (god)
    {
    case GOD_SHINING_ONE:
        return (discipline & SPTYP_POISON);
    case GOD_YREDELEMNUL:
        return (discipline & SPTYP_HOLY);
    case GOD_XOM:
        return (discipline & (SPTYP_DIVINATION | SPTYP_HOLY));
    case GOD_ELYVILON:
        return (discipline & (SPTYP_CONJURATION | SPTYP_SUMMONING));
    default:
        break;
    }
    return (false);
}

Insertion in crawl-ref/source/fight.cc at line 30 [14.3140790]
[14.3142432]
[5.2809]
```
#include "goditem.h"
```
Insertion in crawl-ref/source/describe.cc at line 32 [14.3736416]
[12.29115]
[6.6153]
```
#include "goditem.h"
```

Slightly reduce religion.cc by yanking item-handling stuff to goditem.cc

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/xom.cc at line 17 [11.3]

Insertion in crawl-ref/source/view.cc at line 36 [14.16817]

Insertion in crawl-ref/source/spl-cast.cc at line 21 [14.293070]

Insertion in crawl-ref/source/spl-book.cc at line 29 [14.397614]

Insertion in crawl-ref/source/spells3.cc at line 29 [14.531613]

Insertion in crawl-ref/source/spells2.cc at line 27 [14.569242]

Deletion in crawl-ref/source/religion.h at line 126 [14.800304]

Deletion in crawl-ref/source/religion.h at line 127 [14.800304]

Insertion in crawl-ref/source/religion.cc at line 39 [14.804403]

Deletion in crawl-ref/source/religion.cc at line 70 [14.804403]

Deletion in crawl-ref/source/religion.cc at line 71 [14.804403]

Deletion in crawl-ref/source/religion.cc at line 3854 [14.804403]

Deletion in crawl-ref/source/religion.cc at line 3856 [14.804403]

Insertion in crawl-ref/source/player.cc at line 32 [14.962854]

Insertion in crawl-ref/source/mon-util.cc at line 34 [14.1699344]

Insertion in crawl-ref/source/makefile.obj at line 32 [77.79]

Insertion in crawl-ref/source/itemname.cc at line 26 [14.2667494]

Insertion in crawl-ref/source/itemname.cc at line 37 [14.2667494]

Deletion in crawl-ref/source/itemname.cc at line 39 [14.2667494]

Insertion in crawl-ref/source/item_use.cc at line 32 [14.2781507]

File addition: goditem.h (----------)

File addition: goditem.cc (----------)

Insertion in crawl-ref/source/fight.cc at line 30 [14.3140790]

Insertion in crawl-ref/source/describe.cc at line 32 [14.3736416]