fiddlerwoaroof/crawl - Change QS3ZRS3E6KL3YJHPKYEWCWJYRBJSXD5OOYF6Y25HZVECGPJRDB5QC

Experimental monster weapon swapping implementation. Allow monsters to use

throwing weapons (hand axes, spears, clubs, daggers). Give orcs and orc warriors a chance of being generated with throwing weapons (axes or spears).

Throwing weapons are stacked in monster inventory, but unstack when dropped. We may want to consider fully stackable throwing weapons at some point.

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

Created by dshaligram on July 2, 2007

QS3ZRS3E6KL3YJHPKYEWCWJYRBJSXD5OOYF6Y25HZVECGPJRDB5QC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/stuff.h at line 37 [7.217090]
[6.103260]
[4.929]
```
int random_choose(int first, ...);
```
Insertion in crawl-ref/source/stuff.cc at line 24 [7.224557]
[3.205]
[3.205]
```
#include <cstdarg>
```

Insertion in crawl-ref/source/stuff.cc at line 195 [7.224557]

[8.137527]


int random_choose(int first, ...)
{
    va_list args;
    va_start(args, first);
    int chosen = first, count = 1, nargs = 100;

Insertion in crawl-ref/source/stuff.cc at line 203 [7.224557]

[8.137528]

    while (nargs-- > 0)
    {
        const int pick = va_arg(args, int);
        if (pick == -1)
            break;
        if (one_chance_in(++count))
            chosen = pick;
    }
    ASSERT(nargs > 0);
    
    va_end(args);
    return (chosen);
}

Insertion in crawl-ref/source/mstuff2.cc at line 1035 [7.1340842]
[7.1367425]
[7.1367425]
```
    const bool skilled = mons_class_flag(monster->type, M_FIGHTER);
```
Replacement in crawl-ref/source/mstuff2.cc at line 1075 [7.1340842]
B:BD[7.1368276] → [7.1368276:1368301]
```
            baseHit = 5;
```
[7.1368276]
[7.1368301]
```
            baseHit = 11;
```
Replacement in crawl-ref/source/mstuff2.cc at line 1081 [7.1340842]
B:BD[7.1368386] → [7.1368386:1368411]
```
            baseHit = 0;
```
[7.1368386]
[7.1368411]
```
            baseHit = 6;
```

Replacement in crawl-ref/source/mstuff2.cc at line 1277 [7.1340842]

B:BD[7.1373915] → [7.1373915:1374001]

    pbolt.damage = dice_def( 1, baseDam + random2avg(exDamBonus, 2) + ammoDamBonus );

[7.1373915]

[7.1374001]

    pbolt.damage =
        dice_def( 1, baseDam + random2avg(exDamBonus, 2) + ammoDamBonus );

Insertion in crawl-ref/source/mstuff2.cc at line 1285 [7.1340842]
[7.1374110]
[7.1374110]
```
    pbolt.damage.size = diceMult * pbolt.damage.size / 100;
```

Replacement in crawl-ref/source/mstuff2.cc at line 1287 [7.1340842]

B:BD[7.1374111] → [6.404501:404561]

    pbolt.damage.size = diceMult * pbolt.damage.size / 100;

[7.1374111]

[6.404561]

    // Skilled archers get better to-hit and damage.
    if (skilled)
    {
        pbolt.hit         = pbolt.hit * 120 / 100;
        pbolt.damage.size = pbolt.damage.size * 120 / 100;
    }

Insertion in crawl-ref/source/monstuff.h at line 165 [7.1390580]

[6.411125]

[7.1396618]

int mons_weapon_damage_rating(const item_def &launcher);
int mons_pick_best_missile(monsters *mons, item_def **launcher,
                           bool ignore_melee = false);
int mons_missile_damage(const item_def *launch,
                        const item_def *missile);
int mons_thrown_weapon_damage(const item_def *weap);

Insertion in crawl-ref/source/monstuff.cc at line 3255 [7.1396662]

[7.1504040]


// Returns a rough estimate of damage from throwing the wielded weapon.
int mons_thrown_weapon_damage(const item_def *weap)
{
    if (!weap || get_weapon_brand(*weap) != SPWPN_RETURNING)
        return (0);
    return std::max(0, (property(*weap, PWPN_DAMAGE) + weap->plus2 / 2));
}
// Returns a rough estimate of damage from firing/throwing missile.
int mons_missile_damage(const item_def *launch,
                        const item_def *missile)
{
    if (!missile || (!launch && !is_throwable(*missile)))
        return (0);
    const int missile_damage = property(*missile, PWPN_DAMAGE) / 2 + 1;
    const int launch_damage  = launch? property(*launch, PWPN_DAMAGE) : 0;
    return std::max(0, launch_damage + missile_damage);
}
int mons_weapon_damage_rating(const item_def &launcher)
{
    return (property(launcher, PWPN_DAMAGE) + launcher.plus2);
}
// Given the monster's current weapon and alt weapon (either or both of
// which may be NULL), works out whether using missiles or throwing the
// main weapon (with returning brand) is better. If using missiles that
// need a launcher, sets *launcher to the launcher.
// 
// If the monster has no ranged weapon attack, returns NON_ITEM.
//
int mons_pick_best_missile(monsters *mons, item_def **launcher,
                           bool ignore_melee)
{
    *launcher = NULL;
    item_def *melee = NULL, *launch = NULL;
    for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
    {
        if (item_def *item = mons->mslot_item(static_cast<mon_inv_type>(i)))
        {
            if (is_range_weapon(*item))
                launch = item;
            else if (!ignore_melee)
                melee = item;
        }
    }
    
    const item_def *missiles = mons->missiles();
    if (launch && missiles && !missiles->launched_by(*launch))
        launch = NULL;

Insertion in crawl-ref/source/monstuff.cc at line 3308 [7.1396662]

[7.1504041]

    const int tdam = mons_thrown_weapon_damage(melee);
    const int fdam = mons_missile_damage(launch, missiles);
    if (!tdam && !fdam)
        return (NON_ITEM);
    else if (tdam >= fdam)
        return (melee->index());
    else
    {
        *launcher = launch;
        return (missiles->index());
    }
}

Replacement in crawl-ref/source/monstuff.cc at line 3333 [7.1396662]

B:BD[7.1504405] → [9.9984:10027]

∅:D[9.10027] → [7.1504453:1504496]

B:BD[7.1504453] → [7.1504453:1504496]

B:BD[7.1504496] → [9.10028:10074]

    if (monster->has_ench(ENCH_CONFUSION) 
        || monster->behaviour == BEH_SLEEP
        || monster->has_ench(ENCH_SUBMERGED))

[7.1504405]

[7.1504549]

    if (monster->incapacitated()
        || monster->asleep()
        || monster->submerged())

Replacement in crawl-ref/source/monstuff.cc at line 3343 [7.1396662]

B:BD[7.1504668] → [5.959:1330]

∅:D[5.1330] → [7.1504722:1504788]

B:BD[7.1504722] → [7.1504722:1504788]

    int mon_item;
    const int mon_wpn = monster->inv[MSLOT_WEAPON];
    bool returning = false;
    // weapons of returning can be thrown
    if ( mon_wpn != NON_ITEM &&
         get_weapon_brand(mitm[mon_wpn]) == SPWPN_RETURNING )
    {
        mon_item = mon_wpn;
        returning = true;
    }
    else
    {
        mon_item = monster->inv[MSLOT_MISSILE];
    }
    if (mon_item == NON_ITEM || !is_valid_item( mitm[mon_item] ))

[7.1504668]

[7.1504788]

    if (one_chance_in(5))

Replacement in crawl-ref/source/monstuff.cc at line 3346 [7.1396662]
B:BD[7.1504813] → [7.1504813:1504862]
```
    // don't allow offscreen throwing.. for now.
```
[7.1504813]
[7.1504862]
```
    // don't allow offscreen throwing for now.
```

Deletion in crawl-ref/source/monstuff.cc at line 3350 [7.1396662]

B:BD[7.1504943] → [7.1504943:1505080]

    // poor 2-headed ogres {dlb}
    if (monster->type == MONS_TWO_HEADED_OGRE || monster->type == MONS_ETTIN) 
        return (false);

Replacement in crawl-ref/source/monstuff.cc at line 3355 [7.1396662]

B:BD[7.1505329] → [7.1505329:1505379]

    if (one_chance_in(5))
        return (false);

[7.1505329]

[7.1505379]

    item_def *launcher = NULL;
    const int mon_item = mons_pick_best_missile(monster, &launcher);

Replacement in crawl-ref/source/monstuff.cc at line 3358 [7.1396662]

B:BD[7.1505380] → [7.1505380:1505859]

B:BD[7.1505859] → [5.1331:1375]

    // new (GDL) - don't throw idiotic stuff.  It's a waste of time.
    int wepClass = mitm[mon_item].base_type;
    int wepType = mitm[mon_item].sub_type;
    int weapon = monster->inv[MSLOT_WEAPON];
    int lnchClass = (weapon != NON_ITEM) ? mitm[weapon].base_type : -1;
    int lnchType  = (weapon != NON_ITEM) ? mitm[weapon].sub_type  :  0;
    bool thrown = false;
    bool launched = false;
    throw_type( lnchClass, lnchType, wepClass, wepType, launched, thrown );
    if (!launched && !thrown && !returning)

[7.1505380]

[7.1505889]

    if (mon_item == NON_ITEM || !is_valid_item(mitm[mon_item]))

Insertion in crawl-ref/source/monstuff.cc at line 3376 [7.1396662]

[7.1506094]

[6.428711]

        if (launcher && launcher != monster->mslot_item(MSLOT_WEAPON))
            monster->swap_weapons();

Deletion in crawl-ref/source/monstuff.cc at line 3836 [7.1396662]

B:BD[2.76] → [2.76:1053]

∅:D[2.1053] → [7.1519384:1519385]

B:BD[7.1519384] → [7.1519384:1519385]

B:BD[7.1519385] → [2.1054:1075]

∅:D[2.1075] → [7.1519385:1519386]

B:BD[7.1519385] → [7.1519385:1519386]

static bool monster_wants_weapon(const monsters *monster, const item_def &weap)
{
    if (is_fixed_artefact( weap ))
        return (false);
    if (is_random_artefact( weap ))
        return (false);
    // wimpy monsters (Kob, gob) shouldn't pick up halberds etc
    // of course, this also block knives {dlb}:
    if ((mons_species(monster->type) == MONS_KOBOLD
         || mons_species(monster->type) == MONS_GOBLIN)
        && property( weap, PWPN_HIT ) <= 0)
    {
        return (false);
    }
    // Nobody picks up giant clubs:
    if (weap.sub_type == WPN_GIANT_CLUB
        || weap.sub_type == WPN_GIANT_SPIKED_CLUB)
    {
        return (false);
    }
    const int brand = get_weapon_brand(weap);
    const int holiness = monster->holiness();
    if (brand == SPWPN_DISRUPTION && holiness == MH_UNDEAD)
        return (false);
    if (brand == SPWPN_HOLY_WRATH
        && (holiness == MH_DEMONIC || holiness == MH_UNDEAD))
    {
        return (false);
    }
    return (true);
}

Replacement in crawl-ref/source/monstuff.cc at line 3952 [7.1396662]

B:BD[7.1523000] → [7.1523000:1523076]

    item = igrd[monster->x][monster->y];
    switch (mitm[item].base_type)

[7.1523000]

[7.1523076]

    
    for (item = igrd[monster->x][monster->y]; item != NON_ITEM; )

Replacement in crawl-ref/source/monstuff.cc at line 3955 [7.1396662]

B:BD[7.1523082] → [7.1523082:1523185]

B:BD[7.1523185] → [2.1076:1132]

∅:D[2.1132] → [7.1523230:1523259]

B:BD[7.1523230] → [7.1523230:1523259]

B:BD[7.1523880] → [7.1523880:1524018]

B:BD[7.1524018] → [10.7538:7568]

∅:D[10.7568] → [7.1524058:1524106]

B:BD[7.1524058] → [7.1524058:1524106]

B:BD[7.1524106] → [11.2175:2254]

∅:D[11.2254] → [12.4961:5040]

B:BD[12.4961] → [12.4961:5040]

∅:D[12.5040] → [7.1524369:1524933]

B:BD[7.1524369] → [7.1524369:1524933]

B:BD[7.1524933] → [11.2255:2359]

∅:D[11.2359] → [12.5115:5176]

B:BD[12.5115] → [12.5115:5176]

∅:D[12.5176] → [7.1525198:1525404]

B:BD[7.1525198] → [7.1525198:1525404]

    case OBJ_WEAPONS:
        if (monster->inv[MSLOT_WEAPON] != NON_ITEM)
            return (false);
        if (!monster_wants_weapon(monster, mitm[item]))
            return (false);
        monster->inv[MSLOT_WEAPON] = item;
        if (get_weapon_brand(mitm[monster->inv[MSLOT_WEAPON]]) == SPWPN_PROTECTION)
        {
            monster->ac += 3;
        }
        if (monsterNearby)
        {
            mprf("%s picks up %s.", str_monam(*monster, DESC_CAP_THE).c_str(),
                 mitm[monster->inv[MSLOT_WEAPON]].name(DESC_NOCAP_A).c_str());
        }
        break;
    case OBJ_MISSILES:
        // don't pick up if we're in combat, and there isn't much there
        if (mitm[item].quantity < 5 || monster->behaviour != BEH_WANDER)
            return (false);
        if (monster->inv[MSLOT_MISSILE] != NON_ITEM
            && mitm[monster->inv[MSLOT_MISSILE]].sub_type == mitm[item].sub_type
            && mitm[monster->inv[MSLOT_MISSILE]].plus == mitm[item].plus
            && mitm[monster->inv[MSLOT_MISSILE]].special == mitm[item].special)
        {
            if (monsterNearby)
            {
                mprf("%s picks up %s.",
                     str_monam(*monster, DESC_CAP_THE).c_str(),
                     mitm[item].name(DESC_NOCAP_A).c_str());
            }
            inc_mitm_item_quantity( monster->inv[MSLOT_MISSILE], 
                                    mitm[item].quantity );
            dec_mitm_item_quantity( item, mitm[item].quantity );

[7.1523082]

[7.1525404]

        item_def &topickup = mitm[item];
        item = topickup.link;
        if (monster->pickup_item(topickup, monsterNearby))

Deletion in crawl-ref/source/monstuff.cc at line 3959 [7.1396662]

B:BD[7.1525431] → [7.1525431:1525816]

B:BD[7.1525816] → [11.2360:2439]

∅:D[11.2439] → [12.5247:5304]

B:BD[12.5247] → [12.5247:5304]

∅:D[12.5304] → [7.1526080:1526284]

B:BD[7.1526080] → [7.1526080:1526284]

B:BD[7.1526284] → [11.2440:2519]

∅:D[11.2519] → [12.5375:5432]

B:BD[12.5375] → [12.5375:5432]

∅:D[12.5432] → [7.1526545:1526755]

B:BD[7.1526545] → [7.1526545:1526755]

B:BD[7.1526755] → [11.2520:2599]

∅:D[11.2599] → [12.5503:5560]

B:BD[12.5503] → [12.5503:5560]

∅:D[12.5560] → [7.1527018:1527228]

B:BD[7.1527018] → [7.1527018:1527228]

B:BD[7.1527228] → [11.2600:2679]

∅:D[11.2679] → [12.5631:5688]

B:BD[12.5631] → [12.5631:5688]

∅:D[12.5688] → [7.1527491:1527645]

B:BD[7.1527491] → [7.1527491:1527645]

B:BD[7.1527645] → [12.5689:5767]

∅:D[12.5767] → [7.1527725:1528038]

B:BD[7.1527725] → [7.1527725:1528038]

B:BD[7.1528038] → [11.2680:2755]

∅:D[11.2755] → [12.5834:5893]

B:BD[12.5834] → [12.5834:5893]

∅:D[12.5893] → [7.1528277:1528445]

B:BD[7.1528277] → [7.1528277:1528445]

B:BD[7.1528445] → [13.3835:3878]

B:BD[13.3878] → [11.2756:2817]

∅:D[11.2817] → [7.1528702:1529170]

∅:D[13.4045] → [7.1528702:1529170]

B:BD[7.1528702] → [7.1528702:1529170]

        }
        // nobody bothers to pick up rocks if they don't already have some:
        if (mitm[item].sub_type == MI_LARGE_ROCK)
            return (false);
        // monsters with powerful melee attacks don't bother
        if (mons_damage(monster->type, 0) > 5)
            return (false);
        monster->inv[MSLOT_MISSILE] = item;
        if (monsterNearby)
        {
            mprf("%s picks up %s.", str_monam(*monster, DESC_CAP_THE).c_str(),
                 mitm[item].name(DESC_NOCAP_A).c_str());
        }
        break;
    case OBJ_WANDS:
        if (monster->inv[MSLOT_WAND] != NON_ITEM)
            return (false);
        monster->inv[MSLOT_WAND] = item;
        if (monsterNearby)
        {
            mprf("%s picks up %s.", str_monam(*monster, DESC_CAP_THE).c_str(),
                 mitm[item].name(DESC_NOCAP_A).c_str());
        }
        break;
    case OBJ_SCROLLS:
        if (monster->inv[MSLOT_SCROLL] != NON_ITEM)
            return (false);
        monster->inv[MSLOT_SCROLL] = item;
        if (monsterNearby)
        {
            mprf("%s picks up %s.", str_monam(*monster, DESC_CAP_THE).c_str(),
                 mitm[item].name(DESC_NOCAP_A).c_str());
        }
        break;
    case OBJ_POTIONS:
        if (monster->inv[MSLOT_POTION] != NON_ITEM)
            return (false);
        monster->inv[MSLOT_POTION] = item;
        if (monsterNearby)
        {
            mprf("%s picks up %s.", str_monam(*monster, DESC_CAP_THE).c_str(),
                 mitm[item].name(DESC_NOCAP_A).c_str());
        }
        break;
    case OBJ_CORPSES:
        if (monster->type != MONS_NECROPHAGE && monster->type != MONS_GHOUL)
            return (false);
        monster->hit_points += 1 + random2(mons_weight(mitm[item].plus))/100;
        // limited growth factor here -- should 77 really be the cap? {dlb}:
        if (monster->hit_points > 100)
            monster->hit_points = 100;
        if (monster->hit_points > monster->max_hit_points)
            monster->max_hit_points = monster->hit_points;
        if (monsterNearby)
        {
            mprf("%s eats %s.", str_monam(*monster, DESC_CAP_THE).c_str(),
                 mitm[item].name(DESC_NOCAP_THE).c_str());
        }
        destroy_item( item );
        return (true);
    case OBJ_GOLD: //mv - monsters now pick up gold (19 May 2001)
        if (monsterNearby)
        {
            mprf("%s picks up some gold.",
                 str_monam(*monster, DESC_CAP_THE).c_str());
        }
        if (monster->inv[MSLOT_GOLD] != NON_ITEM)
        {
            // transfer gold to monster's object, destroy ground object
            inc_mitm_item_quantity( monster->inv[MSLOT_GOLD], 
                                    mitm[item].quantity );
            destroy_item( item );
            return (true);
        }
        else
        {
            monster->inv[MSLOT_GOLD] = item;
        }
        break;
    default:
        return (false);

Replacement in crawl-ref/source/monstuff.cc at line 3960 [7.1396662]

B:BD[7.1529176] → [7.1529176:1529583]


    // Item has been picked-up, move to monster inventory.
    mitm[item].x = 0; 
    mitm[item].y = 0; 
    // Monster's only take the top item of stacks, so relink the 
    // top item, and unlink the item.
    igrd[monster->x][monster->y] = mitm[item].link;
    mitm[item].link = NON_ITEM;
    if (monster->speed_increment > 25)
        monster->speed_increment -= monster->speed;
    return (true);

[7.1529176]

[7.1529583]

    return (false);

Insertion in crawl-ref/source/mon-util.cc at line 1607 [7.1699344]

[14.2325]

}
bool mons_eats_corpses(const monsters *m)
{
    return (m->type == MONS_NECROPHAGE || m->type == MONS_GHOUL);

Replacement in crawl-ref/source/mon-util.cc at line 1623 [7.1699344]
B:BD[14.2474] → [14.2474:2498]
```
    return (m->inv[1]);
```
[14.2474]
[14.2498]
```
    return (m->inv[MSLOT_ALT_WEAPON]);
```

Insertion in crawl-ref/source/mon-util.cc at line 2289 [7.1699344]

[15.9079]

}
item_def *monsters::missiles()
{
    return (inv[MSLOT_MISSILE] != NON_ITEM? &mitm[inv[MSLOT_MISSILE]] : NULL);
}
int monsters::missile_count()
{
    if (const item_def *missile = missiles())
        return (missile->quantity);
    return (0);
}
item_def *monsters::launcher()
{
    item_def *weap = mslot_item(MSLOT_WEAPON);
    if (weap && is_range_weapon(*weap))
        return (weap);
    weap = mslot_item(MSLOT_ALT_WEAPON);
    return (weap && is_range_weapon(*weap)? weap : NULL);

Insertion in crawl-ref/source/mon-util.cc at line 2334 [7.1699344]
[10.11812]
[10.11812]

Replacement in crawl-ref/source/mon-util.cc at line 2336 [7.1699344]

B:BD[10.11813] → [10.11813:11863]

static int equip_slot_to_mslot(equipment_type eq)

[10.11813]

[10.11863]

bool monsters::can_throw_rocks() const
{
    return (type == MONS_STONE_GIANT || type == MONS_CYCLOPS);
}
bool monsters::can_use_missile(const item_def &item) const
{
    // Pretty simplistic at the moment. We allow monsters to pick up
    // missiles without the corresponding launcher, assuming that sufficient
    // wandering may get them to stumble upon the launcher.
    
    if (item.base_type == OBJ_WEAPONS)
        return (is_throwable(item));
    if (item.base_type != OBJ_MISSILES)
        return (false);
    if (item.sub_type == MI_LARGE_ROCK && !can_throw_rocks())
        return (false);
    return (true);
}
void monsters::swap_slots(mon_inv_type a, mon_inv_type b)
{
    const int swap = inv[a];
    inv[a] = inv[b];
    inv[b] = swap;
}
void monsters::equip_weapon(const item_def &item, int near)
{
    const int brand = get_weapon_brand(item);
    if (brand == SPWPN_PROTECTION)
        ac += 5;
    if (brand != SPWPN_NORMAL && need_message(near))
    {
        switch (brand)
        {
        case SPWPN_FLAMING:
            mpr("It bursts into flame!");
            break;
        case SPWPN_FREEZING:
            mpr("It glows with a cold blue light!");
            break;
        case SPWPN_HOLY_WRATH:
            mpr("It softly glows with a divine radiance!");
            break;
        case SPWPN_ELECTROCUTION:
            mpr("You hear the crackle of electricity.");
            break;
        case SPWPN_VENOM:
            mpr("It begins to drip with poison!");
            break;
        case SPWPN_DRAINING:
            mpr("You sense an unholy aura.");
            break;
        case SPWPN_FLAME:
            mpr("It glows red for a moment.");
            break;
        case SPWPN_FROST:
            mpr("It is covered in frost.");
            break;
        case SPWPN_DISRUPTION:
            mpr("You sense a holy aura.");
            break;
        case SPWPN_RETURNING:
            mpr("It wiggles slightly.");
            break;
        }
    }    
}
void monsters::equip(const item_def &item, int slot, int near)
{
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        if (need_message(near))
            mprf("%s wields %s.", name(DESC_CAP_THE).c_str(),
                 item.name(DESC_NOCAP_A).c_str());
        equip_weapon(item, near);
        break;
    case OBJ_ARMOUR:
    {
        ac += property( item, PARM_AC );
        const int armour_plus = item.plus;
        ASSERT(abs(armour_plus) < 20);
        if (abs(armour_plus) < 20) 
            ac += armour_plus;
        ev += property( item, PARM_EVASION ) / 2;
        
        if (ev < 1)
            ev = 1;   // This *shouldn't* happen.
        break;
    }
    default:
        break;
    }
}
void monsters::unequip(const item_def &item, int slot, int near)
{
    // XXX: Handle armour removal when armour swapping is implemented.
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        if (get_weapon_brand(item) == SPWPN_PROTECTION)
            ac -= 5;
        break;
    default:
        break;
    }
}
void monsters::lose_pickup_energy()
{
    if (speed_increment > 25 && speed < speed_increment)
        speed_increment -= speed;
}
void monsters::pickup_message(const item_def &item, int near)
{
    if (need_message(near))
        mprf("%s picks up %s.",
             name(DESC_CAP_THE).c_str(),
             item.base_type == OBJ_GOLD? "some gold"
             : item.name(DESC_NOCAP_A).c_str());
}
bool monsters::pickup(item_def &item, int slot, int near, bool force_merge)
{
    if (inv[slot] != NON_ITEM)
    {
        if (items_stack(item, mitm[inv[slot]], force_merge))
        {
            pickup_message(item, near);
            inc_mitm_item_quantity( inv[slot], item.quantity );
            destroy_item(item.index());
            equip(item, slot, near);
            lose_pickup_energy();
            return (true);
        }
        return (false);
    }
    
    const int index = item.index();
    unlink_item(index);
    inv[slot] = index;
    pickup_message(item, near);
    equip(item, slot, near);
    lose_pickup_energy();
    return (true);
}
bool monsters::drop_item(int eslot, int near)
{
    if (eslot < 0 || eslot >= NUM_MONSTER_SLOTS)
        return (false);
    int index = inv[eslot];
    if (index == NON_ITEM)
        return (true);
    // Cannot drop cursed weapon or armour.
    if ((eslot == MSLOT_WEAPON || eslot == MSLOT_ARMOUR)
        && mitm[index].cursed())
        return (false);
    const std::string iname = mitm[index].name(DESC_NOCAP_A);
    move_item_to_grid(&index, x, y);
    if (index == inv[eslot])
        return (false);
    if (need_message(near))
        mprf("%s drops %s.", name(DESC_CAP_THE).c_str(), iname.c_str());
    inv[eslot] = NON_ITEM;
    return (true);
}
bool monsters::pickup_launcher(item_def &launch, int near)
{
    const int mdam_rating = mons_weapon_damage_rating(launch);
    const missile_type mt = fires_ammo_type(launch);
    int eslot = -1;
    for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
    {
        if (const item_def *elaunch = mslot_item(static_cast<mon_inv_type>(i)))
        {
            if (is_range_weapon(*elaunch))
                continue;
            
            return (fires_ammo_type(*elaunch) == mt
                    && mons_weapon_damage_rating(*elaunch) < mdam_rating
                    && drop_item(i, near) && pickup(launch, i, near));
        }
        else
            eslot = i;
    }
    return (eslot == -1? false : pickup(launch, eslot, near));
}
bool monsters::pickup_melee_weapon(item_def &item, int near)
{
    if (mons_wields_two_weapons(this))
    {
        // If we have either weapon slot free, pick up the weapon.
        if (inv[MSLOT_WEAPON] == NON_ITEM)
            return pickup(item, MSLOT_WEAPON, near);
        else if (inv[MSLOT_ALT_WEAPON] == NON_ITEM)
            return pickup(item, MSLOT_ALT_WEAPON, near);
    }
    const int mdam_rating = mons_weapon_damage_rating(item);
    int eslot = -1;
    bool has_melee = false;
    for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
    {
        if (const item_def *weap = mslot_item(static_cast<mon_inv_type>(i)))
        {
            if (is_range_weapon(*weap))
                continue;
            has_melee = true;
            if (mons_weapon_damage_rating(*weap) < mdam_rating)
                return (drop_item(i, near) && pickup(item, i, near));
        }
        else
            eslot = i;
    }
    if (eslot == MSLOT_ALT_WEAPON && inv[MSLOT_WEAPON] == NON_ITEM)
        eslot = MSLOT_WEAPON;
    return (eslot == -1 || has_melee? false : pickup(item, eslot, near));
}
// Arbitrary damage adjustment for quantity of missiles. So sue me.
static int q_adj_damage(int damage, int qty)
{
    return (damage * std::min(qty, 8));
}
    
bool monsters::pickup_throwable_weapon(item_def &item, int near)

Insertion in crawl-ref/source/mon-util.cc at line 2587 [7.1699344]

[10.11865]

    if (mslot_item(MSLOT_MISSILE) && pickup(item, MSLOT_MISSILE, near, true))
        return (true);
    
    item_def *launch = NULL;
    const int exist_missile = mons_pick_best_missile(this, &launch, true);
    if (exist_missile == NON_ITEM
        || (q_adj_damage(mons_missile_damage(launch, &mitm[exist_missile]),
                          mitm[exist_missile].quantity)
            <
            q_adj_damage(mons_thrown_weapon_damage(&item), item.quantity)))
    {
        if (inv[MSLOT_MISSILE] != NON_ITEM && !drop_item(MSLOT_MISSILE, near))
            return (false);
        return pickup(item, MSLOT_MISSILE, near);
    }
    return (false);
}
bool monsters::wants_weapon(const item_def &weap) const
{
    if (is_fixed_artefact( weap ))
        return (false);
    // wimpy monsters (Kob, gob) shouldn't pick up halberds etc
    // of course, this also block knives {dlb}:
    if ((::mons_species(type) == MONS_KOBOLD
         || ::mons_species(type) == MONS_GOBLIN)
        && property( weap, PWPN_HIT ) <= 0)
    {
        return (false);
    }
    // Nobody picks up giant clubs:
    if (weap.sub_type == WPN_GIANT_CLUB
        || weap.sub_type == WPN_GIANT_SPIKED_CLUB)
    {
        return (false);
    }
    const int brand = get_weapon_brand(weap);
    const int holy = holiness();
    if (brand == SPWPN_DISRUPTION && holy == MH_UNDEAD)
        return (false);
    if (brand == SPWPN_HOLY_WRATH
        && (holy == MH_DEMONIC || holy == MH_UNDEAD))
    {
        return (false);
    }
    return (true);    
}
bool monsters::pickup_weapon(item_def &item, int near, bool force)
{
    if (!force && !wants_weapon(item))
        return (false);
    
    // Weapon pickup involves:
    // - If we have no weapons, always pick this up.
    // - If this is a melee weapon and we already have a melee weapon, pick
    //   it up if it is superior to the one we're carrying (and drop the
    //   one we have).
    // - If it is a ranged weapon, and we already have a ranged weapon,
    //   pick it up if it is better than the one we have.
    // - If it is a throwable weapon, and we're carrying no missiles (or our
    //   missiles are the same type), pick it up.
    if (is_range_weapon(item))
        return (pickup_launcher(item, near));
    
    if (pickup_melee_weapon(item, near))
        return (true);
    return (can_use_missile(item) && pickup_throwable_weapon(item, near));
}
bool monsters::pickup_missile(item_def &item, int near)
{
    // XXX: Missile pickup could get a lot smarter if we allow monsters to
    // drop their existing missiles and pick up new stuff, but that's too
    // much work for now.
    
    const item_def *miss = missiles();
    if (miss && items_stack(*miss, item))
        return (pickup(item, MSLOT_MISSILE, near));
    if (!can_use_missile(item))
        return (false);
    return pickup(item, MSLOT_MISSILE, near);
}
bool monsters::pickup_wand(item_def &item, int near)
{
    return pickup(item, MSLOT_WEAPON, near);
}
bool monsters::pickup_scroll(item_def &item, int near)
{
    return pickup(item, MSLOT_SCROLL, near);
}
bool monsters::pickup_potion(item_def &item, int near)
{
    return pickup(item, MSLOT_POTION, near);
}
bool monsters::pickup_gold(item_def &item, int near)
{
    return pickup(item, MSLOT_GOLD, near);
}
bool monsters::eat_corpse(item_def &carrion, int near)
{
    if (!mons_eats_corpses(this))
        return (false);
    hit_points += 1 + random2(mons_weight(carrion.plus)) / 100;
    // limited growth factor here -- should 77 really be the cap? {dlb}:
    if (hit_points > 100)
        hit_points = 100;
    if (hit_points > max_hit_points)
        max_hit_points = hit_points;
    if (need_message(near))
        mprf("%s eats %s.", name(DESC_CAP_THE).c_str(),
             carrion.name(DESC_NOCAP_THE).c_str());
    destroy_item( carrion.index() );
    return (true);
}
bool monsters::pickup_item(item_def &item, int near, bool force)
{
    // Never pick up stuff when we're in battle.
    if (behaviour != BEH_WANDER && !force)
        return (false);
    
    // Jellies are not handled here.
    switch (item.base_type)
    {
    case OBJ_WEAPONS:
        return pickup_weapon(item, near, force);
    case OBJ_ARMOUR:
        return pickup(item, MSLOT_ARMOUR, near);
    case OBJ_MISSILES:
        return pickup_missile(item, near);
    case OBJ_WANDS:
        return pickup_wand(item, near);
    case OBJ_SCROLLS:
        return pickup_scroll(item, near);
    case OBJ_CORPSES:
        return eat_corpse(item, near);
    case OBJ_MISCELLANY:
        return pickup(item, MSLOT_MISCELLANY, near);
    case OBJ_GOLD:
        return pickup_gold(item, near);
    default:
        return (false);
    }
}
bool monsters::need_message(int &near) const
{
    return near != -1? near : (near = visible());
}
void monsters::swap_weapons(int near)
{
    const item_def *weap = mslot_item(MSLOT_WEAPON);
    const item_def *alt  = mslot_item(MSLOT_ALT_WEAPON);
    
    if (weap)
        unequip(*weap, MSLOT_WEAPON, !alt && need_message(near));
    swap_slots(MSLOT_WEAPON, MSLOT_ALT_WEAPON);
    if (need_message(near))
    {
        if (!alt && weap)
            mprf("%s unwields %s.", name(DESC_CAP_THE).c_str(),
                 weap->name(DESC_NOCAP_A).c_str());
    }
    if (alt)
        equip(*alt, MSLOT_WEAPON, near);
    // Monsters can swap weapons really fast. :-)
    if ((weap || alt) && speed_increment >= 2)
        speed_increment -= 2;
}
void monsters::wield_melee_weapon(int near)
{
    const item_def *weap = mslot_item(MSLOT_WEAPON);
    if (!weap || (!weap->cursed() && is_range_weapon(*weap)))
    {
        const item_def *alt = mslot_item(MSLOT_ALT_WEAPON);
        if (alt && (!weap || !is_range_weapon(*alt)))
            swap_weapons(near);
    }
}
static mon_inv_type equip_slot_to_mslot(equipment_type eq)
{

Replacement in crawl-ref/source/mon-util.cc at line 2799 [7.1699344]
B:BD[10.11974] → [10.11974:12000]
```
    default: return (-1);
```
[10.11974]
[10.12000]
```
    default: return (NUM_MONSTER_SLOTS);
```

Replacement in crawl-ref/source/mon-util.cc at line 2805 [7.1699344]

B:BD[10.12060] → [10.12060:12154]

    int mslot = equip_slot_to_mslot(eq);
    int mindex = mslot == -1? NON_ITEM : inv[mslot];

[10.12060]

[10.12154]

    return mslot_item(equip_slot_to_mslot(eq));
}
item_def *monsters::mslot_item(mon_inv_type mslot)
{
    const int mindex = mslot == NUM_MONSTER_SLOTS? NON_ITEM : inv[mslot];

Replacement in crawl-ref/source/mon-data.h at line 503 [7.1826214]

B:BD[7.1838537] → [7.1838537:1838613]

    1, 4, 8, 7, MST_NO_SPELLS, CE_CONTAMINATED, Z_BIG, S_SHOUT2, I_NORMAL,

[7.1838537]

[16.2451]

    1, 4, 10, 7, MST_NO_SPELLS, CE_CONTAMINATED, Z_BIG, S_SHOUT2, I_NORMAL,

Replacement in crawl-ref/source/makeitem.cc at line 1458 [17.927]

B:BD[17.46440] → [17.46440:46601]

                            set_weapon_special(p, (coinflip() ? SPWPN_FLAMING
                                                               : SPWPN_FREEZING));

[17.46440]

[17.46601]

                            set_weapon_special(p,
                                               (coinflip() ? SPWPN_FLAMING
                                                           : SPWPN_FREEZING));

Replacement in crawl-ref/source/makeitem.cc at line 2900 [17.927]

B:BD[17.99879] → [17.99879:99960]

static void give_monster_item(monsters *mon, int thing, bool force_item = false)

[17.99879]

[17.99960]

static void give_monster_item(
    monsters *mon, int thing,
    bool force_item = false,
    bool (monsters::*pickupfn)(item_def&, int) = NULL)

Deletion in crawl-ref/source/makeitem.cc at line 2912 [17.927]

B:BD[17.100114] → [17.100114:101280]

    switch (mthing.base_type)
    {
    case OBJ_WEAPONS:
    {
        const int slot = mon->inv[MSLOT_WEAPON] == NON_ITEM? 0 : 1;
        mon->inv[slot] = thing;
        break;
    }
    case OBJ_MISSILES:
        mon->inv[MSLOT_MISSILE] = thing;
        break;
    case OBJ_SCROLLS:
        mon->inv[MSLOT_SCROLL] = thing;
        break;
    case OBJ_GOLD:
        mon->inv[MSLOT_GOLD] = thing;
        break;
    case OBJ_POTIONS:
        mon->inv[MSLOT_POTION] = thing;
        break;
    case OBJ_MISCELLANY:
        mon->inv[MSLOT_MISCELLANY] = thing;
        break;
    case OBJ_WANDS:
        mon->inv[MSLOT_WAND] = thing;
        break;
    case OBJ_ARMOUR:
    {
        mon->inv[MSLOT_ARMOUR] = thing;
        
        mon->ac += property( mthing, PARM_AC );
        const int armour_plus = mthing.plus;
        
        ASSERT(abs(armour_plus) < 20);
        
        if (abs(armour_plus) < 20) 
            mon->ac += armour_plus;
        
        mon->ev += property( mthing, PARM_EVASION ) / 2;
        
        if (mon->ev < 1)
            mon->ev = 1;   // This *shouldn't* happen.
        
        break;
    }
    default:
        break;
    }

Replacement in crawl-ref/source/makeitem.cc at line 2914 [17.927]

B:BD[17.101337] → [17.101337:101510]

    if (get_weapon_brand( mthing ) == SPWPN_PROTECTION )
        mon->ac += 5;
    else if (get_weapon_brand(mthing) == SPWPN_DISRUPTION
             && mholy == MH_UNDEAD)

[17.101337]

[17.101510]

    if (get_weapon_brand(mthing) == SPWPN_DISRUPTION
        && mholy == MH_UNDEAD)

Insertion in crawl-ref/source/makeitem.cc at line 2925 [17.927]

[17.101782]

    const int speed_inc = mon->speed_increment;
    if (!(pickupfn? (mon->*pickupfn)(mthing, false)
          : mon->pickup_item(mthing, false, true)))
    {
#ifdef DEBUG_DIAGNOSTICS
        mprf(MSGCH_WARN, "Destroying %s because %s doesn't want it!",
             mthing.name(DESC_PLAIN).c_str(), mon->name(DESC_PLAIN).c_str());
#endif
        destroy_item(thing);
        return ;
    }
    mon->speed_increment = speed_inc;

Replacement in crawl-ref/source/makeitem.cc at line 3614 [17.927]

B:BD[17.124285] → [17.124285:124388]

    if (mon->inv[MSLOT_WEAPON] != NON_ITEM
        && is_range_weapon( mitm[mon->inv[MSLOT_WEAPON]] ))

[17.124285]

[17.124388]

    if (const item_def *launcher = mon->launcher())

Replacement in crawl-ref/source/makeitem.cc at line 3617 [17.927]
∅:D[18.1802] → [17.124433:124505]
B:BD[17.124433] → [17.124433:124505]
```
        const int xitt = fires_ammo_type(mitm[mon->inv[MSLOT_WEAPON]]);
```
[18.1802]
[17.124505]
```
        const int xitt = fires_ammo_type(*launcher);
```
Deletion in crawl-ref/source/makeitem.cc at line 3632 [17.927]
B:BD[17.125009] → [17.125009:125079]
```
        mitm[thing_created].x = 0;
        mitm[thing_created].y = 0;
```

Insertion in crawl-ref/source/makeitem.cc at line 3635 [17.927]

[17.125218]

    else
    {
        // Give some monsters throwing weapons.
        int weap_type = WPN_UNKNOWN;
        int qty = 0;
        switch (mon->type)
        {
        case MONS_ORC_WARRIOR:
            if (one_chance_in(
                    you.where_are_you == BRANCH_ORCISH_MINES? 9 : 20))
            {
                weap_type =
                    random_choose(WPN_HAND_AXE, WPN_SPEAR, -1);
                qty = random_range(4, 8);
            }
            break;
        case MONS_ORC:
            if (one_chance_in(20))
            {
                weap_type =
                    random_choose(WPN_HAND_AXE, WPN_SPEAR, -1);
                qty = random_range(2, 5);                
            }
            break;
        }
        if (weap_type == WPN_UNKNOWN)
            return ;
        
        const int thing_created =
            items( 0, OBJ_WEAPONS, weap_type, true, level, item_race );
        if (thing_created != NON_ITEM)
        {
            mitm[thing_created].quantity = qty;
            mitm[thing_created].flags    = 0;
            give_monster_item(mon, thing_created, false,
                              &monsters::pickup_throwable_weapon);
        }
    }

Replacement in crawl-ref/source/items.h at line 32 [7.2580284]

∅:D[19.774] → [7.2581200:2581266]

B:BD[7.2581200] → [7.2581200:2581266]

bool items_stack( const item_def &item1, const item_def &item2 );

[19.774]

[20.144271]

bool items_stack( const item_def &item1, const item_def &item2,
                  bool force = false );

Replacement in crawl-ref/source/items.cc at line 1170 [7.2584728]

B:BD[7.2612145] → [7.2612145:2612210]

bool items_stack( const item_def &item1, const item_def &item2 )

[7.2612145]

[7.2612210]

bool items_stack( const item_def &item1, const item_def &item2,
                  bool force_merge )

Replacement in crawl-ref/source/items.cc at line 1174 [7.2584728]

B:BD[7.2612248] → [7.2612248:2612316]

    if (!is_stackable_item( item1 ) || !is_stackable_item( item2 ))

[7.2612248]

[7.2612316]

    if (!force_merge
        && (!is_stackable_item( item1 ) || !is_stackable_item( item2 )))

Insertion in crawl-ref/source/items.cc at line 1182 [7.2584728]
[7.2612505]
[19.863]
```
    ASSERT(force_merge || item1.base_type != OBJ_WEAPONS);
```

Replacement in crawl-ref/source/items.cc at line 1188 [7.2584728]

B:BD[7.2612558] → [7.2612558:2612660]

    if (item1.base_type == OBJ_MISSILES
         || item1.base_type == OBJ_MISCELLANY)  // only runes

[7.2612558]

[7.2612660]

    if (item1.base_type == OBJ_WEAPONS         // only throwing weapons
        || item1.base_type == OBJ_MISSILES
        || item1.base_type == OBJ_MISCELLANY)  // only runes

Insertion in crawl-ref/source/items.cc at line 1451 [7.2584728]

[7.2618262]

        }
    }
    // Non-stackable item that's been fudge-stacked (monster throwing weapons).
    // Explode the stack when dropped.
    else if (mitm[*obj].quantity > 1)
    {
        while (mitm[*obj].quantity > 1)
        {
            // If we can't copy the items out, we lose the surplus.
            if (copy_item_to_grid(mitm[*obj], x, y, 1, false))
                --mitm[*obj].quantity;
            else
                mitm[*obj].quantity = 1;

Insertion in crawl-ref/source/items.cc at line 2941 [7.2584728]

[21.49188]


bool item_def::launched_by(const item_def &launcher) const
{
    if (base_type != OBJ_MISSILES)
        return (false);
    return (sub_type == fires_ammo_type(launcher));
}
int item_def::index() const
{
    return (this - mitm.buffer());
}

Insertion in crawl-ref/source/fight.cc at line 3023 [7.3140790]

[10.77673]


    // Melee combat, tell attacker to wield its melee weapon.
    atk->wield_melee_weapon();

Insertion in crawl-ref/source/externs.h at line 523 [7.3270163]

[22.1065]

[12.27398]


    // Returns index in mitm array. Results are undefined if this item is
    // not in the array!
    int  index() const;
    
    bool launched_by(const item_def &launcher) const;

Replacement in crawl-ref/source/externs.h at line 989 [7.3270163]
B:BD[7.3280691] → [7.3280691:3280720]
```
    FixedVector<int, 8> inv;
```
[7.3280691]
[6.898103]
```
    FixedVector<short, NUM_MONSTER_SLOTS> inv;
```
Insertion in crawl-ref/source/externs.h at line 1061 [7.3270163]
[10.88505]
[15.83885]
```
    item_def *mslot_item(mon_inv_type sl);
```

Insertion in crawl-ref/source/externs.h at line 1063 [7.3270163]

[15.83930]

    item_def *launcher();
    item_def *missiles();
    int       missile_count();

Insertion in crawl-ref/source/externs.h at line 1067 [7.3270163]

[15.83954]

    void      wield_melee_weapon(int near = -1);
    void      swap_weapons(int near = -1);
    bool      pickup_item(item_def &item, int near = -1, bool force = false);
    void      pickup_message(const item_def &item, int near);
    bool      pickup_wand(item_def &item, int near);
    bool      pickup_scroll(item_def &item, int near);
    bool      pickup_potion(item_def &item, int near);
    bool      pickup_gold(item_def &item, int near);
    bool      pickup_launcher(item_def &launcher, int near);
    bool      pickup_melee_weapon(item_def &item, int near);
    bool      pickup_throwable_weapon(item_def &item, int near);
    bool      pickup_weapon(item_def &item, int near, bool force);
    bool      pickup_missile(item_def &item, int near);
    bool      eat_corpse(item_def &carrion, int near);
    void      equip(const item_def &item, int slot, int near = -1);
    void      unequip(const item_def &item, int slot, int near = -1);
    bool      can_use_missile(const item_def &item) const;

Insertion in crawl-ref/source/externs.h at line 1156 [7.3270163]

[13.32043]

[7.3281164]

    void swap_slots(mon_inv_type a, mon_inv_type b);
    bool need_message(int &near) const;
    bool pickup(item_def &item, int slot, int near, bool force_merge = false);
    void equip_weapon(const item_def &item, int near);
   
    bool drop_item(int eslot, int near);
    bool wants_weapon(const item_def &item) const;
    bool can_throw_rocks() const;
    void lose_pickup_energy();

Deletion in crawl-ref/source/enum.h at line 1910 [7.3287960]
∅:D[23.4225] → [14.9938:9939]
B:BD[6.920128] → [14.9938:9939]
Insertion in crawl-ref/source/enum.h at line 2482 [7.3287960]
[7.3342995]
[6.923315]
```
// Adding slots breaks saves. YHBW.
```

Replacement in crawl-ref/source/enum.h at line 2485 [7.3287960]

B:BD[7.3343058] → [7.3343058:3343188]

    MSLOT_WEAPON,
    MSLOT_MISSILE, // although it is a second weapon for MONS_TWO_HEADED_OGRE - how to reconcile cleanly? {dlb}

[7.3343058]

[7.3343188]

    MSLOT_WEAPON,           // Primary weapon (melee)
    MSLOT_ALT_WEAPON,       // Alternate weapon, ranged or second melee weapon
                            // for monsters that can use two weapons.
    MSLOT_MISSILE,

Replacement in crawl-ref/source/enum.h at line 2490 [7.3287960]

B:BD[7.3343206] → [7.3343206:3343350]

    MSLOT_MISCELLANY, //mv: used for misc. obj. (7 Aug 2001)
    MSLOT_POTION, // mv: now used only for potions (7 Aug 2001)
    MSLOT_WAND, //

[7.3343206]

[7.3343350]

    MSLOT_MISCELLANY,
    MSLOT_POTION,
    MSLOT_WAND,

Replacement in crawl-ref/source/enum.h at line 2494 [7.3287960]

B:BD[7.3343368] → [7.3343368:3343503]

    MSLOT_GOLD, //mv: used for money :) (7 Aug 2001)
    NUM_MONSTER_SLOTS = 8 // value must remain 8 for savefile compatibility {dlb}

[7.3343368]

[7.3343503]

    MSLOT_GOLD,
    NUM_MONSTER_SLOTS

Replacement in crawl-ref/source/effects.cc at line 90 [7.3382105]

B:BD[6.937006] → [6.937006:937079]

                    // FIXME: If we ever make any other weapon / randart

[6.937006]

[6.937079]

                    // XXX: If we ever make any other weapon / randart

Insertion in crawl-ref/source/dungeon.cc at line 1510 [7.3429798]
[7.3566281]
[7.3566281]
```
        int tries = 200;
```

Replacement in crawl-ref/source/dungeon.cc at line 1513 [7.3429798]

B:BD[7.3566302] → [7.3566302:3566406]

            env.trap[i].x = 10 + random2(GXM - 20);
            env.trap[i].y = 10 + random2(GYM - 20);

[7.3566302]

[7.3566406]

            env.trap[i].x = random2(GXM);
            env.trap[i].y = random2(GYM);

Replacement in crawl-ref/source/dungeon.cc at line 1516 [7.3429798]

B:BD[7.3566416] → [7.3566416:3566481]

        while (grd[env.trap[i].x][env.trap[i].y] != DNGN_FLOOR);

[7.3566416]

[7.3566481]

        while (grd[env.trap[i].x][env.trap[i].y] != DNGN_FLOOR
               && --tries > 0);

Deletion in crawl-ref/source/dungeon.cc at line 5900 [7.3429798]
B:BD[7.3686793] → [7.3686793:3686857]
```
        if (tcount >= MAX_TRAPS - 1)
            return false;
```

Replacement in crawl-ref/source/direct.cc at line 1568 [7.3697945]

B:BD[7.3719010] → [11.12543:12622]

        mprf("%s. ('v' to describe)", str_monam(menv[i], DESC_CAP_A).c_str());

[7.3719010]

[16.12783]

        mprf("%s.", str_monam(menv[i], DESC_CAP_A).c_str());

Replacement in crawl-ref/source/direct.cc at line 1580 [7.3697945]
∅:D[12.28136] → [7.3719608:3719667]
B:BD[7.3719608] → [7.3719608:3719667]
```
                && menv[i].inv[MSLOT_MISSILE] != NON_ITEM)
```
[12.28136]
[7.3719667]
```
                && menv[i].inv[MSLOT_ALT_WEAPON] != NON_ITEM)
```

Replacement in crawl-ref/source/direct.cc at line 1583 [7.3697945]

B:BD[24.522] → [24.522:599]

                    <<  mitm[menv[i].inv[MSLOT_MISSILE]].name(DESC_NOCAP_A);

[24.522]

[7.3720009]

                    <<  mitm[menv[i].inv[MSLOT_ALT_WEAPON]].name(DESC_NOCAP_A);

Replacement in crawl-ref/source/describe.cc at line 4875 [7.3736416]
B:BD[7.3941654] → [25.6148:6187]
```
            description << "    " << i
```
[7.3941654]
[25.6187]
```
            description << "    " << i << ") "
```
Replacement in crawl-ref/source/beam.cc at line 3343 [7.4128068]
B:BD[7.4232647] → [6.1245725:1245768]
```
    // simple cases for scroll burns FIXME
```
[7.4232647]
[6.1245768]
```
    // simple cases for scroll burns
```
Deletion in crawl-ref/source/acr.cc at line 1868 [7.4397395]
B:BD[7.4448791] → [7.4448791:4448797]
```
    {
```
Deletion in crawl-ref/source/acr.cc at line 1869 [7.4397395]
B:BD[7.4448836] → [7.4448836:4448880]
```
        //FIXME: cute message or not?
    }
```

Experimental monster weapon swapping implementation. Allow monsters to use

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/stuff.h at line 37 [7.217090]

Insertion in crawl-ref/source/stuff.cc at line 24 [7.224557]

Insertion in crawl-ref/source/stuff.cc at line 195 [7.224557]

Insertion in crawl-ref/source/stuff.cc at line 203 [7.224557]

Insertion in crawl-ref/source/mstuff2.cc at line 1035 [7.1340842]

Replacement in crawl-ref/source/mstuff2.cc at line 1075 [7.1340842]

Replacement in crawl-ref/source/mstuff2.cc at line 1081 [7.1340842]