Revert "Track who destroys an item; incur Nemelex penance for deck destruction."
[crawl.git] / crawl-ref / source / monster.cc
1 /**
2  * @file
3  * @brief Monsters class methods
4 **/
5
6 #include "AppHdr.h"
7 #include "bitary.h"
8
9 #include "areas.h"
10 #include "art-enum.h"
11 #include "artefact.h"
12 #include "beam.h"
13 #include "cloud.h"
14 #include "coordit.h"
15 #include "database.h"
16 #include "delay.h"
17 #include "dgnevent.h"
18 #include "dgn-overview.h"
19 #include "directn.h"
20 #include "env.h"
21 #include "fight.h"
22 #include "fineff.h"
23 #include "fprop.h"
24 #include "ghost.h"
25 #include "godabil.h"
26 #include "godconduct.h"
27 #include "goditem.h"
28 #include "itemname.h"
29 #include "itemprop.h"
30 #include "items.h"
31 #include "kills.h"
32 #include "libutil.h"
33 #include "makeitem.h"
34 #include "misc.h"
35 #include "mon-abil.h"
36 #include "mon-act.h"
37 #include "mon-behv.h"
38 #include "mon-cast.h"
39 #include "mon-place.h"
40 #include "mon-stuff.h"
41 #include "mon-transit.h"
42 #include "mon-util.h"
43 #include "mgen_data.h"
44 #include "random.h"
45 #include "religion.h"
46 #include "shopping.h"
47 #include "spl-damage.h"
48 #include "spl-util.h"
49 #include "state.h"
50 #include "terrain.h"
51 #ifdef USE_TILE
52 #include "tileview.h"
53 #endif
54 #include "traps.h"
55 #include "view.h"
56 #include "shout.h"
57 #include "xom.h"
58
59 #include <algorithm>
60 #include <queue>
61
62 // Macro that saves some typing, nothing more.
63 #define smc get_monster_data(mc)
64
65 monster::monster()
66     : hit_points(0), max_hit_points(0), hit_dice(0),
67       ac(0), ev(0), speed(0), speed_increment(0), target(), firing_pos(),
68       patrol_point(), travel_target(MTRAV_NONE), inv(NON_ITEM), spells(),
69       attitude(ATT_HOSTILE), behaviour(BEH_WANDER), foe(MHITYOU),
70       enchantments(), flags(0), experience(0), base_monster(MONS_NO_MONSTER),
71       number(0), colour(BLACK), foe_memory(0), shield_blocks(0),
72       god(GOD_NO_GOD), ghost(), seen_context(SC_NONE), client_id(0)
73
74 {
75     type = MONS_NO_MONSTER;
76     travel_path.clear();
77     props.clear();
78     if (crawl_state.game_is_arena())
79         foe = MHITNOT;
80
81     constricting = 0;
82
83     clear_constricted();
84 };
85
86 // Empty destructor to keep unique_ptr happy with incomplete ghost_demon type.
87 monster::~monster()
88 {
89 }
90
91 monster::monster(const monster& mon)
92 {
93     constricting = 0;
94     init_with(mon);
95 }
96
97 monster &monster::operator = (const monster& mon)
98 {
99     if (this != &mon)
100         init_with(mon);
101     return *this;
102 }
103
104 void monster::reset()
105 {
106     mname.clear();
107     enchantments.clear();
108     ench_cache.reset();
109     ench_countdown = 0;
110     inv.init(NON_ITEM);
111
112     flags           = 0;
113     experience      = 0;
114     type            = MONS_NO_MONSTER;
115     base_monster    = MONS_NO_MONSTER;
116     hit_points      = 0;
117     max_hit_points  = 0;
118     hit_dice        = 0;
119     ac              = 0;
120     ev              = 0;
121     speed_increment = 0;
122     attitude        = ATT_HOSTILE;
123     behaviour       = BEH_SLEEP;
124     foe             = MHITNOT;
125     number          = 0;
126     damage_friendly = 0;
127     damage_total    = 0;
128
129     mons_remove_from_grid(this);
130     position.reset();
131     firing_pos.reset();
132     patrol_point.reset();
133     travel_target = MTRAV_NONE;
134     travel_path.clear();
135     ghost.reset(NULL);
136     seen_context = SC_NONE;
137     props.clear();
138     clear_constricted();
139     // no actual in-game monster should be reset while still constricting
140     ASSERT(!constricting);
141
142     client_id = 0;
143 }
144
145 void monster::init_with(const monster& mon)
146 {
147     reset();
148
149     mid               = mon.mid;
150     mname             = mon.mname;
151     type              = mon.type;
152     base_monster      = mon.base_monster;
153     hit_points        = mon.hit_points;
154     max_hit_points    = mon.max_hit_points;
155     hit_dice          = mon.hit_dice;
156     ac                = mon.ac;
157     ev                = mon.ev;
158     speed             = mon.speed;
159     speed_increment   = mon.speed_increment;
160     position          = mon.position;
161     target            = mon.target;
162     firing_pos        = mon.firing_pos;
163     patrol_point      = mon.patrol_point;
164     travel_target     = mon.travel_target;
165     travel_path       = mon.travel_path;
166     inv               = mon.inv;
167     spells            = mon.spells;
168     attitude          = mon.attitude;
169     behaviour         = mon.behaviour;
170     foe               = mon.foe;
171     enchantments      = mon.enchantments;
172     ench_cache        = mon.ench_cache;
173     flags             = mon.flags;
174     experience        = mon.experience;
175     number            = mon.number;
176     colour            = mon.colour;
177     foe_memory        = mon.foe_memory;
178     god               = mon.god;
179     props             = mon.props;
180     damage_friendly   = mon.damage_friendly;
181     damage_total      = mon.damage_total;
182
183     if (mon.ghost.get())
184         ghost.reset(new ghost_demon(*mon.ghost));
185     else
186         ghost.reset(NULL);
187 }
188
189 uint32_t monster::last_client_id = 0;
190
191 uint32_t monster::get_client_id() const
192 {
193     return client_id;
194 }
195
196 void monster::reset_client_id()
197 {
198     client_id = 0;
199 }
200
201 void monster::ensure_has_client_id()
202 {
203     if (client_id == 0)
204         client_id = ++last_client_id;
205 }
206
207 mon_attitude_type monster::temp_attitude() const
208 {
209     if (has_ench(ENCH_CHARM))
210         return ATT_FRIENDLY;
211     else
212         return attitude;
213 }
214
215 bool monster::swimming() const
216 {
217     const dungeon_feature_type grid = grd(pos());
218     return (feat_is_watery(grid) && mons_primary_habitat(this) == HT_WATER);
219 }
220
221 bool monster::wants_submerge() const
222 {
223     // Trapdoor spiders only hide themselves under the floor when they
224     // can't see their prey.
225     if (type == MONS_TRAPDOOR_SPIDER)
226     {
227         const actor* _foe = get_foe();
228         return (_foe == NULL || !can_see(_foe));
229     }
230
231     // Don't submerge if we just unsubmerged to shout.
232     if (seen_context == SC_FISH_SURFACES_SHOUT)
233         return false;
234
235     if (!mons_is_retreating(this) && mons_can_move_towards_target(this))
236         return false;
237
238     return !mons_landlubbers_in_reach(this);
239 }
240
241 bool monster::submerged() const
242 {
243     // FIXME, switch to 4.1's MF_SUBMERGED system which is much cleaner.
244     // Can't find any reference to MF_SUBMERGED anywhere. Don't know what
245     // this means. - abrahamwl
246     if (has_ench(ENCH_SUBMERGED))
247         return true;
248
249     if (grd(pos()) == DNGN_DEEP_WATER
250         && (!monster_habitable_grid(this, DNGN_DEEP_WATER)
251             || (mons_genus(type) == MONS_DRACONIAN
252                 && draco_subspecies(this) == MONS_GREY_DRACONIAN))
253         && !can_drown())
254     {
255         return true;
256     }
257
258     return false;
259 }
260
261 bool monster::extra_balanced_at(const coord_def p) const
262 {
263     const dungeon_feature_type grid = grd(p);
264     return ((mons_genus(type) == MONS_DRACONIAN
265              && draco_subspecies(this) == MONS_GREY_DRACONIAN)
266                  || grid == DNGN_SHALLOW_WATER
267                     && (mons_genus(type) == MONS_NAGA // tails, not feet
268                         || body_size(PSIZE_BODY) >= SIZE_LARGE));
269 }
270
271 bool monster::extra_balanced() const
272 {
273     return extra_balanced_at(pos());
274 }
275
276 /*
277  * Monster floundering conditions.
278  *
279  * Floundering reduce the movement speed and can cause the monster to fumble
280  * its attacks. It can be caused by water or by Leda's liquefaction.
281  *
282  * @param pos Coordinates of position to check.
283  * @return Whether the monster would be floundering at p.
284  */
285 bool monster::floundering_at(const coord_def p) const
286 {
287     const dungeon_feature_type grid = grd(p);
288     return (liquefied(p)
289             || (feat_is_water(grid)
290                 // Can't use monster_habitable_grid() because that'll return
291                 // true for non-water monsters in shallow water.
292                 && mons_primary_habitat(this) != HT_WATER
293                 // Use real_amphibious to detect giant non-water monsters in
294                 // deep water, who flounder despite being treated as amphibious.
295                 && mons_habitat(this, true) != HT_AMPHIBIOUS
296                 && !extra_balanced_at(p)))
297            && !cannot_fight()
298            && ground_level();
299 }
300
301 bool monster::floundering() const
302 {
303     return floundering_at(pos());
304 }
305
306 bool monster::can_pass_through_feat(dungeon_feature_type grid) const
307 {
308     return mons_class_can_pass(mons_base_type(this), grid);
309 }
310
311 bool monster::is_habitable_feat(dungeon_feature_type actual_grid) const
312 {
313     return monster_habitable_grid(this, actual_grid);
314 }
315
316 bool monster::can_drown() const
317 {
318     // Presumably a shark in lava or a lavafish in deep water could
319     // drown, but that should never happen, so this simple check should
320     // be enough.
321     switch (mons_primary_habitat(this))
322     {
323     case HT_WATER:
324     case HT_LAVA:
325     case HT_AMPHIBIOUS:
326         return false;
327     default:
328         break;
329     }
330
331     // Mummies can fall apart in water or be incinerated in lava.
332     // Ghouls and vampires can drown in water or lava.  Others just
333     // "sink like a rock", to never be seen again.
334     return (!is_unbreathing()
335             || mons_genus(type) == MONS_MUMMY
336             || mons_genus(type) == MONS_GHOUL
337             || mons_genus(type) == MONS_VAMPIRE);
338 }
339
340 size_type monster::body_size(size_part_type /* psize */, bool /* base */) const
341 {
342     monster_info mi(this, MILEV_NAME);
343     return mi.body_size();
344 }
345
346 int monster::body_weight(bool /*base*/) const
347 {
348     monster_type mc = mons_base_type(this);
349
350     if (mc == MONS_RAKSHASA_FAKE || mc == MONS_MARA_FAKE)
351         return 0;
352
353     int weight = mons_weight(mc);
354
355     // weight == 0 in the monster entry indicates "no corpse".  Can't
356     // use CE_NOCORPSE, because the corpse-effect field is used for
357     // corpseless monsters to indicate what happens if their blood
358     // is sucked.  Grrrr.
359     if (weight == 0 && !is_insubstantial())
360     {
361         weight = actor::body_weight();
362
363         switch (mc)
364         {
365         case MONS_IRON_IMP:
366             weight += 450;
367             break;
368
369         case MONS_IRON_DEVIL:
370             weight += 550;
371             break;
372
373         case MONS_STONE_GOLEM:
374         case MONS_EARTH_ELEMENTAL:
375         case MONS_CRYSTAL_GOLEM:
376             weight *= 2;
377             break;
378
379         case MONS_IRON_DRAGON:
380         case MONS_IRON_GOLEM:
381             weight *= 3;
382             break;
383
384         case MONS_QUICKSILVER_DRAGON:
385         case MONS_SILVER_STATUE:
386         case MONS_STATUE:
387             weight *= 4;
388             break;
389
390         case MONS_FLYING_SKULL:
391         case MONS_CURSE_SKULL:
392         case MONS_BONE_DRAGON:
393         case MONS_SKELETAL_WARRIOR:
394         case MONS_ANCIENT_CHAMPION:
395         case MONS_REVENANT:
396             weight /= 2;
397             break;
398
399         case MONS_SHADOW_FIEND:
400         case MONS_SHADOW_IMP:
401         case MONS_SHADOW_DEMON:
402             weight /= 3;
403             break;
404
405         default: ;
406         }
407
408         if (mons_base_char(mc) == 'L')
409             weight /= 2;
410     }
411
412     if (mc == MONS_SKELETON)
413         weight /= 2;
414
415     // Slime creature weight is multiplied by the number merged.
416     if (mc == MONS_SLIME_CREATURE && number > 1)
417         weight *= number;
418
419     return weight;
420 }
421
422 int monster::total_weight() const
423 {
424     int burden = 0;
425
426     for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
427         if (inv[i] != NON_ITEM)
428             burden += item_mass(mitm[inv[i]]) * mitm[inv[i]].quantity;
429
430     return (body_weight() + burden);
431 }
432
433 brand_type monster::damage_brand(int which_attack)
434 {
435     const item_def *mweap = weapon(which_attack);
436
437     if (!mweap)
438     {
439         if (mons_is_ghost_demon(type))
440             return ghost->brand;
441
442         return SPWPN_NORMAL;
443     }
444
445     return (!is_range_weapon(*mweap) ?
446             static_cast<brand_type>(get_weapon_brand(*mweap)) : SPWPN_NORMAL);
447 }
448
449 int monster::damage_type(int which_attack)
450 {
451     const item_def *mweap = weapon(which_attack);
452
453     if (!mweap)
454     {
455         const mon_attack_def atk = mons_attack_spec(this, which_attack);
456         return ((atk.type == AT_CLAW)          ? DVORP_CLAWING :
457                 (atk.type == AT_TENTACLE_SLAP) ? DVORP_TENTACLE
458                                                : DVORP_CRUSHING);
459     }
460
461     return get_vorpal_type(*mweap);
462 }
463
464 int monster::has_claws(bool allow_tran) const
465 {
466     for (int i = 0; i < MAX_NUM_ATTACKS; i++)
467     {
468         const mon_attack_def atk = mons_attack_spec(this, i);
469         if (atk.type == AT_CLAW)
470         {
471             // Some better criteria would be better.
472             if (body_size() < SIZE_LARGE || atk.damage < 15)
473                 return 1;
474             return 3;
475         }
476     }
477
478     return 0;
479 }
480
481 item_def *monster::missiles()
482 {
483     return (inv[MSLOT_MISSILE] != NON_ITEM ? &mitm[inv[MSLOT_MISSILE]] : NULL);
484 }
485
486 int monster::missile_count()
487 {
488     if (const item_def *missile = missiles())
489         return missile->quantity;
490
491     return 0;
492 }
493
494 item_def *monster::launcher()
495 {
496     item_def *weap = mslot_item(MSLOT_WEAPON);
497     if (weap && is_range_weapon(*weap))
498         return weap;
499
500     weap = mslot_item(MSLOT_ALT_WEAPON);
501     return (weap && is_range_weapon(*weap) ? weap : NULL);
502 }
503
504 // Does not check whether the monster can dual-wield - that is the
505 // caller's responsibility.
506 static int _mons_offhand_weapon_index(const monster* m)
507 {
508     return (m->inv[MSLOT_ALT_WEAPON]);
509 }
510
511 item_def *monster::weapon(int which_attack) const
512 {
513     const mon_attack_def attk = mons_attack_spec(this, which_attack);
514     if (attk.type != AT_HIT && attk.type != AT_WEAP_ONLY)
515         return NULL;
516
517     // Even/odd attacks use main/offhand weapon.
518     if (which_attack > 1)
519         which_attack &= 1;
520
521     // This randomly picks one of the wielded weapons for monsters that can use
522     // two weapons. Not ideal, but better than nothing. fight.cc does it right,
523     // for various values of right.
524     int weap = inv[MSLOT_WEAPON];
525
526     if (which_attack && mons_wields_two_weapons(this))
527     {
528         const int offhand = _mons_offhand_weapon_index(this);
529         if (offhand != NON_ITEM
530             && (weap == NON_ITEM || which_attack == 1 || coinflip()))
531         {
532             weap = offhand;
533         }
534     }
535
536     return (weap == NON_ITEM ? NULL : &mitm[weap]);
537 }
538
539 bool monster::can_wield(const item_def& item, bool ignore_curse,
540                          bool ignore_brand, bool ignore_shield,
541                          bool ignore_transform) const
542 {
543     // Monsters can only wield weapons or go unarmed (OBJ_UNASSIGNED
544     // means unarmed).
545     if (item.base_type != OBJ_WEAPONS && item.base_type != OBJ_UNASSIGNED)
546         return false;
547
548     // These *are* weapons, so they can't wield another weapon or
549     // unwield themselves.
550     if (type == MONS_DANCING_WEAPON)
551         return false;
552
553     // MF_HARD_RESET means that all items the monster is carrying will
554     // disappear when it does, so it can't accept new items or give up
555     // the ones it has.
556     if (flags & MF_HARD_RESET)
557         return false;
558
559     // Summoned items can only be held by summoned monsters.
560     if ((item.flags & ISFLAG_SUMMONED) && !is_summoned())
561         return false;
562
563     item_def* weap1 = NULL;
564     if (inv[MSLOT_WEAPON] != NON_ITEM)
565         weap1 = &mitm[inv[MSLOT_WEAPON]];
566
567     int       avail_slots = 1;
568     item_def* weap2       = NULL;
569     if (mons_wields_two_weapons(this))
570     {
571         if (!weap1 || hands_reqd(*weap1, body_size()) != HANDS_TWO)
572             avail_slots = 2;
573
574         const int offhand = _mons_offhand_weapon_index(this);
575         if (offhand != NON_ITEM)
576             weap2 = &mitm[offhand];
577     }
578
579     // If we're already wielding it, then of course we can wield it.
580     if (&item == weap1 || &item == weap2)
581         return true;
582
583     // Barehanded needs two hands.
584     const bool two_handed = item.base_type == OBJ_UNASSIGNED
585                             || hands_reqd(item, body_size()) == HANDS_TWO;
586
587     item_def* _shield = NULL;
588     if (inv[MSLOT_SHIELD] != NON_ITEM)
589     {
590         ASSERT(!(weap1 && weap2));
591
592         if (two_handed && !ignore_shield)
593             return false;
594
595         _shield = &mitm[inv[MSLOT_SHIELD]];
596     }
597
598     if (!ignore_curse)
599     {
600         int num_cursed = 0;
601         if (weap1 && weap1->cursed())
602             num_cursed++;
603         if (weap2 && weap2->cursed())
604             num_cursed++;
605         if (_shield && _shield->cursed())
606             num_cursed++;
607
608         if (two_handed && num_cursed > 0 || num_cursed >= avail_slots)
609             return false;
610     }
611
612     return could_wield(item, ignore_brand, ignore_transform);
613 }
614
615 bool monster::could_wield(const item_def &item, bool ignore_brand,
616                            bool /* ignore_transform */) const
617 {
618     ASSERT(item.defined());
619
620     // These *are* weapons, so they can't wield another weapon.
621     if (type == MONS_DANCING_WEAPON)
622         return false;
623
624     // Monsters can't use unrandarts with special effects.
625     if (is_special_unrandom_artefact(item) && !crawl_state.game_is_arena())
626         return false;
627
628     // Wimpy monsters (e.g. kobolds, goblins) can't use halberds, etc.
629     if (!check_weapon_wieldable_size(item, body_size()))
630         return false;
631
632     if (!ignore_brand)
633     {
634         const int brand = get_weapon_brand(item);
635
636         // Draconians won't use dragon slaying weapons.
637         if (brand == SPWPN_DRAGON_SLAYING && is_dragonkind(this))
638             return false;
639
640         // Orcs won't use orc slaying weapons.
641         if (brand == SPWPN_ORC_SLAYING && is_orckind(this))
642             return false;
643
644         // Undead and demonic monsters and monsters that are
645         // gifts/worshippers of Yredelemnul won't use holy weapons.
646         if ((undead_or_demonic() || god == GOD_YREDELEMNUL)
647             && is_holy_item(item))
648         {
649             return false;
650         }
651
652         // Holy monsters that aren't gifts/worshippers of chaotic gods
653         // and monsters that are gifts/worshippers of good gods won't
654         // use potentially unholy weapons.
655         if (((is_holy() && !is_chaotic_god(god)) || is_good_god(god))
656             && is_potentially_unholy_item(item))
657         {
658             return false;
659         }
660
661         // Holy monsters and monsters that are gifts/worshippers of good
662         // gods won't use unholy weapons.
663         if ((is_holy() || is_good_god(god)) && is_unholy_item(item))
664             return false;
665
666         // Holy monsters that aren't gifts/worshippers of chaotic gods
667         // and monsters that are gifts/worshippers of good gods won't
668         // use potentially evil weapons.
669         if (((is_holy() && !is_chaotic_god(god))
670                 || is_good_god(god))
671             && is_potentially_evil_item(item))
672         {
673             return false;
674         }
675
676         // Holy monsters and monsters that are gifts/worshippers of good
677         // gods won't use evil weapons.
678         if (((is_holy() || is_good_god(god)))
679             && is_evil_item(item))
680         {
681             return false;
682         }
683
684         // Monsters that are gifts/worshippers of Fedhas won't use
685         // corpse-violating weapons.
686         if (god == GOD_FEDHAS && is_corpse_violating_item(item))
687             return false;
688
689         // Monsters that are gifts/worshippers of Zin won't use unclean
690         // weapons.
691         if (god == GOD_ZIN && is_unclean_item(item))
692             return false;
693
694         // Holy monsters that aren't gifts/worshippers of chaotic gods
695         // and monsters that are gifts/worshippers of good gods won't
696         // use chaotic weapons.
697         if (((is_holy() && !is_chaotic_god(god)) || is_good_god(god))
698             && is_chaotic_item(item))
699         {
700             return false;
701         }
702
703         // Monsters that are gifts/worshippers of TSO won't use poisoned
704         // weapons.
705         if (god == GOD_SHINING_ONE && is_poisoned_item(item))
706             return false;
707     }
708
709     return true;
710 }
711
712 bool monster::can_throw_large_rocks() const
713 {
714     monster_type species = mons_species(false); // zombies can't
715     return (species == MONS_STONE_GIANT
716             || species == MONS_CYCLOPS
717             || species == MONS_OGRE);
718 }
719
720 bool monster::can_speak()
721 {
722     if (has_ench(ENCH_MUTE))
723         return false;
724
725     // Priest and wizard monsters can always speak.
726     if (is_priest() || is_actual_spellcaster())
727         return true;
728
729     // Silent or non-sentient monsters can't use the original speech.
730     if (mons_intel(this) < I_NORMAL
731         || mons_shouts(type) == S_SILENT)
732     {
733         return false;
734     }
735
736     // Does it have the proper vocal equipment?
737     const mon_body_shape shape = get_mon_shape(this);
738     return (shape >= MON_SHAPE_HUMANOID && shape <= MON_SHAPE_NAGA);
739 }
740
741 bool monster::has_spell_of_type(unsigned disciplines) const
742 {
743     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
744     {
745         if (spells[i] == SPELL_NO_SPELL)
746             continue;
747
748         if (spell_typematch(spells[i], disciplines))
749             return true;
750     }
751     return false;
752 }
753
754 void monster::bind_melee_flags()
755 {
756     // Bind fighter / dual-wielder / archer flags from the base type.
757
758     // Alas, we don't know if the mon is zombified at the moment, if it
759     // is, the flags (other than dual-wielder) will be removed later.
760     if (mons_class_flag(type, M_FIGHTER))
761         flags |= MF_FIGHTER;
762     if (mons_class_flag(type, M_TWO_WEAPONS))
763         flags |= MF_TWO_WEAPONS;
764     if (mons_class_flag(type, M_ARCHER))
765         flags |= MF_ARCHER;
766 }
767
768 void monster::bind_spell_flags()
769 {
770     // Bind spellcaster / priest flags from the base type. These may be
771     // overridden by vault defs for individual monsters.
772
773     // Alas, we don't know if the mon is zombified at the moment, if it
774     // is, the flags will be removed later.
775     if (mons_class_flag(type, M_SPELLCASTER))
776         flags |= MF_SPELLCASTER;
777     if (mons_class_flag(type, M_ACTUAL_SPELLS))
778         flags |= MF_ACTUAL_SPELLS;
779     if (mons_class_flag(type, M_PRIEST))
780         flags |= MF_PRIEST;
781
782     if (!mons_is_ghost_demon(type) && mons_has_ranged_spell(this))
783         flags |= MF_SEEN_RANGED;
784 }
785
786 static bool _needs_ranged_attack(const monster* mon)
787 {
788     // Prevent monsters that have conjurations from grabbing missiles.
789     if (mon->has_spell_of_type(SPTYP_CONJURATION))
790         return false;
791
792     // Same for summonings, but make an exception for friendlies.
793     if (!mon->friendly() && mon->has_spell_of_type(SPTYP_SUMMONING))
794         return false;
795
796     // Blademasters don't want to throw stuff.
797     if (mon->type == MONS_DEEP_ELF_BLADEMASTER)
798         return false;
799
800     return true;
801 }
802
803 bool monster::can_use_missile(const item_def &item) const
804 {
805     // Don't allow monsters to pick up missiles without the corresponding
806     // launcher. The opposite is okay, and sufficient wandering will
807     // hopefully take the monster to a stack of appropriate missiles.
808
809     if (!_needs_ranged_attack(this))
810         return false;
811
812     if (item.base_type == OBJ_WEAPONS
813         || item.base_type == OBJ_MISSILES && !has_launcher(item))
814     {
815         return is_throwable(this, item);
816     }
817
818     if (item.base_type != OBJ_MISSILES)
819         return false;
820
821     // Stones are allowed even without launcher.
822     if (item.sub_type == MI_STONE)
823         return true;
824
825     item_def *launch;
826     for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
827     {
828         launch = mslot_item(static_cast<mon_inv_type>(i));
829         if (launch && fires_ammo_type(*launch) == item.sub_type)
830             return true;
831     }
832
833     // No fitting launcher in inventory.
834     return false;
835 }
836
837 void monster::swap_slots(mon_inv_type a, mon_inv_type b)
838 {
839     const int swap = inv[a];
840     inv[a] = inv[b];
841     inv[b] = swap;
842 }
843
844 void monster::equip_weapon(item_def &item, int near, bool msg)
845 {
846     if (msg && !need_message(near))
847         msg = false;
848
849     if (msg)
850     {
851         snprintf(info, INFO_SIZE, " wields %s.",
852                  item.name(DESC_A, false, false, true, false,
853                            ISFLAG_CURSED).c_str());
854         msg = simple_monster_message(this, info);
855     }
856
857     const int brand = get_weapon_brand(item);
858     if (brand == SPWPN_PROTECTION)
859         ac += 5;
860     if (brand == SPWPN_EVASION)
861         ev += 5;
862
863     if (msg)
864     {
865         bool message_given = true;
866         switch (brand)
867         {
868         case SPWPN_FLAMING:
869             mpr("It bursts into flame!");
870             break;
871         case SPWPN_FREEZING:
872             mpr("It glows with a cold blue light!");
873             break;
874         case SPWPN_HOLY_WRATH:
875             mpr("It softly glows with a divine radiance!");
876             break;
877         case SPWPN_ELECTROCUTION:
878             mpr("You hear the crackle of electricity.", MSGCH_SOUND);
879             break;
880         case SPWPN_VENOM:
881             mpr("It begins to drip with poison!");
882             break;
883         case SPWPN_DRAINING:
884             mpr("You sense an unholy aura.");
885             break;
886         case SPWPN_FLAME:
887             mpr("It bursts into flame!");
888             break;
889         case SPWPN_FROST:
890             mpr("It is covered in frost.");
891             break;
892         case SPWPN_RETURNING:
893             mpr("It wiggles slightly.");
894             break;
895         case SPWPN_DISTORTION:
896             mpr("Its appearance distorts for a moment.");
897             break;
898         case SPWPN_CHAOS:
899             mpr("It is briefly surrounded by a scintillating aura of "
900                 "random colours.");
901             break;
902         case SPWPN_PENETRATION:
903             mprf("%s %s briefly pass through it before %s manages to get a "
904                  "firm grip on it.",
905                  pronoun(PRONOUN_POSSESSIVE).c_str(),
906                  hand_name(true).c_str(),
907                  pronoun(PRONOUN_SUBJECTIVE).c_str());
908             break;
909         case SPWPN_REAPING:
910             mpr("It is briefly surrounded by shifting shadows.");
911             break;
912
913         default:
914             // A ranged weapon without special message is known to be unbranded.
915             if (brand != SPWPN_NORMAL || !is_range_weapon(item))
916                 message_given = false;
917         }
918
919         if (message_given)
920         {
921             if (is_artefact(item) && !is_special_unrandom_artefact(item))
922                 artefact_wpn_learn_prop(item, ARTP_BRAND);
923             else
924                 set_ident_flags(item, ISFLAG_KNOW_TYPE);
925         }
926     }
927 }
928
929 int monster::armour_bonus(const item_def &item)
930 {
931     if (is_shield(item))
932         return 0;
933
934     int armour_ac = property(item, PARM_AC);
935     // For concistency with players, we should multiply this by 1 + (skill/22),
936     // where skill may be HD.
937
938     const int armour_plus = item.plus;
939     ASSERT(abs(armour_plus) < 30); // sanity check
940     return armour_ac + armour_plus;
941 }
942
943 void monster::equip_armour(item_def &item, int near)
944 {
945     if (need_message(near))
946     {
947         snprintf(info, INFO_SIZE, " wears %s.",
948                  item.name(DESC_A).c_str());
949         simple_monster_message(this, info);
950     }
951
952     ac += armour_bonus(item);
953     ev += property(item, PARM_EVASION) / (is_shield(item) ? 2 : 6);
954 }
955
956 void monster::equip_jewellery(item_def &item, int near)
957 {
958     ASSERT(item.base_type == OBJ_JEWELLERY);
959
960     if (need_message(near))
961     {
962         snprintf(info, INFO_SIZE, " puts on %s.",
963                  item.name(DESC_A).c_str());
964         simple_monster_message(this, info);
965     }
966
967     if (item.sub_type == AMU_STASIS)
968     {
969         if (has_ench(ENCH_TP))
970             del_ench(ENCH_TP);
971         if (has_ench(ENCH_SLOW))
972             del_ench(ENCH_SLOW);
973         if (has_ench(ENCH_HASTE))
974             del_ench(ENCH_HASTE);
975         if (has_ench(ENCH_PARALYSIS))
976             del_ench(ENCH_PARALYSIS);
977         if (has_ench(ENCH_BERSERK))
978             del_ench(ENCH_BERSERK);
979     }
980
981     if (item.sub_type == AMU_CLARITY)
982     {
983         if (has_ench(ENCH_CONFUSION))
984             del_ench(ENCH_CONFUSION);
985         if (has_ench(ENCH_BERSERK))
986             del_ench(ENCH_BERSERK);
987     }
988
989     if (item.sub_type == RING_PROTECTION)
990     {
991         const int jewellery_plus = item.plus;
992         ASSERT(abs(jewellery_plus) < 30); // sanity check
993         ac += jewellery_plus;
994     }
995
996     if (item.sub_type == RING_EVASION)
997     {
998         const int jewellery_plus = item.plus;
999         ASSERT(abs(jewellery_plus) < 30); // sanity check
1000         ev += jewellery_plus;
1001     }
1002 }
1003
1004 void monster::equip(item_def &item, int slot, int near)
1005 {
1006     switch (item.base_type)
1007     {
1008     case OBJ_WEAPONS:
1009     case OBJ_STAVES:
1010     case OBJ_RODS:
1011     {
1012         bool give_msg = (slot == MSLOT_WEAPON || mons_wields_two_weapons(this));
1013         equip_weapon(item, near, give_msg);
1014         break;
1015     }
1016     case OBJ_ARMOUR:
1017         equip_armour(item, near);
1018         break;
1019
1020     case OBJ_JEWELLERY:
1021         equip_jewellery(item, near);
1022     break;
1023
1024     default:
1025         break;
1026     }
1027 }
1028
1029 void monster::unequip_weapon(item_def &item, int near, bool msg)
1030 {
1031     if (msg && !need_message(near))
1032         msg = false;
1033
1034     if (msg)
1035     {
1036         snprintf(info, INFO_SIZE, " unwields %s.",
1037                              item.name(DESC_A, false, false, true, false,
1038                              ISFLAG_CURSED).c_str());
1039         msg = simple_monster_message(this, info);
1040     }
1041
1042     const int brand = get_weapon_brand(item);
1043     if (brand == SPWPN_PROTECTION)
1044         ac -= 5;
1045     if (brand == SPWPN_EVASION)
1046         ev -= 5;
1047
1048     if (msg && brand != SPWPN_NORMAL)
1049     {
1050         bool message_given = true;
1051         switch (brand)
1052         {
1053         case SPWPN_FLAMING:
1054             mpr("It stops flaming.");
1055             break;
1056
1057         case SPWPN_HOLY_WRATH:
1058             mpr("It stops glowing.");
1059             break;
1060
1061         case SPWPN_ELECTROCUTION:
1062             mpr("It stops crackling.");
1063             break;
1064
1065         case SPWPN_VENOM:
1066             mpr("It stops dripping with poison.");
1067             break;
1068
1069         case SPWPN_DISTORTION:
1070             mpr("Its appearance distorts for a moment.");
1071             break;
1072
1073         default:
1074             message_given = false;
1075         }
1076         if (message_given)
1077         {
1078             if (is_artefact(item) && !is_special_unrandom_artefact(item))
1079                 artefact_wpn_learn_prop(item, ARTP_BRAND);
1080             else
1081                 set_ident_flags(item, ISFLAG_KNOW_TYPE);
1082         }
1083     }
1084 }
1085
1086 void monster::unequip_armour(item_def &item, int near)
1087 {
1088     if (need_message(near))
1089     {
1090         snprintf(info, INFO_SIZE, " takes off %s.",
1091                  item.name(DESC_A).c_str());
1092         simple_monster_message(this, info);
1093     }
1094
1095     ac -= armour_bonus(item);
1096     ev -= property(item, PARM_EVASION) / (is_shield(item) ? 2 : 6);
1097 }
1098
1099 void monster::unequip_jewellery(item_def &item, int near)
1100 {
1101     ASSERT(item.base_type == OBJ_JEWELLERY);
1102
1103     if (need_message(near))
1104     {
1105         snprintf(info, INFO_SIZE, " takes off %s.",
1106                  item.name(DESC_A).c_str());
1107         simple_monster_message(this, info);
1108     }
1109
1110     if (item.sub_type == RING_PROTECTION)
1111     {
1112         const int jewellery_plus = item.plus;
1113         ASSERT(abs(jewellery_plus) < 30);
1114         ac -= jewellery_plus;
1115     }
1116
1117     if (item.sub_type == RING_EVASION)
1118     {
1119         const int jewellery_plus = item.plus;
1120         ASSERT(abs(jewellery_plus) < 30);
1121         ev -= jewellery_plus;
1122     }
1123 }
1124
1125 bool monster::unequip(item_def &item, int slot, int near, bool force)
1126 {
1127     if (!force && item.cursed())
1128         return false;
1129
1130     if (!force && you.can_see(this))
1131         set_ident_flags(item, ISFLAG_KNOW_CURSE);
1132
1133     switch (item.base_type)
1134     {
1135     case OBJ_WEAPONS:
1136     {
1137         bool give_msg = (slot == MSLOT_WEAPON || mons_wields_two_weapons(this));
1138         unequip_weapon(item, near, give_msg);
1139         break;
1140     }
1141     case OBJ_ARMOUR:
1142         unequip_armour(item, near);
1143         break;
1144
1145     case OBJ_JEWELLERY:
1146         unequip_jewellery(item, near);
1147     break;
1148
1149     default:
1150         break;
1151     }
1152
1153     return true;
1154 }
1155
1156 void monster::lose_pickup_energy()
1157 {
1158     if (const monsterentry* entry = find_monsterentry())
1159     {
1160         const int delta = speed * entry->energy_usage.pickup_percent / 100;
1161         if (speed_increment > 25 && delta < speed_increment)
1162             speed_increment -= delta;
1163     }
1164 }
1165
1166 void monster::pickup_message(const item_def &item, int near)
1167 {
1168     if (need_message(near))
1169     {
1170         if (is_range_weapon(item)
1171             || is_throwable(this, item)
1172             || item.base_type == OBJ_MISSILES)
1173         {
1174             flags |= MF_SEEN_RANGED;
1175         }
1176
1177         mprf("%s picks up %s.",
1178              name(DESC_THE).c_str(),
1179              item.base_type == OBJ_GOLD ? "some gold"
1180                                         : item.name(DESC_A).c_str());
1181     }
1182 }
1183
1184 bool monster::pickup(item_def &item, int slot, int near, bool force_merge)
1185 {
1186     ASSERT(item.defined());
1187
1188     const monster* other_mon = item.holding_monster();
1189
1190     if (other_mon != NULL)
1191     {
1192         if (other_mon == this)
1193         {
1194             if (inv[slot] == item.index())
1195             {
1196                 mprf(MSGCH_DIAGNOSTICS, "Monster %s already holding item %s.",
1197                      name(DESC_PLAIN, true).c_str(),
1198                      item.name(DESC_PLAIN, false, true).c_str());
1199                 return false;
1200             }
1201             else
1202             {
1203                 mprf(MSGCH_DIAGNOSTICS, "Item %s thinks it's already held by "
1204                                         "monster %s.",
1205                      item.name(DESC_PLAIN, false, true).c_str(),
1206                      name(DESC_PLAIN, true).c_str());
1207             }
1208         }
1209         else if (other_mon->type == MONS_NO_MONSTER)
1210         {
1211             mprf(MSGCH_DIAGNOSTICS, "Item %s, held by dead monster, being "
1212                                     "picked up by monster %s.",
1213                  item.name(DESC_PLAIN, false, true).c_str(),
1214                  name(DESC_PLAIN, true).c_str());
1215         }
1216         else
1217         {
1218             mprf(MSGCH_DIAGNOSTICS, "Item %s, held by monster %s, being "
1219                                     "picked up by monster %s.",
1220                  item.name(DESC_PLAIN, false, true).c_str(),
1221                  other_mon->name(DESC_PLAIN, true).c_str(),
1222                  name(DESC_PLAIN, true).c_str());
1223         }
1224     }
1225
1226     // If a monster chooses a two-handed weapon as main weapon, it will
1227     // first have to drop any shield it might wear.
1228     // (Monsters will always favour damage over protection.)
1229     if ((slot == MSLOT_WEAPON || slot == MSLOT_ALT_WEAPON)
1230         && inv[MSLOT_SHIELD] != NON_ITEM
1231         && hands_reqd(item, body_size()) == HANDS_TWO)
1232     {
1233         if (!drop_item(MSLOT_SHIELD, near))
1234             return false;
1235     }
1236
1237     // Similarly, monsters won't pick up shields if they're
1238     // wielding (or alt-wielding) a two-handed weapon.
1239     if (slot == MSLOT_SHIELD)
1240     {
1241         const item_def* wpn = mslot_item(MSLOT_WEAPON);
1242         const item_def* alt = mslot_item(MSLOT_ALT_WEAPON);
1243         if (wpn && hands_reqd(*wpn, body_size()) == HANDS_TWO)
1244             return false;
1245         if (alt && hands_reqd(*alt, body_size()) == HANDS_TWO)
1246             return false;
1247     }
1248
1249     if (inv[slot] != NON_ITEM)
1250     {
1251         item_def &dest(mitm[inv[slot]]);
1252         if (items_stack(item, dest, force_merge))
1253         {
1254             dungeon_events.fire_position_event(
1255                 dgn_event(DET_ITEM_PICKUP, pos(), 0, item.index(),
1256                           mindex()),
1257                 pos());
1258
1259             pickup_message(item, near);
1260             inc_mitm_item_quantity(inv[slot], item.quantity);
1261             merge_item_stacks(item, dest);
1262             destroy_item(item.index());
1263             equip(item, slot, near);
1264             lose_pickup_energy();
1265             return true;
1266         }
1267         return false;
1268     }
1269
1270     if (item.flags & ISFLAG_MIMIC && !mons_is_item_mimic(type))
1271         return false;
1272
1273     dungeon_events.fire_position_event(
1274         dgn_event(DET_ITEM_PICKUP, pos(), 0, item.index(),
1275                   mindex()),
1276         pos());
1277
1278     const int item_index = item.index();
1279     unlink_item(item_index);
1280
1281     inv[slot] = item_index;
1282
1283     item.set_holding_monster(mindex());
1284
1285     pickup_message(item, near);
1286     if (!mons_is_item_mimic(type))
1287         equip(item, slot, near);
1288     lose_pickup_energy();
1289     return true;
1290 }
1291
1292 bool monster::drop_item(int eslot, int near)
1293 {
1294     if (eslot < 0 || eslot >= NUM_MONSTER_SLOTS)
1295         return false;
1296
1297     int item_index = inv[eslot];
1298     if (item_index == NON_ITEM)
1299         return true;
1300
1301     item_def* pitem = &mitm[item_index];
1302
1303     // Unequip equipped items before dropping them; unequip() prevents
1304     // cursed items from being removed.
1305     bool was_unequipped = false;
1306     if (eslot == MSLOT_WEAPON
1307         || eslot == MSLOT_ARMOUR
1308         || eslot == MSLOT_JEWELLERY
1309         || eslot == MSLOT_ALT_WEAPON && mons_wields_two_weapons(this))
1310     {
1311         if (!unequip(*pitem, eslot, near))
1312             return false;
1313         was_unequipped = true;
1314     }
1315
1316     if (pitem->flags & ISFLAG_SUMMONED)
1317     {
1318         if (need_message(near))
1319         {
1320             mprf("%s %s as %s drops %s!",
1321                  pitem->name(DESC_THE).c_str(),
1322                  summoned_poof_msg(this, *pitem).c_str(),
1323                  name(DESC_THE).c_str(),
1324                  pitem->quantity > 1 ? "them" : "it");
1325         }
1326
1327         item_was_destroyed(*pitem, mindex());
1328         destroy_item(item_index);
1329     }
1330     else
1331     {
1332         if (need_message(near))
1333         {
1334             mprf("%s drops %s.", name(DESC_THE).c_str(),
1335                  pitem->name(DESC_A).c_str());
1336         }
1337
1338         if (!move_item_to_grid(&item_index, pos(), swimming()))
1339         {
1340             // Re-equip item if we somehow failed to drop it.
1341             if (was_unequipped)
1342                 equip(*pitem, eslot, near);
1343
1344             return false;
1345         }
1346
1347         if (friendly() && item_index != NON_ITEM)
1348         {
1349             // move_item_to_grid could change item_index, so
1350             // update pitem.
1351             pitem = &mitm[item_index];
1352
1353             pitem->flags |= ISFLAG_DROPPED_BY_ALLY;
1354         }
1355     }
1356
1357     if (props.exists("wand_known") && near && pitem->base_type == OBJ_WANDS)
1358         props.erase("wand_known");
1359
1360     inv[eslot] = NON_ITEM;
1361     return true;
1362 }
1363
1364 // We don't want monsters to pick up ammunition that is identical to the
1365 // launcher brand, in hope of another monster wandering by who may want to
1366 // use the ammo in question.
1367 static bool _nonredundant_launcher_ammo_brands(item_def *launcher,
1368                                              const item_def *ammo)
1369 {
1370     // If the monster has no ammo then there's no redundancy problems
1371     // to check.
1372     if (ammo == NULL)
1373         return true;
1374
1375     const int bow_brand  = get_weapon_brand(*launcher);
1376     const int ammo_brand = get_ammo_brand(*ammo);
1377
1378     switch (ammo_brand)
1379     {
1380     case SPMSL_FLAME:
1381         return (bow_brand != SPWPN_FLAME);
1382     case SPMSL_FROST:
1383         return (bow_brand != SPWPN_FROST);
1384     case SPMSL_CHAOS:
1385         return (bow_brand != SPWPN_CHAOS);
1386     case SPMSL_PENETRATION:
1387         return (bow_brand != SPWPN_PENETRATION);
1388     default:
1389         return true;
1390     }
1391 }
1392
1393 bool monster::pickup_launcher(item_def &launch, int near, bool force)
1394 {
1395     // Don't allow monsters to pick up launchers that would also
1396     // refuse to pick up the matching ammo.
1397     if (!force && !_needs_ranged_attack(this))
1398         return false;
1399
1400     // Don't allow monsters to switch to another type of launcher
1401     // as that would require them to also drop their ammunition
1402     // and then try to find ammunition for their new launcher.
1403     // However, they may switch to another launcher if they're
1404     // out of ammo. (jpeg)
1405     const int mdam_rating = mons_weapon_damage_rating(launch);
1406     const missile_type mt = fires_ammo_type(launch);
1407     int eslot = -1;
1408     for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
1409     {
1410         if (const item_def *elaunch = mslot_item(static_cast<mon_inv_type>(i)))
1411         {
1412             if (!is_range_weapon(*elaunch))
1413                 continue;
1414
1415             return ((fires_ammo_type(*elaunch) == mt || !missiles())
1416                     && (mons_weapon_damage_rating(*elaunch) < mdam_rating
1417                         || mons_weapon_damage_rating(*elaunch) == mdam_rating
1418                            && get_weapon_brand(*elaunch) == SPWPN_NORMAL
1419                            && get_weapon_brand(launch) != SPWPN_NORMAL
1420                            && _nonredundant_launcher_ammo_brands(&launch,
1421                                                                  missiles()))
1422                     && drop_item(i, near) && pickup(launch, i, near));
1423         }
1424         else
1425             eslot = i;
1426     }
1427
1428     return (eslot == -1 ? false : pickup(launch, eslot, near));
1429 }
1430
1431 static bool _is_signature_weapon(monster* mons, const item_def &weapon)
1432 {
1433     if (mons->type == MONS_DEEP_DWARF_ARTIFICER)
1434         return (weapon.base_type == OBJ_RODS);
1435
1436     // Don't pick up items that would interfere with our special ability
1437     if (mons->type == MONS_RED_DEVIL)
1438         return (weapon_skill(weapon) == SK_POLEARMS);
1439
1440     // Some other uniques have a signature weapon, usually because they
1441     // always spawn with it, or because it is referenced in their speech
1442     // and/or descriptions.
1443     // Upgrading to a similar type is pretty much always allowed, unless
1444     // we are more interested in the brand, and the brand is *rare*.
1445     if (mons_is_unique(mons->type))
1446     {
1447         weapon_type wtype = (weapon.base_type == OBJ_WEAPONS) ?
1448             (weapon_type)weapon.sub_type : NUM_WEAPONS;
1449
1450         // We might allow Sigmund to pick up a better scythe if he finds
1451         // one...
1452         if (mons->type == MONS_SIGMUND)
1453             return (wtype == WPN_SCYTHE);
1454
1455         // Crazy Yiuf's got MONUSE_STARTING_EQUIPMENT right now, but
1456         // in case that ever changes we don't want him to switch away
1457         // from his quarterstaff of chaos.
1458         if (mons->type == MONS_CRAZY_YIUF)
1459         {
1460             return wtype == WPN_QUARTERSTAFF
1461                    && get_weapon_brand(weapon) == SPWPN_CHAOS;
1462         }
1463
1464         // Distortion/chaos is immensely flavourful, and we shouldn't
1465         // allow Psyche to switch away from it.
1466         if (mons->type == MONS_PSYCHE)
1467         {
1468             return get_weapon_brand(weapon) == SPWPN_CHAOS
1469                    || get_weapon_brand(weapon) == SPWPN_DISTORTION;
1470         }
1471
1472         // Don't switch Azrael away from the customary scimitar of
1473         // flaming.
1474         if (mons->type == MONS_AZRAEL)
1475         {
1476             return wtype == WPN_SCIMITAR
1477                    && get_weapon_brand(weapon) == SPWPN_FLAMING;
1478         }
1479
1480         if (mons->type == MONS_AGNES)
1481             return (wtype == WPN_LAJATANG);
1482
1483         if (mons->type == MONS_EDMUND)
1484             return (wtype == WPN_FLAIL || wtype == WPN_DIRE_FLAIL);
1485
1486         // Pikel's got MONUSE_STARTING_EQUIPMENT right now, but,
1487         // in case that ever changes, we don't want him to switch away
1488         // from a whip.
1489         if (mons->type == MONS_PIKEL)
1490             return (get_vorpal_type(weapon) == DVORP_SLASHING);
1491
1492         if (mons->type == MONS_WIGLAF)
1493             return (weapon_skill(weapon) == SK_AXES);
1494
1495         if (mons->type == MONS_NIKOLA)
1496             return (get_weapon_brand(weapon) == SPWPN_ELECTROCUTION);
1497
1498         if (mons->type == MONS_DUVESSA)
1499         {
1500             return (weapon_skill(weapon) == SK_SHORT_BLADES
1501                     || weapon_skill(weapon) == SK_LONG_BLADES);
1502         }
1503
1504         if (mons->type == MONS_IGNACIO)
1505             return (wtype == WPN_EXECUTIONERS_AXE);
1506
1507         if (mons->type == MONS_MENNAS)
1508             return (get_weapon_brand(weapon) == SPWPN_HOLY_WRATH);
1509
1510         if (mons->type == MONS_ARACHNE)
1511         {
1512             return (weapon.base_type == OBJ_STAVES
1513                         && weapon.sub_type == STAFF_POISON
1514                     || weapon.base_type == OBJ_WEAPONS
1515                         && weapon.special == UNRAND_OLGREB);
1516         }
1517
1518         if (mons->type == MONS_FANNAR)
1519         {
1520             return (weapon.base_type == OBJ_STAVES
1521                     && weapon.sub_type == STAFF_COLD);
1522         }
1523     }
1524
1525     if (mons->is_holy())
1526         return is_blessed(weapon);
1527
1528     if (is_unrandom_artefact(weapon))
1529     {
1530         switch (weapon.special)
1531         {
1532         case UNRAND_ASMODEUS:
1533             return (mons->type == MONS_ASMODEUS);
1534
1535         case UNRAND_DISPATER:
1536             return (mons->type == MONS_DISPATER);
1537
1538         case UNRAND_CEREBOV:
1539             return (mons->type == MONS_CEREBOV);
1540
1541         case UNRAND_MORG:
1542             return (mons->type == MONS_BORIS);
1543         }
1544     }
1545
1546     return false;
1547 }
1548
1549 static int _ego_damage_bonus(item_def &item)
1550 {
1551     switch (get_weapon_brand(item))
1552     {
1553     case SPWPN_NORMAL:      return 0;
1554     case SPWPN_VORPAL:      // deliberate
1555     case SPWPN_PROTECTION:  // fall through
1556     case SPWPN_EVASION:     return 1;
1557     default:                return 2;
1558     }
1559 }
1560
1561 static bool _item_race_matches_monster(const item_def &item, monster* mons)
1562 {
1563     if (get_equip_race(item) == ISFLAG_ELVEN)
1564         return (mons_genus(mons->type) == MONS_ELF);
1565
1566     if (get_equip_race(item) == ISFLAG_DWARVEN)
1567         return (mons_genus(mons->type) == MONS_DWARF);
1568
1569     if (get_equip_race(item) == ISFLAG_ORCISH)
1570         return (mons_genus(mons->type) == MONS_ORC);
1571
1572     return false;
1573 }
1574
1575 bool monster::pickup_melee_weapon(item_def &item, int near)
1576 {
1577     // Throwable weapons may be picked up as though dual-wielding.
1578     const bool dual_wielding = (mons_wields_two_weapons(this)
1579                                 || is_throwable(this, item));
1580     if (dual_wielding && item.quantity == 1)
1581     {
1582         // If we have either weapon slot free, pick up the weapon.
1583         if (inv[MSLOT_WEAPON] == NON_ITEM)
1584             return pickup(item, MSLOT_WEAPON, near);
1585
1586         if (inv[MSLOT_ALT_WEAPON] == NON_ITEM)
1587             return pickup(item, MSLOT_ALT_WEAPON, near);
1588     }
1589
1590     const int new_wpn_dam = mons_weapon_damage_rating(item)
1591                             + _ego_damage_bonus(item);
1592     int eslot = -1;
1593     item_def *weap;
1594
1595     // Monsters have two weapon slots, one of which can be a ranged, and
1596     // the other a melee weapon. (The exception being dual-wielders who can
1597     // wield two melee weapons). The weapon in MSLOT_WEAPON is the one
1598     // currently wielded (can be empty).
1599
1600     for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
1601     {
1602         weap = mslot_item(static_cast<mon_inv_type>(i));
1603
1604         // If the weapon is a stack of throwing weaons, the monster
1605         // will not use the stack as their primary melee weapon.
1606         if (item.quantity != 1 && i == MSLOT_WEAPON)
1607             continue;
1608
1609         if (!weap)
1610         {
1611             // If no weapon in this slot, mark this one.
1612             if (eslot == -1)
1613                 eslot = i;
1614         }
1615         else
1616         {
1617             if (is_range_weapon(*weap))
1618                 continue;
1619
1620             // Don't swap from a signature weapon to a non-signature one.
1621             if (!_is_signature_weapon(this, item)
1622                 && _is_signature_weapon(this, *weap))
1623             {
1624                 if (dual_wielding)
1625                     continue;
1626                 else
1627                     return false;
1628             }
1629
1630             // If we get here, the weapon is a melee weapon.
1631             // If the new weapon is better than the current one and not cursed,
1632             // replace it. Otherwise, give up.
1633             const int old_wpn_dam = mons_weapon_damage_rating(*weap)
1634                                     + _ego_damage_bonus(*weap);
1635
1636             bool new_wpn_better = (new_wpn_dam > old_wpn_dam);
1637             if (new_wpn_dam == old_wpn_dam)
1638             {
1639                 // Use shopping value as a crude estimate of resistances etc.
1640                 // XXX: This is not really logical as many properties don't
1641                 //      apply to monsters (e.g. flight, blink, berserk).
1642                 // For simplicity, don't apply this check to secondary weapons
1643                 // for dual wielding monsters.
1644                 int oldval = item_value(*weap, true);
1645                 int newval = item_value(item, true);
1646
1647                 // Vastly prefer matching racial type.
1648                 if (_item_race_matches_monster(*weap, this))
1649                     oldval *= 2;
1650                 if (_item_race_matches_monster(item, this))
1651                     newval *= 2;
1652
1653                 if (newval > oldval)
1654                     new_wpn_better = true;
1655             }
1656
1657             if (new_wpn_better && !weap->cursed())
1658             {
1659                 if (!dual_wielding
1660                     || i == MSLOT_WEAPON
1661                     || old_wpn_dam
1662                        < mons_weapon_damage_rating(*mslot_item(MSLOT_WEAPON))
1663                          + _ego_damage_bonus(*mslot_item(MSLOT_WEAPON)))
1664                 {
1665                     eslot = i;
1666                     if (!dual_wielding)
1667                         break;
1668                 }
1669             }
1670             else if (!dual_wielding)
1671             {
1672                 // We've got a good melee weapon, that's enough.
1673                 return false;
1674             }
1675         }
1676     }
1677
1678     // No slot found to place this item.
1679     if (eslot == -1)
1680         return false;
1681
1682     // Current item cannot be dropped.
1683     if (inv[eslot] != NON_ITEM && !drop_item(eslot, near))
1684         return false;
1685
1686     return pickup(item, eslot, near);
1687 }
1688
1689 // Arbitrary damage adjustment for quantity of missiles. So sue me.
1690 static int _q_adj_damage(int damage, int qty)
1691 {
1692     return (damage * min(qty, 8));
1693 }
1694
1695 bool monster::pickup_throwable_weapon(item_def &item, int near)
1696 {
1697     const mon_inv_type slot = item_to_mslot(item);
1698
1699     // If it's a melee weapon then pickup_melee_weapon() already rejected
1700     // it, even though it can also be thrown.
1701     if (slot == MSLOT_WEAPON)
1702         return false;
1703
1704     ASSERT(slot == MSLOT_MISSILE);
1705
1706     // Spellcasters shouldn't bother with missiles.
1707     if (mons_has_ranged_spell(this, true, false))
1708         return false;
1709
1710     // If occupied, don't pick up a throwable weapons if it would just
1711     // stack with an existing one. (Upgrading is possible.)
1712     if (mslot_item(slot)
1713         && (mons_is_wandering(this) || friendly() && foe == MHITYOU)
1714         && pickup(item, slot, near, true))
1715     {
1716         return true;
1717     }
1718
1719     item_def *launch = NULL;
1720     const int exist_missile = mons_pick_best_missile(this, &launch, true);
1721     if (exist_missile == NON_ITEM
1722         || (_q_adj_damage(mons_missile_damage(this, launch,
1723                                               &mitm[exist_missile]),
1724                           mitm[exist_missile].quantity)
1725             < _q_adj_damage(mons_thrown_weapon_damage(&item), item.quantity)))
1726     {
1727         if (inv[slot] != NON_ITEM && !drop_item(slot, near))
1728             return false;
1729         return pickup(item, slot, near);
1730     }
1731     return false;
1732 }
1733
1734 bool monster::wants_weapon(const item_def &weap) const
1735 {
1736     if (!could_wield(weap))
1737         return false;
1738
1739     // Blademasters and master archers like their starting weapon and
1740     // don't want another, thank you.
1741     if (type == MONS_DEEP_ELF_BLADEMASTER
1742         || type == MONS_DEEP_ELF_MASTER_ARCHER)
1743     {
1744         return false;
1745     }
1746
1747     // Monsters capable of dual-wielding will always prefer two weapons
1748     // to a single two-handed one, however strong.
1749     if (mons_wields_two_weapons(this)
1750         && hands_reqd(weap, body_size()) == HANDS_TWO)
1751     {
1752         return false;
1753     }
1754
1755     // Arcane spellcasters don't want -CAST.
1756     if (is_actual_spellcaster()
1757         && is_artefact(weap)
1758         && artefact_wpn_property(weap, ARTP_PREVENT_SPELLCASTING))
1759     {
1760         return false;
1761     }
1762
1763     // Nobody picks up giant clubs. Starting equipment is okay, of course.
1764     if (is_giant_club_type(weap.sub_type))
1765         return false;
1766
1767     return true;
1768 }
1769
1770 bool monster::wants_armour(const item_def &item) const
1771 {
1772     // Monsters that are capable of dual wielding won't pick up shields.
1773     // Neither will monsters that are already wielding a two-hander.
1774     if (is_shield(item)
1775         && (mons_wields_two_weapons(this)
1776             || mslot_item(MSLOT_WEAPON)
1777                && hands_reqd(*mslot_item(MSLOT_WEAPON), body_size())
1778                       == HANDS_TWO))
1779     {
1780         return false;
1781     }
1782
1783     // Spellcasters won't pick up restricting armour, although they can
1784     // start with one.  Applies to arcane spells only, of course.
1785     if (!pos().origin() && is_actual_spellcaster()
1786         && (property(item, PARM_EVASION) < -5
1787             || is_artefact(item)
1788                && artefact_wpn_property(item, ARTP_PREVENT_SPELLCASTING)))
1789     {
1790         return false;
1791     }
1792
1793     // Returns whether this armour is the monster's size.
1794     return (check_armour_size(item, body_size()));
1795 }
1796
1797 bool monster::wants_jewellery(const item_def &item) const
1798 {
1799     // Arcane spellcasters don't want -CAST.
1800     if (is_actual_spellcaster()
1801         && is_artefact(item)
1802         && artefact_wpn_property(item, ARTP_PREVENT_SPELLCASTING))
1803     {
1804         return false;
1805     }
1806
1807     if (item.sub_type == AMU_INACCURACY)
1808         return false;
1809
1810     // TODO: figure out what monsters actually want rings or amulets
1811     return true;
1812 }
1813
1814 // Monsters magically know the real properties of all items.
1815 static int _get_monster_armour_value(const monster *mon,
1816                                      const item_def &item)
1817 {
1818     // Each resistance/property counts as much as 1 point of AC.
1819     // Steam has been excluded because of its general uselessness.
1820     // Well, the same's true for sticky flame but... (jpeg)
1821     int value  = item.armour_rating();
1822         value += get_armour_res_fire(item, true);
1823         value += get_armour_res_cold(item, true);
1824         value += get_armour_res_elec(item, true);
1825         value += get_armour_res_sticky_flame(item);
1826
1827     // Give a simple bonus, no matter the size of the MR bonus.
1828     if (get_armour_res_magic(item, true) > 0)
1829         value++;
1830
1831     // Poison becomes much less valuable if the monster is
1832     // intrinsically resistant.
1833     if (get_mons_resist(mon, MR_RES_POISON) <= 0)
1834         value += get_armour_res_poison(item, true);
1835
1836     // Same for life protection.
1837     if (mon->holiness() == MH_NATURAL)
1838         value += get_armour_life_protection(item, true);
1839
1840     // See invisible also is only useful if not already intrinsic.
1841     if (!mons_class_flag(mon->type, M_SEE_INVIS))
1842         value += get_armour_see_invisible(item, true);
1843
1844     // Likewise rCorr
1845     if (get_armour_ego_type(item) == SPARM_PRESERVATION
1846         && !mon->res_corr(false, false))
1847     {
1848         value++;
1849     }
1850
1851     // Give a sizable bonus for shields of reflection.
1852     if (get_armour_ego_type(item) == SPARM_REFLECTION)
1853         value += 3;
1854
1855     // And an even more sizable bonus for boots/bardings of running.
1856     if (get_armour_ego_type(item) == SPARM_RUNNING)
1857         value += 5;
1858
1859     return value;
1860 }
1861
1862 bool monster::pickup_armour(item_def &item, int near, bool force)
1863 {
1864     ASSERT(item.base_type == OBJ_ARMOUR);
1865
1866     if (!force && !wants_armour(item))
1867         return false;
1868
1869     equipment_type eq = EQ_NONE;
1870
1871     // HACK to allow nagas/centaurs to wear bardings. (jpeg)
1872     switch (item.sub_type)
1873     {
1874     case ARM_NAGA_BARDING:
1875         if (::mons_genus(type) == MONS_NAGA)
1876             eq = EQ_BODY_ARMOUR;
1877         break;
1878     case ARM_CENTAUR_BARDING:
1879         if (::mons_species(type) == MONS_CENTAUR
1880             || ::mons_species(type) == MONS_YAKTAUR)
1881         {
1882             eq = EQ_BODY_ARMOUR;
1883         }
1884         break;
1885     // And another hack or two...
1886     case ARM_WIZARD_HAT:
1887     case ARM_CAP:
1888         if (type == MONS_GASTRONOK || type == MONS_OCTOPODE)
1889             eq = EQ_BODY_ARMOUR;
1890         break;
1891     case ARM_CLOAK:
1892         if (type == MONS_MAURICE
1893             || type == MONS_NIKOLA
1894             || type == MONS_CRAZY_YIUF
1895             || ::mons_genus(type) == MONS_DRACONIAN)
1896         {
1897             eq = EQ_BODY_ARMOUR;
1898         }
1899         break;
1900     case ARM_GLOVES:
1901         if (type == MONS_NIKOLA)
1902             eq = EQ_SHIELD;
1903         break;
1904     default:
1905         eq = get_armour_slot(item);
1906
1907         if (eq == EQ_BODY_ARMOUR && mons_genus(type) == MONS_DRACONIAN)
1908             return false;
1909
1910         if (eq != EQ_HELMET && (type == MONS_OCTOPODE || type == MONS_GASTRONOK))
1911             return false;
1912     }
1913
1914     // Bardings are only wearable by the appropriate monster.
1915     if (eq == EQ_NONE)
1916         return false;
1917
1918     // XXX: Monsters can only equip body armour and shields (as of 0.4).
1919     if (!force && eq != EQ_BODY_ARMOUR && eq != EQ_SHIELD)
1920         return false;
1921
1922     const mon_inv_type mslot = equip_slot_to_mslot(eq);
1923     if (mslot == NUM_MONSTER_SLOTS)
1924         return false;
1925
1926     int value_new = _get_monster_armour_value(this, item);
1927
1928     // No armour yet -> get this one.
1929     if (!mslot_item(mslot) && value_new > 0)
1930         return pickup(item, mslot, near);
1931
1932     // Simplistic armour evaluation (comparing AC and resistances).
1933     if (const item_def *existing_armour = slot_item(eq, false))
1934     {
1935         if (!force)
1936         {
1937             int value_old = _get_monster_armour_value(this,
1938                                                       *existing_armour);
1939             if (value_old > value_new)
1940                 return false;
1941
1942             if (value_old == value_new)
1943             {
1944                 // Prefer matching racial type.
1945                 if (_item_race_matches_monster(*existing_armour, this))
1946                     value_old++;
1947                 if (_item_race_matches_monster(item, this))
1948                     value_new++;
1949
1950                 if (value_old == value_new)
1951                 {
1952                     // If items are of the same value, use shopping
1953                     // value as a further crude estimate.
1954                     value_old = item_value(*existing_armour, true);
1955                     value_new = item_value(item, true);
1956                 }
1957                 if (value_old >= value_new)
1958                     return false;
1959             }
1960         }
1961
1962         if (!drop_item(mslot, near))
1963             return false;
1964     }
1965
1966     return pickup(item, mslot, near);
1967 }
1968
1969 static int _get_monster_jewellery_value(const monster *mon,
1970                                    const item_def &item)
1971 {
1972     ASSERT(item.base_type == OBJ_JEWELLERY);
1973
1974     // Each resistance/property counts as one point.
1975     int value = 0;
1976
1977     if (item.sub_type == RING_PROTECTION
1978         || item.sub_type == RING_EVASION
1979         || item.sub_type == RING_SLAYING)
1980     {
1981         value += item.plus;
1982     }
1983
1984     if (item.sub_type == RING_SLAYING)
1985         value += item.plus2;
1986
1987     if (item.sub_type == AMU_INACCURACY)
1988         value -= 5;
1989
1990     value += get_jewellery_res_fire(item, true);
1991     value += get_jewellery_res_cold(item, true);
1992     value += get_jewellery_res_elec(item, true);
1993
1994     // Give a simple bonus, no matter the size of the MR bonus.
1995     if (get_jewellery_res_magic(item, true) > 0)
1996         value++;
1997
1998     // Poison becomes much less valuable if the monster is
1999     // intrinsically resistant.
2000     if (get_mons_resist(mon, MR_RES_POISON) <= 0)
2001         value += get_jewellery_res_poison(item, true);
2002
2003     // Same for life protection.
2004     if (mon->holiness() == MH_NATURAL)
2005         value += get_jewellery_life_protection(item, true);
2006
2007     // See invisible also is only useful if not already intrinsic.
2008     if (!mons_class_flag(mon->type, M_SEE_INVIS))
2009         value += get_jewellery_see_invisible(item, true);
2010
2011     // If we're not naturally corrosion-resistant.
2012     if (item.sub_type == AMU_RESIST_CORROSION && !mon->res_corr(false, false))
2013         value++;
2014
2015     return value;
2016 }
2017
2018 bool monster::pickup_jewellery(item_def &item, int near, bool force)
2019 {
2020     ASSERT(item.base_type == OBJ_JEWELLERY);
2021
2022     if (!force && !wants_jewellery(item))
2023         return false;
2024
2025     equipment_type eq = EQ_RINGS;
2026
2027     const mon_inv_type mslot = equip_slot_to_mslot(eq);
2028     if (mslot == NUM_MONSTER_SLOTS)
2029         return false;
2030
2031     int value_new = _get_monster_jewellery_value(this, item);
2032
2033     // No armour yet -> get this one.
2034     if (!mslot_item(mslot) && value_new > 0)
2035         return pickup(item, mslot, near);
2036
2037     // Simplistic jewellery evaluation (comparing AC and resistances).
2038     if (const item_def *existing_jewellery = slot_item(eq, false))
2039     {
2040         if (!force)
2041         {
2042             int value_old = _get_monster_jewellery_value(this,
2043                                                          *existing_jewellery);
2044             if (value_old > value_new)
2045                 return false;
2046
2047             if (value_old == value_new)
2048             {
2049                 // If items are of the same value, use shopping
2050                 // value as a further crude estimate.
2051                 value_old = item_value(*existing_jewellery, true);
2052                 value_new = item_value(item, true);
2053                 if (value_old >= value_new)
2054                     return false;
2055             }
2056         }
2057
2058         if (!drop_item(mslot, near))
2059             return false;
2060     }
2061
2062     return pickup(item, mslot, near);
2063 }
2064
2065 bool monster::pickup_weapon(item_def &item, int near, bool force)
2066 {
2067     if (!force && !wants_weapon(item))
2068         return false;
2069
2070     // Weapon pickup involves:
2071     // - If we have no weapons, always pick this up.
2072     // - If this is a melee weapon and we already have a melee weapon, pick
2073     //   it up if it is superior to the one we're carrying (and drop the
2074     //   one we have).
2075     // - If it is a ranged weapon, and we already have a ranged weapon,
2076     //   pick it up if it is better than the one we have.
2077     // - If it is a throwable weapon, and we're carrying no missiles (or our
2078     //   missiles are the same type), pick it up.
2079
2080     if (is_range_weapon(item))
2081         return pickup_launcher(item, near, force);
2082
2083     if (pickup_melee_weapon(item, near))
2084         return true;
2085
2086     return (can_use_missile(item) && pickup_throwable_weapon(item, near));
2087 }
2088
2089 bool monster::pickup_missile(item_def &item, int near, bool force)
2090 {
2091     const item_def *miss = missiles();
2092
2093     if (!force)
2094     {
2095         if (item.sub_type == MI_THROWING_NET)
2096         {
2097             // Monster may not pick up trapping net.
2098             if (caught() && item_is_stationary(item))
2099                 return false;
2100         }
2101         else // None of these exceptions hold for throwing nets.
2102         {
2103             // Spellcasters should not waste time with ammunition.
2104             // Neither summons nor hostile enchantments are counted for
2105             // this purpose.
2106             if (!force && mons_has_ranged_spell(this, true, false))
2107                 return false;
2108
2109             // Monsters in a fight will only pick up missiles if doing so
2110             // is worthwhile.
2111             if (!mons_is_wandering(this)
2112                 && (!friendly() || foe != MHITYOU)
2113                 && (item.quantity < 5 || miss && miss->quantity >= 7))
2114             {
2115                 return false;
2116             }
2117         }
2118     }
2119
2120     if (miss && items_stack(*miss, item))
2121         return pickup(item, MSLOT_MISSILE, near);
2122
2123     if (!force && !can_use_missile(item))
2124         return false;
2125
2126     if (miss)
2127     {
2128         item_def *launch;
2129         for (int i = MSLOT_WEAPON; i <= MSLOT_ALT_WEAPON; ++i)
2130         {
2131             launch = mslot_item(static_cast<mon_inv_type>(i));
2132             if (launch)
2133             {
2134                 const int item_brand = get_ammo_brand(item);
2135                 // If this ammunition is better, drop the old ones.
2136                 // Don't upgrade to ammunition whose brand cancels the
2137                 // launcher brand or doesn't improve it further.
2138                 // Don't drop huge stacks for tiny stacks.
2139                 if (fires_ammo_type(*launch) == item.sub_type
2140                     && (fires_ammo_type(*launch) != miss->sub_type
2141                         || get_ammo_brand(*miss) == SPMSL_NORMAL
2142                            && item_brand != SPMSL_NORMAL
2143                            && _nonredundant_launcher_ammo_brands(launch, miss))
2144                     && item.quantity * 2 > miss->quantity)
2145                 {
2146                     if (!drop_item(MSLOT_MISSILE, near))
2147                         return false;
2148                     break;
2149                 }
2150             }
2151         }
2152
2153         // Darts don't absolutely need a launcher - still allow upgrading.
2154         if (item.sub_type == miss->sub_type
2155             && item.sub_type == MI_DART
2156             && (item.plus > miss->plus
2157                 || item.plus == miss->plus
2158                    && get_ammo_brand(*miss) == SPMSL_NORMAL
2159                    && get_ammo_brand(item) != SPMSL_NORMAL))
2160         {
2161             if (!drop_item(MSLOT_MISSILE, near))
2162                 return false;
2163         }
2164     }
2165
2166     return pickup(item, MSLOT_MISSILE, near);
2167 }
2168
2169 bool monster::pickup_wand(item_def &item, int near)
2170 {
2171     // Don't pick up empty wands.
2172     if (item.plus == 0)
2173         return false;
2174
2175     // Only low-HD monsters bother with wands.
2176     if (hit_dice >= 14)
2177         return false;
2178
2179     // Holy monsters and worshippers of good gods won't pick up evil
2180     // wands.
2181     if ((is_holy() || is_good_god(god)) && is_evil_item(item))
2182         return false;
2183
2184     // If a monster already has a charged wand, don't bother.
2185     // Otherwise, replace with a charged one.
2186     if (item_def *wand = mslot_item(MSLOT_WAND))
2187     {
2188         if (wand->plus > 0)
2189             return false;
2190
2191         if (!drop_item(MSLOT_WAND, near))
2192             return false;
2193     }
2194
2195     if (pickup(item, MSLOT_WAND, near))
2196     {
2197         if (near)
2198             props["wand_known"] = item_type_known(item);
2199         return true;
2200     }
2201     else
2202         return false;
2203 }
2204
2205 bool monster::pickup_scroll(item_def &item, int near)
2206 {
2207     if (item.sub_type != SCR_TELEPORTATION
2208         && item.sub_type != SCR_BLINKING
2209         && item.sub_type != SCR_SUMMONING)
2210     {
2211         return false;
2212     }
2213
2214     // Holy monsters and worshippers of good gods won't pick up evil or
2215     // unholy scrolls.
2216     if ((is_holy() || is_good_god(god))
2217         && (is_evil_item(item) || is_unholy_item(item)))
2218     {
2219         return false;
2220     }
2221
2222     return pickup(item, MSLOT_SCROLL, near);
2223 }
2224
2225 bool monster::pickup_potion(item_def &item, int near)
2226 {
2227     // Only allow monsters to pick up potions if they can actually use
2228     // them.
2229     const potion_type ptype = static_cast<potion_type>(item.sub_type);
2230
2231     if (!can_drink_potion(ptype))
2232         return false;
2233
2234     return pickup(item, MSLOT_POTION, near);
2235 }
2236
2237 bool monster::pickup_gold(item_def &item, int near)
2238 {
2239     return pickup(item, MSLOT_GOLD, near);
2240 }
2241
2242 bool monster::pickup_food(item_def &item, int near)
2243 {
2244     // Chunks are used only for Simulacrum.
2245     if (item.base_type == OBJ_FOOD
2246         && item.sub_type == FOOD_CHUNK
2247         && has_spell(SPELL_SIMULACRUM)
2248         && mons_class_can_be_zombified(item.mon_type))
2249     {
2250         // If a Beoghite monster ever gets Simulacrum, please
2251         // add monster type restrictions here.
2252         return pickup(item, MSLOT_MISCELLANY, near);
2253     }
2254
2255     return false;
2256 }
2257
2258 bool monster::pickup_misc(item_def &item, int near)
2259 {
2260     // Never pick up the horn of Geryon or runes, except for mimics.
2261     if (item.base_type == OBJ_MISCELLANY
2262         && ((item.sub_type == MISC_HORN_OF_GERYON && type != MONS_GERYON)
2263             || item.sub_type == MISC_RUNE_OF_ZOT)
2264         && !mons_is_item_mimic(type))
2265     {
2266         return false;
2267     }
2268
2269     // Holy monsters and worshippers of good gods won't pick up evil
2270     // miscellaneous items.
2271     if ((is_holy() || is_good_god(god)) && is_evil_item(item))
2272         return false;
2273
2274     return pickup(item, MSLOT_MISCELLANY, near);
2275 }
2276
2277 // Eaten items are handled elsewhere, in _handle_pickup() in mon-stuff.cc.
2278 bool monster::pickup_item(item_def &item, int near, bool force)
2279 {
2280     // Equipping stuff can be forced when initially equipping monsters.
2281     if (!force)
2282     {
2283         // If a monster isn't otherwise occupied (has a foe, is fleeing, etc.)
2284         // it is considered wandering.
2285         bool wandering = (mons_is_wandering(this)
2286                           || friendly() && foe == MHITYOU);
2287         const int itype = item.base_type;
2288
2289         // Weak(ened) monsters won't stop to pick up things as long as they
2290         // feel unsafe.
2291         if (!wandering && (hit_points * 10 < max_hit_points || hit_points < 10)
2292             && mon_enemies_around(this))
2293         {
2294             return false;
2295         }
2296
2297         if (friendly())
2298         {
2299             // Allies are only interested in armour and weaponry.
2300             // Everything else is likely to only annoy the player
2301             // because the monster either won't use the object or
2302             // might use it in ways not helpful to the player.
2303             //
2304             // Not adding jewellery to the list because of potential
2305             // balance implications for perm-allies. Perhaps this should
2306             // be reconsidered -NFM
2307             if (itype != OBJ_ARMOUR && itype != OBJ_WEAPONS
2308                 && itype != OBJ_MISSILES)
2309             {
2310                 return false;
2311             }
2312
2313             // Depending on the friendly pickup toggle, your allies may not
2314             // pick up anything, or only stuff dropped by (other) allies.
2315             if (you.friendly_pickup == FRIENDLY_PICKUP_NONE
2316                 || you.friendly_pickup == FRIENDLY_PICKUP_FRIEND
2317                    && !testbits(item.flags, ISFLAG_DROPPED_BY_ALLY)
2318                 || you.friendly_pickup == FRIENDLY_PICKUP_PLAYER
2319                    && !(item.flags & (ISFLAG_DROPPED | ISFLAG_THROWN
2320                                         | ISFLAG_DROPPED_BY_ALLY)))
2321             {
2322                 return false;
2323             }
2324         }
2325
2326         if (!wandering)
2327         {
2328             // These are not important enough for pickup when
2329             // seeking, fleeing etc.
2330             if (itype == OBJ_ARMOUR || itype == OBJ_CORPSES
2331                 || itype == OBJ_JEWELLERY
2332                 || itype == OBJ_MISCELLANY || itype == OBJ_GOLD)
2333             {
2334                 return false;
2335             }
2336
2337             if (itype == OBJ_WEAPONS || itype == OBJ_MISSILES)
2338             {
2339                 // Fleeing monsters only pick up emergency equipment.
2340                 if (mons_is_fleeing(this))
2341                     return false;
2342
2343                 // While occupied, hostile monsters won't pick up items
2344                 // dropped or thrown by you. (You might have done that to
2345                 // distract them.)
2346                 if (!friendly()
2347                     && (testbits(item.flags, ISFLAG_DROPPED)
2348                         || testbits(item.flags, ISFLAG_THROWN)))
2349                 {
2350                     return false;
2351                 }
2352             }
2353         }
2354     }
2355
2356     switch (item.base_type)
2357     {
2358     // Pickup some stuff only if WANDERING.
2359     case OBJ_ARMOUR:
2360         return pickup_armour(item, near, force);
2361     case OBJ_MISCELLANY:
2362         return pickup_misc(item, near);
2363     case OBJ_FOOD:
2364         return pickup_food(item, near);
2365     case OBJ_GOLD:
2366         return pickup_gold(item, near);
2367     case OBJ_JEWELLERY:
2368         return pickup_jewellery(item, near, force);
2369     // Fleeing monsters won't pick up these.
2370     // Hostiles won't pick them up if they were ever dropped/thrown by you.
2371     case OBJ_STAVES:
2372     case OBJ_WEAPONS:
2373     case OBJ_RODS:
2374         return pickup_weapon(item, near, force);
2375     case OBJ_MISSILES:
2376         return pickup_missile(item, near, force);
2377     // Other types can always be picked up
2378     // (barring other checks depending on subtype, of course).
2379     case OBJ_WANDS:
2380         return pickup_wand(item, near);
2381     case OBJ_SCROLLS:
2382         return pickup_scroll(item, near);
2383     case OBJ_POTIONS:
2384         return pickup_potion(item, near);
2385     case OBJ_BOOKS:
2386         if (force)
2387             return pickup_misc(item, near);
2388         // else fall through
2389     default:
2390         return false;
2391     }
2392 }
2393
2394 bool monster::need_message(int &near) const
2395 {
2396     return (near != -1 ? near
2397                        : (near = observable()));
2398 }
2399
2400 void monster::swap_weapons(int near)
2401 {
2402     item_def *weap = mslot_item(MSLOT_WEAPON);
2403     item_def *alt  = mslot_item(MSLOT_ALT_WEAPON);
2404
2405     if (weap && !unequip(*weap, MSLOT_WEAPON, near))
2406     {
2407         // Item was cursed.
2408         // A centaur may randomly decide to not shoot you, but bashing
2409         // people with a ranged weapon is a dead giveaway.
2410         if (weap->cursed() && you.can_see(this) && is_range_weapon(*weap))
2411             set_ident_flags(*weap, ISFLAG_KNOW_CURSE);
2412         return;
2413     }
2414
2415     swap_slots(MSLOT_WEAPON, MSLOT_ALT_WEAPON);
2416
2417     if (alt)
2418         equip(*alt, MSLOT_WEAPON, near);
2419
2420     // Monsters can swap weapons really fast. :-)
2421     if ((weap || alt) && speed_increment >= 2)
2422     {
2423         if (const monsterentry *entry = find_monsterentry())
2424             speed_increment -= div_rand_round(entry->energy_usage.attack, 5);
2425     }
2426 }
2427
2428 void monster::wield_melee_weapon(int near)
2429 {
2430     const item_def *weap = mslot_item(MSLOT_WEAPON);
2431     if (!weap || (!weap->cursed() && is_range_weapon(*weap)))
2432     {
2433         const item_def *alt = mslot_item(MSLOT_ALT_WEAPON);
2434
2435         // Switch to the alternate weapon if it's not a ranged weapon, too,
2436         // or switch away from our main weapon if it's a ranged weapon.
2437         //
2438         // Don't switch to alt weapon if it's a stack of throwing weapons.
2439         if (alt && !is_range_weapon(*alt) && alt->quantity == 1
2440             || weap && !alt && type != MONS_STATUE)
2441         {
2442             swap_weapons(near);
2443         }
2444     }
2445 }
2446
2447 item_def *monster::slot_item(equipment_type eq, bool include_melded) const
2448 {
2449     return mslot_item(equip_slot_to_mslot(eq));
2450 }
2451
2452 item_def *monster::mslot_item(mon_inv_type mslot) const
2453 {
2454     const int mi = (mslot == NUM_MONSTER_SLOTS) ? NON_ITEM : inv[mslot];
2455     return (mi == NON_ITEM ? NULL : &mitm[mi]);
2456 }
2457
2458 item_def *monster::shield()
2459 {
2460     return mslot_item(MSLOT_SHIELD);
2461 }
2462
2463 bool monster::is_named() const
2464 {
2465     return (!mname.empty() || mons_is_unique(type));
2466 }
2467
2468 bool monster::has_base_name() const
2469 {
2470     // Any non-ghost, non-Pandemonium demon that has an explicitly set
2471     // name has a base name.
2472     return (!mname.empty() && !ghost.get());
2473 }
2474
2475 static string _invalid_monster_str(monster_type type)
2476 {
2477     string str = "INVALID MONSTER ";
2478
2479     switch (type)
2480     {
2481     case NUM_MONSTERS:
2482         return (str + "NUM_MONSTERS");
2483     case MONS_NO_MONSTER:
2484         return (str + "MONS_NO_MONSTER");
2485     case MONS_PLAYER:
2486         return (str + "MONS_PLAYER");
2487     case RANDOM_DRACONIAN:
2488         return (str + "RANDOM_DRACONIAN");
2489     case RANDOM_BASE_DRACONIAN:
2490         return (str + "RANDOM_BASE_DRACONIAN");
2491     case RANDOM_NONBASE_DRACONIAN:
2492         return (str + "RANDOM_NONBASE_DRACONIAN");
2493     case WANDERING_MONSTER:
2494         return (str + "WANDERING_MONSTER");
2495     default:
2496         break;
2497     }
2498
2499     str += make_stringf("#%d", (int) type);
2500
2501     if (type < 0)
2502         return str;
2503
2504     if (type > NUM_MONSTERS)
2505     {
2506         str += make_stringf(" (NUM_MONSTERS + %d)",
2507                             int (NUM_MONSTERS - type));
2508         return str;
2509     }
2510
2511     int          i;
2512     monster_type new_type;
2513     for (i = 0; true; i++)
2514     {
2515         new_type = (monster_type) (((int) type) - i);
2516
2517         if (invalid_monster_type(new_type))
2518             continue;
2519         break;
2520     }
2521     str += make_stringf(" (%s + %d)",
2522                         mons_type_name(new_type, DESC_PLAIN).c_str(),
2523                         i);
2524
2525     return str;
2526 }
2527
2528 static string _mon_special_name(const monster& mon, description_level_type desc,
2529                                 bool force_seen)
2530 {
2531     if (desc == DESC_NONE)
2532         return "";
2533
2534     monster_type type = mon.type;
2535     if (!crawl_state.game_is_arena() && you.misled())
2536         type = mon.get_mislead_type();
2537
2538     const bool arena_submerged = crawl_state.game_is_arena() && !force_seen
2539                                      && mon.submerged();
2540
2541     if (type == MONS_NO_MONSTER)
2542         return "DEAD MONSTER";
2543     else if (invalid_monster_type(type) && type != MONS_PROGRAM_BUG)
2544         return _invalid_monster_str(type);
2545
2546     // Handle non-visible case first.
2547     if (!force_seen && !mon.observable() && !arena_submerged)
2548     {
2549         switch (desc)
2550         {
2551         case DESC_THE: case DESC_A: case DESC_PLAIN:
2552             return "it";
2553         case DESC_ITS:
2554             return "its";
2555         default:
2556             return "it (buggy)";
2557         }
2558     }
2559
2560     if (desc == DESC_DBNAME)
2561     {
2562         monster_info mi(&mon, MILEV_NAME);
2563         return mi.db_name();
2564     }
2565
2566     return "";
2567 }
2568
2569 string monster::name(description_level_type desc, bool force_vis) const
2570 {
2571     string s = _mon_special_name(*this, desc, force_vis);
2572     if (!s.empty() || desc == DESC_NONE)
2573         return s;
2574
2575     monster_info mi(this, MILEV_NAME);
2576     return mi.proper_name(desc);
2577 }
2578
2579 string monster::base_name(description_level_type desc, bool force_vis) const
2580 {
2581     string s = _mon_special_name(*this, desc, force_vis);
2582     if (!s.empty() || desc == DESC_NONE)
2583         return s;
2584
2585     monster_info mi(this, MILEV_NAME);
2586     return mi.common_name(desc);
2587 }
2588
2589 string monster::full_name(description_level_type desc, bool use_comma) const
2590 {
2591     string s = _mon_special_name(*this, desc, true);
2592     if (!s.empty() || desc == DESC_NONE)
2593         return s;
2594
2595     monster_info mi(this, MILEV_NAME);
2596     return mi.full_name(desc);
2597 }
2598
2599 string monster::pronoun(pronoun_type pro, bool force_visible) const
2600 {
2601     return mons_pronoun(type, pro, force_visible || you.can_see(this));
2602 }
2603
2604 string monster::conj_verb(const string &verb) const
2605 {
2606     if (!verb.empty() && verb[0] == '!')
2607         return verb.substr(1);
2608
2609     if (verb == "are")
2610         return "is";
2611
2612     if (verb == "snap closed at")
2613         return "snaps closed at";
2614
2615     if (verb == "pounce on")
2616         return "pounces on";
2617
2618     if (ends_with(verb, "f") || ends_with(verb, "fe")
2619         || ends_with(verb, "y"))
2620     {
2621         return (verb + "s");
2622     }
2623
2624     return pluralise(verb);
2625 }
2626
2627 string monster::hand_name(bool plural, bool *can_plural) const
2628 {
2629     bool _can_plural;
2630     if (can_plural == NULL)
2631         can_plural = &_can_plural;
2632     *can_plural = true;
2633
2634     string str;
2635     char        ch = mons_base_char(type);
2636
2637     const bool rand = (type == MONS_CHAOS_SPAWN);
2638
2639     switch (get_mon_shape(this))
2640     {
2641     case MON_SHAPE_CENTAUR:
2642     case MON_SHAPE_NAGA:
2643         // Defaults to "hand"
2644         break;
2645     case MON_SHAPE_HUMANOID:
2646     case MON_SHAPE_HUMANOID_WINGED:
2647     case MON_SHAPE_HUMANOID_TAILED:
2648     case MON_SHAPE_HUMANOID_WINGED_TAILED:
2649         if (ch == 'T' || ch == 'd' || ch == 'n' || mons_is_demon(type))
2650             str = "claw";
2651         break;
2652
2653     case MON_SHAPE_QUADRUPED:
2654     case MON_SHAPE_QUADRUPED_TAILLESS:
2655     case MON_SHAPE_QUADRUPED_WINGED:
2656     case MON_SHAPE_ARACHNID:
2657         if (mons_genus(type) == MONS_SCORPION || rand && one_chance_in(4))
2658             str = "pincer";
2659         else
2660         {
2661             str = "front ";
2662             return (str + foot_name(plural, can_plural));
2663         }
2664         break;
2665
2666     case MON_SHAPE_BLOB:
2667     case MON_SHAPE_SNAKE:
2668     case MON_SHAPE_FISH:
2669         return foot_name(plural, can_plural);
2670
2671     case MON_SHAPE_BAT:
2672         str = "wing";
2673         break;
2674
2675     case MON_SHAPE_INSECT:
2676     case MON_SHAPE_INSECT_WINGED:
2677     case MON_SHAPE_CENTIPEDE:
2678         str = "antenna";
2679         break;
2680
2681     case MON_SHAPE_SNAIL:
2682         str = "eye-stalk";
2683         break;
2684
2685     case MON_SHAPE_PLANT:
2686         str = "leaf";
2687         break;
2688
2689     case MON_SHAPE_MISC:
2690         if (ch == 'x' || ch == 'X' || rand)
2691         {
2692             str = "tentacle";
2693             break;
2694         }
2695         // Deliberate fallthrough.
2696     case MON_SHAPE_FUNGUS:
2697         str         = "body";
2698         *can_plural = false;
2699         break;
2700
2701     case MON_SHAPE_ORB:
2702         switch (type)
2703         {
2704             case MONS_GIANT_SPORE:
2705                 str = "rhizome";
2706                 break;
2707
2708             case MONS_GIANT_EYEBALL:
2709             case MONS_EYE_OF_DRAINING:
2710             case MONS_SHINING_EYE:
2711             case MONS_EYE_OF_DEVASTATION:
2712             case MONS_GOLDEN_EYE:
2713                 *can_plural = false;
2714                 // Deliberate fallthrough.
2715             case MONS_GREAT_ORB_OF_EYES:
2716                 str = "pupil";
2717                 break;
2718
2719             case MONS_GIANT_ORANGE_BRAIN:
2720             default:
2721                 if (rand)
2722                     str = "rhizome";
2723                 else
2724                 {
2725                     str        = "body";
2726                     *can_plural = false;
2727                 }
2728                 break;
2729         }
2730     }
2731
2732     if (str.empty())
2733     {
2734         // Reduce the chance of a random-shaped monster having hands.
2735         if (rand && coinflip())
2736             return hand_name(plural, can_plural);
2737
2738         str = "hand";
2739     }
2740
2741     if (plural && *can_plural)
2742         str = pluralise(str);
2743
2744     return str;
2745 }
2746
2747 string monster::foot_name(bool plural, bool *can_plural) const
2748 {
2749     bool _can_plural;
2750     if (can_plural == NULL)
2751         can_plural = &_can_plural;
2752     *can_plural = true;
2753
2754     string str;
2755     char        ch = mons_base_char(type);
2756
2757     const bool rand = (type == MONS_CHAOS_SPAWN);
2758
2759     switch (get_mon_shape(this))
2760     {
2761     case MON_SHAPE_INSECT:
2762     case MON_SHAPE_INSECT_WINGED:
2763     case MON_SHAPE_ARACHNID:
2764     case MON_SHAPE_CENTIPEDE:
2765         str = "leg";
2766         break;
2767
2768     case MON_SHAPE_HUMANOID:
2769     case MON_SHAPE_HUMANOID_WINGED:
2770     case MON_SHAPE_HUMANOID_TAILED:
2771     case MON_SHAPE_HUMANOID_WINGED_TAILED:
2772         if (type == MONS_MINOTAUR)
2773             str = "hoof";
2774         else if (swimming()
2775                  && (type == MONS_MERFOLK || mons_genus(type) == MONS_MERMAID))
2776         {
2777             str         = "tail";
2778             *can_plural = false;
2779         }
2780         break;
2781
2782     case MON_SHAPE_CENTAUR:
2783         str = "hoof";
2784         break;
2785
2786     case MON_SHAPE_QUADRUPED:
2787     case MON_SHAPE_QUADRUPED_TAILLESS:
2788     case MON_SHAPE_QUADRUPED_WINGED:
2789         if (rand)
2790         {
2791             const char* feet[] = {"paw", "talon", "hoof"};
2792             str = RANDOM_ELEMENT(feet);
2793         }
2794         else if (ch == 'h')
2795             str = "paw";
2796         else if (ch == 'l' || ch == 'D')
2797             str = "talon";
2798         else if (type == MONS_YAK || type == MONS_DEATH_YAK)
2799             str = "hoof";
2800         else if (ch == 'H')
2801         {
2802             if (type == MONS_MANTICORE || type == MONS_SPHINX)
2803                 str = "paw";
2804             else
2805                 str = "talon";
2806         }
2807         break;
2808
2809     case MON_SHAPE_BAT:
2810         str = "claw";
2811         break;
2812
2813     case MON_SHAPE_SNAKE:
2814     case MON_SHAPE_FISH:
2815         str         = "tail";
2816         *can_plural = false;
2817         break;
2818
2819     case MON_SHAPE_PLANT:
2820         str = "root";
2821         break;
2822
2823     case MON_SHAPE_FUNGUS:
2824         str         = "stem";
2825         *can_plural = false;
2826         break;
2827
2828     case MON_SHAPE_BLOB:
2829         str = "pseudopod";
2830         break;
2831
2832     case MON_SHAPE_MISC:
2833         if (ch == 'x' || ch == 'X' || rand)
2834         {
2835             str = "tentacle";
2836             break;
2837         }
2838         // Deliberate fallthrough.
2839     case MON_SHAPE_SNAIL:
2840     case MON_SHAPE_NAGA:
2841     case MON_SHAPE_ORB:
2842         str         = "underside";
2843         *can_plural = false;
2844         break;
2845     }
2846
2847     if (str.empty())
2848     {
2849         // Reduce the chance of a random-shaped monster having feet.
2850         if (rand && coinflip())
2851             return foot_name(plural, can_plural);
2852
2853         return (plural ? "feet" : "foot");
2854     }
2855
2856     if (plural && *can_plural)
2857         str = pluralise(str);
2858
2859     return str;
2860 }
2861
2862 string monster::arm_name(bool plural, bool *can_plural) const
2863 {
2864     mon_body_shape shape = get_mon_shape(this);
2865
2866     if (shape > MON_SHAPE_NAGA)
2867         return hand_name(plural, can_plural);
2868
2869     if (can_plural != NULL)
2870         *can_plural = true;
2871
2872     string adj;
2873     string str = "arm";
2874
2875     switch (mons_genus(type))
2876     {
2877     case MONS_DRACONIAN:
2878     case MONS_NAGA:
2879         adj = "scaled";
2880         break;
2881
2882     case MONS_TENGU:
2883         adj = "feathered";
2884         break;
2885
2886     case MONS_MUMMY:
2887         adj = "bandage-wrapped";
2888         break;
2889
2890     case MONS_OCTOPODE:
2891         str = "tentacle";
2892         break;
2893
2894     case MONS_LICH:
2895     case MONS_SKELETAL_WARRIOR:
2896     case MONS_ANCIENT_CHAMPION:
2897     case MONS_REVENANT:
2898         adj = "bony";
2899         break;
2900
2901     default:
2902         break;
2903     }
2904
2905     if (!adj.empty())
2906         str = adj + " " + str;
2907
2908     if (plural)
2909         str = pluralise(str);
2910
2911     return str;
2912 }
2913
2914 int monster::mindex() const
2915 {
2916     return (this - menv.buffer());
2917 }
2918
2919 int monster::get_experience_level() const
2920 {
2921     return hit_dice;
2922 }
2923
2924 void monster::moveto(const coord_def& c, bool clear_net)
2925 {
2926     if (clear_net && c != pos() && in_bounds(pos()))
2927         mons_clear_trapping_net(this);
2928
2929     if (is_projectile())
2930     {
2931         // Assume some means of displacement, normal moves will overwrite this.
2932         props["iood_x"].get_float() += c.x - pos().x;
2933         props["iood_y"].get_float() += c.y - pos().y;
2934     }
2935
2936     set_position(c);
2937
2938     clear_far_constrictions();
2939 }
2940
2941 bool monster::fumbles_attack(bool verbose)
2942 {
2943     if (floundering() && one_chance_in(4))
2944     {
2945         if (verbose)
2946         {
2947             if (you.can_see(this))
2948             {
2949                 mpr(name(DESC_THE)
2950                     + (liquefied(pos())
2951                        ? " becomes momentarily stuck in the liquid earth."
2952                        : " splashes around in the water."));
2953             }
2954             else if (player_can_hear(pos(), LOS_RADIUS))
2955                 mpr("You hear a splashing noise.", MSGCH_SOUND);
2956         }
2957
2958         return true;
2959     }
2960
2961     if (submerged())
2962         return true;
2963
2964     return false;
2965 }
2966
2967 bool monster::cannot_fight() const
2968 {
2969     return (mons_class_flag(type, M_NO_EXP_GAIN)
2970             || mons_is_statue(type));
2971 }
2972
2973 void monster::attacking(actor * /* other */)
2974 {
2975 }
2976
2977 // Sends a monster into a frenzy.
2978 void monster::go_frenzy()
2979 {
2980     if (!can_go_berserk())
2981         return;
2982
2983     if (has_ench(ENCH_SLOW))
2984     {
2985         del_ench(ENCH_SLOW, true); // Give no additional message.
2986         simple_monster_message(this,
2987             make_stringf(" shakes off %s lethargy.",
2988                          pronoun(PRONOUN_POSSESSIVE).c_str()).c_str());
2989     }
2990     del_ench(ENCH_HASTE, true);
2991     del_ench(ENCH_FATIGUE, true); // Give no additional message.
2992
2993     const int duration = 16 + random2avg(13, 2);
2994
2995     // store the attitude for later retrieval
2996     props["old_attitude"] = short(attitude);
2997
2998     attitude = ATT_NEUTRAL;
2999     add_ench(mon_enchant(ENCH_INSANE, 0, 0, duration * 10));
3000     add_ench(mon_enchant(ENCH_HASTE, 0, 0, duration * 10));
3001     add_ench(mon_enchant(ENCH_MIGHT, 0, 0, duration * 10));
3002     mons_att_changed(this);
3003
3004     if (simple_monster_message(this, " flies into a frenzy!"))
3005         // Xom likes monsters going insane.
3006         xom_is_stimulated(friendly() ? 25 : 100);
3007 }
3008
3009 void monster::go_berserk(bool /* intentional */, bool /* potion */)
3010 {
3011     if (!can_go_berserk())
3012         return;
3013
3014     if (check_stasis(false))
3015         return;
3016
3017     if (has_ench(ENCH_SLOW))
3018     {
3019         del_ench(ENCH_SLOW, true); // Give no additional message.
3020         simple_monster_message(this,
3021             make_stringf(" shakes off %s lethargy.",
3022                          pronoun(PRONOUN_POSSESSIVE).c_str()).c_str());
3023     }
3024     del_ench(ENCH_FATIGUE, true); // Give no additional message.
3025
3026     add_ench(ENCH_BERSERK);
3027     if (simple_monster_message(this, " goes berserk!"))
3028         // Xom likes monsters going berserk.
3029         xom_is_stimulated(friendly() ? 25 : 100);
3030 }
3031
3032 void monster::expose_to_element(beam_type flavour, int strength,
3033                                 bool damage_inventory, bool slow_cold_blood)
3034 {
3035     switch (flavour)
3036     {
3037     case BEAM_COLD:
3038         if (slow_cold_blood && mons_class_flag(type, M_COLD_BLOOD)
3039             && res_cold() <= 0 && coinflip())
3040         {
3041             slow_down(this, strength);
3042         }
3043         break;
3044     default:
3045         break;
3046     }
3047 }
3048
3049 void monster::banish(actor *agent, const string &)
3050 {
3051     coord_def old_pos = pos();
3052
3053     if (mons_is_projectile(type))
3054         return;
3055     simple_monster_message(this, " is devoured by a tear in reality.",
3056                            MSGCH_BANISHMENT);
3057     if (agent && !has_ench(ENCH_ABJ) && !(flags & MF_NO_REWARD)
3058         && !has_ench(ENCH_FAKE_ABJURATION)
3059         && !mons_class_flag(type, M_NO_EXP_GAIN))
3060     {
3061         // Double the existing damage blame counts, so the unassigned xp for
3062         // remaining hp is effectively halved.  No need to pass flags this way.
3063         damage_total *= 2;
3064         damage_friendly *= 2;
3065         blame_damage(agent, hit_points);
3066         // Note: we do not set MF_GOT_HALF_XP, the monster is usually not
3067         // distinguishable from others of the same kind in the Abyss.
3068
3069         if (agent->is_player())
3070             did_god_conduct(DID_BANISH, hit_dice, true /*possibly wrong*/, this);
3071     }
3072     monster_die(this, KILL_BANISHED, NON_MONSTER);
3073
3074     place_cloud(CLOUD_TLOC_ENERGY, old_pos, 5 + random2(8), 0);
3075     for (adjacent_iterator ai(old_pos); ai; ++ai)
3076         if (!feat_is_solid(grd(*ai)) && env.cgrid(*ai) == EMPTY_CLOUD
3077             && coinflip())
3078         {
3079             place_cloud(CLOUD_TLOC_ENERGY, *ai, 1 + random2(8), 0);
3080         }
3081 }
3082
3083 bool monster::has_spells() const
3084 {
3085     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3086         if (spells[i] != SPELL_NO_SPELL)
3087             return true;
3088
3089     return false;
3090 }
3091
3092 bool monster::has_spell(spell_type spell) const
3093 {
3094     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3095         if (spells[i] == spell)
3096             return true;
3097
3098     return false;
3099 }
3100
3101 bool monster::has_unholy_spell() const
3102 {
3103     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3104         if (is_unholy_spell(spells[i]))
3105             return true;
3106
3107     return false;
3108 }
3109
3110 bool monster::has_evil_spell() const
3111 {
3112     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3113         if (is_evil_spell(spells[i]))
3114             return true;
3115
3116     return false;
3117 }
3118
3119 bool monster::has_unclean_spell() const
3120 {
3121     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3122         if (is_unclean_spell(spells[i]))
3123             return true;
3124
3125     return false;
3126 }
3127
3128 bool monster::has_chaotic_spell() const
3129 {
3130     for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3131         if (is_chaotic_spell(spells[i]))
3132             return true;
3133
3134     return false;
3135 }
3136
3137 bool monster::has_corpse_violating_spell() const
3138 {
3139      for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
3140         if (is_corpse_violating_spell(spells[i]))
3141             return true;
3142
3143     return false;
3144 }
3145
3146 bool monster::has_attack_flavour(int flavour) const
3147 {
3148     for (int i = 0; i < 4; ++i)
3149     {
3150         const int attk_flavour = mons_attack_spec(this, i).flavour;
3151         if (attk_flavour == flavour)
3152             return true;
3153     }
3154
3155     return false;
3156 }
3157
3158 bool monster::has_damage_type(int dam_type)
3159 {
3160     for (int i = 0; i < 4; ++i)
3161     {
3162         const int dmg_type = damage_type(i);
3163         if (dmg_type == dam_type)
3164             return true;
3165     }
3166
3167     return false;
3168 }
3169
3170 int monster::constriction_damage() const
3171 {
3172     for (int i = 0; i < 4; ++i)
3173     {
3174         const mon_attack_def attack = mons_attack_spec(this, i);
3175         if (attack.type == AT_CONSTRICT)
3176             return attack.damage;
3177     }
3178     return -1;
3179 }
3180
3181 // Whether the monster is temporarily confused.
3182 // False for butterflies, vapours etc.
3183 bool monster::confused() const
3184 {
3185     return mons_is_confused(this);
3186 }
3187
3188 bool monster::confused_by_you() const
3189 {
3190     if (mons_class_flag(type, M_CONFUSED))
3191         return false;
3192
3193     const mon_enchant me = get_ench(ENCH_CONFUSION);
3194     const mon_enchant me2 = get_ench(ENCH_MAD);
3195
3196     return ((me.ench == ENCH_CONFUSION && me.who == KC_YOU) ||
3197             (me2.ench == ENCH_MAD && me2.who == KC_YOU));
3198 }
3199
3200 bool monster::paralysed() const
3201 {
3202     return (has_ench(ENCH_PARALYSIS) || has_ench(ENCH_DUMB));
3203 }
3204
3205 bool monster::cannot_act() const
3206 {
3207     return (paralysed() || petrified()
3208             || has_ench(ENCH_PREPARING_RESURRECT));
3209 }
3210
3211 bool monster::cannot_move() const
3212 {
3213     return cannot_act();
3214 }
3215
3216 bool monster::asleep() const
3217 {
3218     return (behaviour == BEH_SLEEP);
3219 }
3220
3221 bool monster::backlit(bool check_haloed, bool self_halo, bool check_corona) const
3222 {
3223     if (check_corona && has_ench(ENCH_CORONA)
3224         || has_ench(ENCH_SILVER_CORONA)
3225         || has_ench(ENCH_STICKY_FLAME))
3226     {
3227         return true;
3228     }
3229     if (check_haloed)
3230         return (!umbraed() && haloed() &&
3231                 (self_halo || halo_radius2() == -1));
3232     return false;
3233 }
3234
3235 bool monster::umbra(bool check_haloed, bool self_halo) const
3236 {
3237     if (check_haloed)
3238         return (umbraed() && !haloed() &&
3239                 (self_halo || umbra_radius2() == -1));
3240     return false;
3241 }
3242
3243 bool monster::glows_naturally() const
3244 {
3245     return (mons_class_flag(type, M_GLOWS_LIGHT)
3246             || mons_class_flag(type, M_GLOWS_RADIATION));
3247 }
3248
3249 bool monster::caught() const
3250 {
3251     return has_ench(ENCH_HELD);
3252 }
3253
3254 bool monster::petrified() const
3255 {
3256     return has_ench(ENCH_PETRIFIED);
3257 }
3258
3259 bool monster::petrifying() const
3260 {
3261     return has_ench(ENCH_PETRIFYING);
3262 }
3263
3264 bool monster::liquefied_ground() const
3265 {
3266     return (liquefied(pos())
3267             && ground_level() && !is_insubstantial()
3268             && !mons_class_is_stationary(type));
3269 }
3270
3271 bool monster::friendly() const
3272 {
3273     return (attitude == ATT_FRIENDLY || has_ench(ENCH_CHARM));
3274 }
3275
3276 bool monster::neutral() const
3277 {
3278     return (attitude == ATT_NEUTRAL || attitude == ATT_GOOD_NEUTRAL
3279             || attitude == ATT_STRICT_NEUTRAL);
3280 }
3281
3282 bool monster::good_neutral() const
3283 {
3284     return attitude == ATT_GOOD_NEUTRAL;
3285 }
3286
3287 bool monster::strict_neutral() const
3288 {
3289     return (attitude == ATT_STRICT_NEUTRAL);
3290 }
3291
3292 bool monster::wont_attack() const
3293 {
3294     return (friendly() || good_neutral() || strict_neutral());
3295 }
3296
3297 bool monster::pacified() const
3298 {
3299     return (attitude == ATT_NEUTRAL && testbits(flags, MF_GOT_HALF_XP));
3300 }
3301
3302 int monster::shield_bonus() const
3303 {
3304     const item_def *shld = const_cast<monster* >(this)->shield();
3305     if (shld && get_armour_slot(*shld) == EQ_SHIELD)
3306     {
3307         // Note that 0 is not quite no-blocking.
3308         if (incapacitated())
3309             return 0;
3310
3311         int shld_c = property(*shld, PARM_AC) + shld->plus;
3312         shld_c = shld_c * 2 + (body_size(PSIZE_TORSO) - SIZE_MEDIUM)
3313                             * (shld->sub_type - ARM_LARGE_SHIELD);
3314         return (random2avg(shld_c + hit_dice * 4 / 3, 2) / 2);
3315     }
3316     return -100;
3317 }
3318
3319 int monster::shield_block_penalty() const
3320 {
3321     return (4 * shield_blocks * shield_blocks);
3322 }
3323
3324 void monster::shield_block_succeeded(actor *attacker)
3325 {
3326     actor::shield_block_succeeded(attacker);
3327
3328     ++shield_blocks;
3329 }
3330
3331 int monster::shield_bypass_ability(int) const
3332 {
3333     return (15 + hit_dice * 2 / 3);
3334 }
3335
3336 int monster::missile_deflection() const
3337 {
3338     if (mons_class_flag(type, M_DEFLECT_MISSILES))
3339         return 2;
3340     else if (scan_artefacts(ARTP_RMSL))
3341         return 1;
3342     else
3343         return 0;
3344 }
3345
3346 int monster::armour_class() const
3347 {
3348     int a = ac;
3349
3350     // Extra AC for snails/turtles drawn into their shells.
3351     if (has_ench(ENCH_WITHDRAWN))
3352         a += 10;
3353
3354     // Penalty due to bad temp mutations.
3355     if (has_ench(ENCH_WRETCHED))
3356         a -= get_ench(ENCH_WRETCHED).degree;
3357
3358     return max(a, 0);
3359 }
3360
3361 int monster::melee_evasion(const actor *act, ev_ignore_type evit) const
3362 {
3363     int evasion = ev;
3364
3365     // Phase Shift EV is already included (but ignore if dimension anchored)
3366     if (mons_class_flag(type, M_PHASE_SHIFT)
3367         && ((evit & EV_IGNORE_PHASESHIFT) || has_ench(ENCH_DIMENSION_ANCHOR)))
3368     {
3369         evasion -= 8;
3370     }
3371
3372     if (evit & EV_IGNORE_HELPLESS)
3373         return max(evasion, 0);
3374
3375     if (paralysed() || petrified() || petrifying() || asleep())
3376         evasion = 0;
3377     else if (caught() || is_constricted())
3378         evasion /= (body_size(PSIZE_BODY) + 2);
3379     else if (confused())
3380         evasion /= 2;
3381     return max(evasion, 0);
3382 }
3383
3384 bool monster::heal(int amount, bool max_too)
3385 {
3386     if (mons_is_statue(type))
3387         return false;
3388
3389     if (has_ench(ENCH_DEATHS_DOOR))
3390         return false;
3391
3392     if (amount < 1)
3393         return false;
3394     else if (!max_too && hit_points == max_hit_points)
3395         return false;
3396
3397     hit_points += amount;
3398
3399     bool success = true;
3400
3401     if (hit_points > max_hit_points)
3402     {
3403         if (max_too)
3404         {
3405             const monsterentry* m = get_monster_data(type);
3406             const int maxhp =
3407                 m->hpdice[0] * (m->hpdice[1] + m->hpdice[2]) + m->hpdice[3];
3408
3409             // Limit HP growth.
3410             if (random2(3 * maxhp) > 2 * max_hit_points)
3411                 max_hit_points = min(max_hit_points + 1, MAX_MONSTER_HP);
3412             else
3413                 success = false;
3414         }
3415
3416         hit_points = max_hit_points;
3417     }
3418
3419     if (hit_points == max_hit_points)
3420     {
3421         // Clear the damage blame if it goes away completely.
3422         damage_friendly = 0;
3423         damage_total = 0;
3424         props.erase("reaping_damage");
3425     }
3426
3427     return success;
3428 }
3429
3430 void monster::blame_damage(const actor* attacker, int amount)
3431 {
3432     ASSERT(amount >= 0);
3433     damage_total = min<int>(MAX_DAMAGE_COUNTER, damage_total + amount);
3434     if (attacker)
3435         damage_friendly = min<int>(MAX_DAMAGE_COUNTER * 2,
3436                       damage_friendly + amount * exp_rate(attacker->mindex()));
3437 }
3438
3439 void monster::suicide(int hp)
3440 {
3441     if (hit_points > 0)
3442         blame_damage(NULL, hit_points);
3443     hit_points = hp;
3444 }
3445
3446 mon_holy_type monster::holiness() const
3447 {
3448     // zombie kraken tentacles
3449     if (testbits(flags, MF_FAKE_UNDEAD))
3450         return MH_UNDEAD;
3451
3452     return mons_class_holiness(type);
3453 }
3454
3455 bool monster::undead_or_demonic() const
3456 {
3457     const mon_holy_type holi = holiness();
3458
3459     return (holi == MH_UNDEAD || holi == MH_DEMONIC || type == MONS_DEMONSPAWN);
3460 }
3461
3462 bool monster::is_holy(bool check_spells) const
3463 {
3464     if (holiness() == MH_HOLY)
3465         return true;
3466
3467     // Assume that all unknown gods are not holy.
3468     if (is_priest() && is_good_god(god) && check_spells)
3469         return true;
3470
3471     return false;
3472 }
3473
3474 bool monster::is_unholy(bool check_spells) const
3475 {
3476     if (type == MONS_SILVER_STATUE || type == MONS_DEMONSPAWN)
3477         return true;
3478
3479     if (holiness() == MH_DEMONIC)
3480         return true;
3481
3482     if (has_unholy_spell() && check_spells)
3483         return true;
3484
3485     return false;
3486 }
3487
3488 bool monster::is_evil(bool check_spells) const
3489 {
3490     if (holiness() == MH_UNDEAD)
3491         return true;
3492
3493     // Assume that all unknown gods are evil.
3494     if (is_priest() && (is_evil_god(god) || is_unknown_god(god))
3495         && check_spells)
3496     {
3497         return true;
3498     }
3499
3500     if (has_evil_spell() && check_spells)
3501         return true;
3502
3503     if (has_attack_flavour(AF_DRAIN_XP)
3504         || has_attack_flavour(AF_VAMPIRIC))
3505     {
3506         return true;
3507     }
3508
3509     return false;
3510 }
3511
3512 bool monster::is_unclean(bool check_spells) const
3513 {
3514     if (has_unclean_spell() && check_spells)
3515         return true;
3516
3517     if (has_attack_flavour(AF_DISEASE)
3518         || has_attack_flavour(AF_HUNGER)
3519         || has_attack_flavour(AF_ROT)
3520         || has_attack_flavour(AF_STEAL)
3521         || has_attack_flavour(AF_STEAL_FOOD))
3522     {
3523         return true;
3524     }
3525
3526     // Zin considers insanity unclean.  And slugs that speak.
3527     if (type == MONS_CRAZY_YIUF
3528         || type == MONS_PSYCHE
3529         || type == MONS_GASTRONOK)
3530     {
3531         return true;
3532     }
3533
3534     // A floating mass of disease is nearly the definition of unclean.
3535     if (type == MONS_ANCIENT_ZYME)
3536         return true;
3537
3538     // Assume that all unknown gods are not chaotic.
3539     //
3540     // Being a worshipper of a chaotic god doesn't yet make you
3541     // physically/essentially chaotic (so you don't get hurt by silver),
3542     // but Zin does mind.
3543     if (is_priest() && is_chaotic_god(god) && check_spells)
3544         return true;
3545
3546     if (has_chaotic_spell() && is_actual_spellcaster() && check_spells)
3547         return true;
3548
3549     corpse_effect_type ce = mons_corpse_effect(type);
3550     if ((ce == CE_ROT || ce == CE_MUTAGEN) && !is_chaotic())
3551         return true;
3552
3553     return false;
3554 }
3555
3556 bool monster::is_known_chaotic() const
3557 {
3558     if (type == MONS_UGLY_THING
3559         || type == MONS_VERY_UGLY_THING
3560         || type == MONS_ABOMINATION_SMALL
3561         || type == MONS_ABOMINATION_LARGE
3562         || type == MONS_WRETCHED_STAR
3563         || type == MONS_KILLER_KLOWN // For their random attacks.
3564         || type == MONS_TIAMAT)      // For her colour-changing.
3565     {
3566         return true;
3567     }
3568
3569     if (is_shapeshifter() && (flags & MF_KNOWN_SHIFTER))
3570         return true;
3571
3572     // Knowing chaotic spells is not enough to make you "essentially"
3573     // chaotic (i.e., silver doesn't hurt you), it's just unclean for
3574     // Zin.  Having chaotic abilities (not actual spells) does mean
3575     // you're truly changed by chaos.
3576     if (has_chaotic_spell() && !is_actual_spellcaster())
3577         return true;
3578
3579     if (has_attack_flavour(AF_MUTATE)
3580         || has_attack_flavour(AF_CHAOS))
3581     {
3582         return true;
3583     }
3584
3585     return false;
3586 }
3587
3588 bool monster::is_chaotic() const
3589 {
3590     return (is_shapeshifter() || is_known_chaotic());
3591 }
3592
3593 bool monster::is_artificial() const
3594 {
3595     return mons_class_flag(type, M_ARTIFICIAL);
3596 }
3597
3598 bool monster::is_unbreathing() const
3599 {
3600     const mon_holy_type holi = holiness();
3601
3602     if (holi == MH_UNDEAD
3603         || holi == MH_NONLIVING
3604         || holi == MH_PLANT)
3605     {
3606         return true;
3607     }
3608
3609     return mons_class_flag(type, M_UNBREATHING);
3610 }
3611
3612 bool monster::is_insubstantial() const
3613 {
3614     return mons_class_flag(type, M_INSUBSTANTIAL);
3615 }
3616
3617 int monster::res_hellfire() const
3618 {
3619     return get_mons_resist(this, MR_RES_FIRE) >= 4;
3620 }
3621
3622 int monster::res_fire() const
3623 {
3624     int u = get_mons_resist(this, MR_RES_FIRE);
3625
3626     if (mons_itemuse(this) >= MONUSE_STARTING_EQUIPMENT)
3627     {
3628         u += scan_artefacts(ARTP_FIRE);
3629
3630         const int armour    = inv[MSLOT_ARMOUR];
3631         const int shld      = inv[MSLOT_SHIELD];
3632         const int jewellery = inv[MSLOT_JEWELLERY];
3633
3634         if (armour != NON_ITEM && mitm[armour].base_type == OBJ_ARMOUR)
3635             u