Revert "Track who destroys an item; incur Nemelex penance for deck destruction."
[crawl.git] / crawl-ref / source / mon-stuff.cc
1 /**
2  * @file
3  * @brief Misc monster related functions.
4 **/
5
6 #include "AppHdr.h"
7 #include <math.h>
8 #include "mon-stuff.h"
9
10 #include "areas.h"
11 #include "arena.h"
12 #include "art-enum.h"
13 #include "artefact.h"
14 #include "attitude-change.h"
15 #include "cloud.h"
16 #include "cluautil.h"
17 #include "coordit.h"
18 #include "database.h"
19 #include "delay.h"
20 #include "dactions.h"
21 #include "describe.h"
22 #include "dgnevent.h"
23 #include "dgn-overview.h"
24 #include "dlua.h"
25 #include "dungeon.h"
26 #include "effects.h"
27 #include "env.h"
28 #include "exclude.h"
29 #include "fprop.h"
30 #include "files.h"
31 #include "food.h"
32 #include "godabil.h"
33 #include "godcompanions.h"
34 #include "godconduct.h"
35 #include "hints.h"
36 #include "hiscores.h"
37 #include "itemname.h"
38 #include "itemprop.h"
39 #include "items.h"
40 #include "kills.h"
41 #include "libutil.h"
42 #include "losglobal.h"
43 #include "makeitem.h"
44 #include "mapmark.h"
45 #include "message.h"
46 #include "mgen_data.h"
47 #include "misc.h"
48 #include "mon-abil.h"
49 #include "mon-behv.h"
50 #include "mon-death.h"
51 #include "mon-iter.h"
52 #include "mon-place.h"
53 #include "mon-speak.h"
54 #include "notes.h"
55 #include "ouch.h"
56 #include "player.h"
57 #include "random.h"
58 #include "religion.h"
59 #include "shout.h"
60 #include "spl-damage.h"
61 #include "spl-miscast.h"
62 #include "spl-summoning.h"
63 #include "spl-util.h"
64 #include "state.h"
65 #include "stuff.h"
66 #include "target.h"
67 #include "teleport.h"
68 #include "terrain.h"
69 #include "transform.h"
70 #include "traps.h"
71 #include "unwind.h"
72 #include "view.h"
73 #include "viewchar.h"
74 #include "xom.h"
75
76 static bool _wounded_damaged(mon_holy_type holi);
77 static int _calc_player_experience(const monster* mons);
78
79 dungeon_feature_type get_mimic_feat(const monster* mimic)
80 {
81     if (mimic->props.exists("feat_type"))
82         return static_cast<dungeon_feature_type>(mimic->props["feat_type"].get_short());
83     else
84         return DNGN_FLOOR;
85 }
86
87 bool feature_mimic_at(const coord_def &c)
88 {
89     return map_masked(c, MMT_MIMIC);
90 }
91
92 item_def* item_mimic_at(const coord_def &c)
93 {
94     for (stack_iterator si(c); si; ++si)
95         if (si->flags & ISFLAG_MIMIC)
96             return &*si;
97     return NULL;
98 }
99
100 bool mimic_at(const coord_def &c)
101 {
102     return (feature_mimic_at(c) || item_mimic_at(c));
103 }
104
105 // Monster curses a random player inventory item.
106 bool curse_an_item(bool quiet)
107 {
108     // allowing these would enable mummy scumming
109     if (you.religion == GOD_ASHENZARI)
110     {
111         if (!quiet)
112         {
113             mprf(MSGCH_GOD, "The curse is absorbed by %s.",
114                  god_name(GOD_ASHENZARI).c_str());
115         }
116         return false;
117     }
118
119     int count = 0;
120     int item  = ENDOFPACK;
121
122     for (int i = 0; i < ENDOFPACK; i++)
123     {
124         if (!you.inv[i].defined())
125             continue;
126
127         if (is_weapon(you.inv[i])
128             || you.inv[i].base_type == OBJ_ARMOUR
129             || you.inv[i].base_type == OBJ_JEWELLERY)
130         {
131             if (you.inv[i].cursed())
132                 continue;
133
134             // Melded items cannot be cursed.
135             if (item_is_melded(you.inv[i]))
136                 continue;
137
138             // Item is valid for cursing, so we'll give it a chance.
139             count++;
140             if (one_chance_in(count))
141                 item = i;
142         }
143     }
144
145     // Any item to curse?
146     if (item == ENDOFPACK)
147         return false;
148
149     do_curse_item(you.inv[item], false);
150
151     return true;
152 }
153
154 // The default suitable() function for monster_drop_things().
155 bool is_any_item(const item_def& item)
156 {
157     return true;
158 }
159
160 void monster_drop_things(monster* mons,
161                           bool mark_item_origins,
162                           bool (*suitable)(const item_def& item),
163                           int owner_id)
164 {
165     // Drop weapons and missiles last (i.e., on top), so others pick up.
166     for (int i = NUM_MONSTER_SLOTS - 1; i >= 0; --i)
167     {
168         int item = mons->inv[i];
169
170         if (item != NON_ITEM && suitable(mitm[item]))
171         {
172             const bool summoned_item =
173                 testbits(mitm[item].flags, ISFLAG_SUMMONED);
174             if (summoned_item)
175             {
176                 item_was_destroyed(mitm[item], mons->mindex());
177                 destroy_item(item);
178             }
179             else
180             {
181                 if (mons->friendly() && mitm[item].defined())
182                     mitm[item].flags |= ISFLAG_DROPPED_BY_ALLY;
183
184                 if (mark_item_origins && mitm[item].defined())
185                     origin_set_monster(mitm[item], mons);
186
187                 if (mitm[item].props.exists("autoinscribe"))
188                 {
189                     add_inscription(mitm[item],
190                         mitm[item].props["autoinscribe"].get_string());
191                     mitm[item].props.erase("autoinscribe");
192                 }
193
194                 // Unrands held by fixed monsters would give awfully redundant
195                 // messages ("Cerebov hits you with the Sword of Cerebov."),
196                 // thus delay identification until drop/death.
197                 autoid_unrand(mitm[item]);
198
199                 // If a monster is swimming, the items are ALREADY
200                 // underwater.
201                 move_item_to_grid(&item, mons->pos(), mons->swimming());
202             }
203
204             mons->inv[i] = NON_ITEM;
205         }
206     }
207 }
208
209 // Initialises a corpse item using the given monster and monster type.
210 // The monster pointer is optional; you may pass in NULL to bypass
211 // per-monster checks.
212 //
213 // force_corpse forces creation of the corpse item even if the monster
214 // would not otherwise merit a corpse.
215 monster_type fill_out_corpse(const monster* mons,
216                              monster_type mtype,
217                              item_def& corpse,
218                              bool force_corpse)
219 {
220     ASSERT(!invalid_monster_type(mtype));
221     corpse.clear();
222
223     int summon_type;
224     if (mons && (mons->is_summoned(NULL, &summon_type)
225                     || (mons->flags & (MF_BANISHED | MF_HARD_RESET))))
226     {
227         return MONS_NO_MONSTER;
228     }
229
230     monster_type corpse_class = mons_species(mtype);
231
232     if (mons)
233     {
234         // If this was a corpse that was temporarily animated then turn the
235         // monster back into a corpse.
236         if (mons_class_is_zombified(mons->type)
237             && (summon_type == SPELL_ANIMATE_DEAD
238                 || summon_type == SPELL_ANIMATE_SKELETON
239                 || summon_type == MON_SUMM_ANIMATE))
240         {
241             corpse_class = mons_zombie_base(mons);
242         }
243
244         if (mons && mons_genus(mtype) == MONS_DRACONIAN)
245         {
246             if (mons->type == MONS_TIAMAT)
247                 corpse_class = MONS_DRACONIAN;
248             else
249                 corpse_class = draco_subspecies(mons);
250         }
251
252         if (mons->has_ench(ENCH_GLOWING_SHAPESHIFTER))
253             mtype = corpse_class = MONS_GLOWING_SHAPESHIFTER;
254         else if (mons->has_ench(ENCH_SHAPESHIFTER))
255             mtype = corpse_class = MONS_SHAPESHIFTER;
256     }
257
258     // Doesn't leave a corpse.
259     if (!mons_class_can_leave_corpse(corpse_class) && !force_corpse)
260         return MONS_NO_MONSTER;
261
262     corpse.flags       = 0;
263     corpse.base_type   = OBJ_CORPSES;
264     corpse.plus        = corpse_class;
265     corpse.plus2       = 0;    // butcher work done
266     corpse.sub_type    = CORPSE_BODY;
267     corpse.special     = FRESHEST_CORPSE;  // rot time
268     corpse.quantity    = 1;
269     corpse.orig_monnum = mtype;
270
271     if (mtype == MONS_PLAGUE_SHAMBLER)
272         corpse.special = ROTTING_CORPSE;
273
274     if (mons)
275     {
276         corpse.props[MONSTER_HIT_DICE] = short(mons->hit_dice);
277         corpse.props[MONSTER_NUMBER]   = short(mons->number);
278         // XXX: Appears to be a safe conversion?
279         corpse.props[MONSTER_MID]      = int(mons->mid);
280     }
281
282     corpse.colour = mons_class_colour(corpse_class);
283     if (corpse.colour == BLACK)
284     {
285         if (mons)
286             corpse.colour = mons->colour;
287         else
288         {
289             // [ds] Ick: no easy way to get a monster's colour
290             // otherwise:
291             monster m;
292             m.type = mtype;
293             define_monster(&m);
294             corpse.colour = m.colour;
295         }
296     }
297
298     if (mons && !mons->mname.empty() && !(mons->flags & MF_NAME_NOCORPSE))
299     {
300         corpse.props[CORPSE_NAME_KEY] = mons->mname;
301         corpse.props[CORPSE_NAME_TYPE_KEY].get_int64() = mons->flags;
302     }
303     else if (mons_is_unique(mtype))
304     {
305         corpse.props[CORPSE_NAME_KEY] = mons_type_name(mtype, DESC_PLAIN);
306         corpse.props[CORPSE_NAME_TYPE_KEY].get_int64() = 0;
307     }
308
309     return corpse_class;
310 }
311
312 bool explode_corpse(item_def& corpse, const coord_def& where)
313 {
314     // Don't want chunks to show up behind the player.
315     los_def ld(where, opc_no_actor);
316
317     if (monster_descriptor(corpse.mon_type, MDSC_LEAVES_HIDE)
318         && mons_genus(corpse.mon_type) == MONS_DRAGON)
319     {
320         // Uh... dragon hide is tough stuff and it keeps the monster in
321         // one piece?  More importantly, it prevents a flavour feature
322         // from becoming a trap for the unwary.
323
324         return false;
325     }
326
327     ld.update();
328
329     const int max_chunks = get_max_corpse_chunks(corpse.mon_type);
330
331     int nchunks = 1 + random2(max_chunks);
332     nchunks = stepdown_value(nchunks, 4, 4, 12, 12);
333
334     int ntries = 0;
335
336     corpse.base_type = OBJ_FOOD;
337     corpse.sub_type  = FOOD_CHUNK;
338     if (is_bad_food(corpse))
339         corpse.flags |= ISFLAG_DROPPED;
340
341     int blood = nchunks * 3;
342
343     if (food_is_rotten(corpse))
344         blood /= 3;
345
346     blood_spray(where, corpse.mon_type, blood);
347
348     while (nchunks > 0 && ntries < 10000)
349     {
350         ++ntries;
351
352         coord_def cp = where;
353         cp.x += random_range(-LOS_RADIUS, LOS_RADIUS);
354         cp.y += random_range(-LOS_RADIUS, LOS_RADIUS);
355
356         dprf("Trying to scatter chunk to %d, %d...", cp.x, cp.y);
357
358         if (!in_bounds(cp))
359             continue;
360
361         if (!ld.see_cell(cp))
362             continue;
363
364         dprf("Cell is visible...");
365
366         if (feat_is_solid(grd(cp)) || actor_at(cp))
367             continue;
368
369         --nchunks;
370
371         dprf("Success");
372
373         copy_item_to_grid(corpse, cp);
374     }
375
376     return true;
377 }
378
379 // Returns the item slot of a generated corpse, or -1 if no corpse.
380 int place_monster_corpse(const monster* mons, bool silent,
381                          bool force)
382 {
383     // The game can attempt to place a corpse for an out-of-bounds monster
384     // if a shifter turns into a giant spore and explodes.  In this
385     // case we place no corpse since the explosion means anything left
386     // over would be scattered, tiny chunks of shifter.
387     if (!in_bounds(mons->pos()))
388         return -1;
389
390     // Don't attempt to place corpses within walls, either.
391     // Currently, this only applies to (shapeshifter) rock worms.
392     if (feat_is_wall(grd(mons->pos())))
393         return -1;
394
395     // If we were told not to leave a corpse, don't.
396     if (mons->props.exists("never_corpse"))
397         return -1;
398
399     item_def corpse;
400     const monster_type corpse_class = fill_out_corpse(mons, mons->type,
401                                                       corpse);
402
403     bool vault_forced = false;
404
405     // Don't place a corpse?  If a zombified monster is somehow capable
406     // of leaving a corpse, then always place it.
407     if (mons_class_is_zombified(mons->type))
408         force = true;
409
410     // "always_corpse" forces monsters to always generate a corpse upon
411     // their deaths.
412     if (mons->props.exists("always_corpse")
413         || mons_class_flag(mons->type, M_ALWAYS_CORPSE))
414     {
415         vault_forced = true;
416     }
417
418     if (corpse_class == MONS_NO_MONSTER
419         || (!force && !vault_forced && coinflip())
420         || (mons_corpse_effect(corpse_class) == CE_MUTAGEN
421            && !one_chance_in(3)))
422     {
423         return -1;
424     }
425
426     if (mons && mons_is_phoenix(mons))
427         corpse.props["destroy_xp"].get_int() = _calc_player_experience(mons);
428
429     int o = get_mitm_slot();
430
431     // Zotdef corpse creation forces cleanup, otherwise starvation
432     // kicks in. The magic number 9 is less than the magic number of
433     // 10 in get_mitm_slot which indicates that a cull will be initiated
434     // if a free slot can't be found.
435     if (o == NON_ITEM && crawl_state.game_is_zotdef())
436         o = get_mitm_slot(9);
437
438     if (o == NON_ITEM)
439     {
440         item_was_destroyed(corpse);
441         return -1;
442     }
443
444     mitm[o] = corpse;
445
446     origin_set_monster(mitm[o], mons);
447
448     if ((mons->flags & MF_EXPLODE_KILL) && explode_corpse(corpse, mons->pos()))
449     {
450         // We already have a spray of chunks.
451         item_was_destroyed(mitm[o]);
452         destroy_item(o);
453         return -1;
454     }
455
456     move_item_to_grid(&o, mons->pos(), !mons->swimming());
457
458     if (you.see_cell(mons->pos()))
459     {
460         if (force && !silent)
461         {
462             if (you.can_see(mons))
463                 simple_monster_message(mons, " turns back into a corpse!");
464             else
465             {
466                 mprf("%s appears out of nowhere!",
467                      mitm[o].name(DESC_A).c_str());
468             }
469         }
470         if (o != NON_ITEM && !silent)
471         {
472             const bool poison =
473                 (chunk_is_poisonous(mons_corpse_effect(corpse_class))
474                  && player_res_poison() <= 0);
475             hints_dissection_reminder(!poison);
476         }
477     }
478
479     return (o == NON_ITEM ? -1 : o);
480 }
481
482 static void _hints_inspect_kill()
483 {
484     if (Hints.hints_events[HINT_KILLED_MONSTER])
485         learned_something_new(HINT_KILLED_MONSTER);
486 }
487
488 static string _milestone_kill_verb(killer_type killer)
489 {
490     return (killer == KILL_BANISHED ? "banished" :
491             killer == KILL_PACIFIED ? "pacified" :
492             killer == KILL_ENSLAVED ? "enslaved" : "killed");
493 }
494
495 void record_monster_defeat(monster* mons, killer_type killer)
496 {
497     if (crawl_state.game_is_arena())
498         return;
499     if (killer == KILL_RESET || killer == KILL_DISMISSED)
500         return;
501     if (mons->has_ench(ENCH_FAKE_ABJURATION))
502         return;
503     if (MONST_INTERESTING(mons))
504     {
505         take_note(Note(NOTE_DEFEAT_MONSTER, mons->type, mons->friendly(),
506                        mons->full_name(DESC_A).c_str(),
507                        _milestone_kill_verb(killer).c_str()));
508     }
509     // XXX: See comment in monster_polymorph.
510     bool is_unique = mons_is_unique(mons->type);
511     if (mons->props.exists("original_was_unique"))
512         is_unique = mons->props["original_was_unique"].get_bool();
513     if (mons->type == MONS_PLAYER_GHOST)
514     {
515         monster_info mi(mons);
516         string milestone = _milestone_kill_verb(killer) + " the ghost of ";
517         milestone += get_ghost_description(mi, true);
518         milestone += ".";
519         mark_milestone("ghost", milestone);
520     }
521     // Or summoned uniques, which a summoned ghost is treated as {due}
522     else if (is_unique && !mons->is_summoned())
523     {
524         mark_milestone("uniq",
525                        _milestone_kill_verb(killer)
526                        + " "
527                        + mons->name(DESC_THE, true)
528                        + ".");
529     }
530 }
531
532 static int _calc_monster_experience(monster* victim, killer_type killer,
533                                     int killer_index)
534 {
535     const int experience = exper_value(victim);
536     const bool no_xp = victim->has_ench(ENCH_ABJ) || !experience || victim->has_ench(ENCH_FAKE_ABJURATION);
537     const bool created_friendly = testbits(victim->flags, MF_NO_REWARD);
538
539     if (no_xp || !MON_KILL(killer) || invalid_monster_index(killer_index))
540         return 0;
541
542     monster* mon = &menv[killer_index];
543     if (!mon->alive())
544         return 0;
545
546     if ((created_friendly && mon->friendly())
547         || mons_aligned(mon, victim))
548     {
549         return 0;
550     }
551
552     return experience;
553 }
554
555 static void _give_monster_experience(int experience, int killer_index)
556 {
557     if (experience <= 0 || invalid_monster_index(killer_index))
558         return;
559
560     monster* mon = &menv[killer_index];
561     if (!mon->alive())
562         return;
563
564     if (mon->gain_exp(experience))
565     {
566         if (you.religion != GOD_SHINING_ONE && you.religion != GOD_BEOGH
567             || player_under_penance()
568             || !one_chance_in(3))
569         {
570             return;
571         }
572
573         // Randomly bless the follower who gained experience.
574         if (you.religion == GOD_SHINING_ONE
575                 && random2(you.piety) >= piety_breakpoint(0)
576             || you.religion == GOD_BEOGH
577                 && random2(you.piety) >= piety_breakpoint(2))
578         {
579             bless_follower(mon);
580         }
581     }
582 }
583
584 static void _beogh_spread_experience(int exp)
585 {
586     int total_hd = 0;
587
588     for (monster_iterator mi(&you); mi; ++mi)
589     {
590         if (is_orcish_follower(*mi))
591             total_hd += mi->hit_dice;
592     }
593
594     if (total_hd > 0)
595     {
596         for (monster_iterator mi(&you); mi; ++mi)
597         {
598             if (is_orcish_follower(*mi))
599             {
600                 _give_monster_experience(exp * mi->hit_dice / total_hd,
601                                          mi->mindex());
602             }
603         }
604     }
605 }
606
607 static int _calc_player_experience(const monster* mons)
608 {
609     int experience = exper_value(mons);
610
611     const bool created_friendly = testbits(mons->flags, MF_NO_REWARD);
612     const bool was_neutral = testbits(mons->flags, MF_WAS_NEUTRAL);
613     const bool no_xp = mons->has_ench(ENCH_ABJ) || !experience || mons->has_ench(ENCH_FAKE_ABJURATION);
614     const bool already_got_half_xp = testbits(mons->flags, MF_GOT_HALF_XP);
615     const int half_xp = (experience + 1) / 2;
616
617     // We give double exp for shedu here, rather than artificially
618     // adjusting the modifier.
619     if (mons->flags & MF_BAND_MEMBER && mons_is_shedu(mons))
620         experience *= 2;
621
622     if (created_friendly || was_neutral || no_xp
623         || mons_is_shedu(mons) && shedu_pair_alive(mons))
624     {
625         return 0; // No xp if monster was created friendly or summoned.
626                     // or if you've only killed one of two shedu.
627     }
628
629     if (!mons->damage_total)
630     {
631         mprf(MSGCH_WARN, "Error, exp for monster with no damage: %s",
632              mons->name(DESC_PLAIN, true).c_str());
633         return 0;
634     }
635
636     dprf("Damage ratio: %1.1f/%d (%d%%)",
637          0.5 * mons->damage_friendly, mons->damage_total,
638          50 * mons->damage_friendly / mons->damage_total);
639     experience = (experience * mons->damage_friendly / mons->damage_total
640                   + 1) / 2;
641     ASSERT(mons->damage_friendly <= 2 * mons->damage_total);
642
643     // All deaths of hostiles grant at least 50% XP in ZotDef.
644     if (crawl_state.game_is_zotdef() && experience < half_xp)
645         experience = half_xp;
646
647     // Note: This doesn't happen currently since monsters with
648     //       MF_GOT_HALF_XP have always gone through pacification,
649     //       hence also have MF_WAS_NEUTRAL. [rob]
650     if (already_got_half_xp)
651     {
652         experience -= half_xp;
653         if (experience < 0)
654             experience = 0;
655     }
656
657     return experience;
658 }
659
660 static void _give_player_experience(int experience, killer_type killer,
661                                     bool pet_kill, bool was_visible)
662 {
663     if (experience <= 0 || crawl_state.game_is_arena())
664         return;
665
666     unsigned int exp_gain = 0;
667     gain_exp(experience, &exp_gain);
668
669     kill_category kc =
670             (killer == KILL_YOU || killer == KILL_YOU_MISSILE) ? KC_YOU :
671             (pet_kill)                                         ? KC_FRIENDLY :
672                                                                  KC_OTHER;
673     PlaceInfo& curr_PlaceInfo = you.get_place_info();
674     PlaceInfo  delta;
675
676     delta.mon_kill_num[kc]++;
677     delta.mon_kill_exp       += exp_gain;
678
679     you.global_info += delta;
680     you.global_info.assert_validity();
681
682     curr_PlaceInfo += delta;
683     curr_PlaceInfo.assert_validity();
684
685     // Give a message for monsters dying out of sight.
686     if (exp_gain > 0 && !was_visible)
687         mpr("You feel a bit more experienced.");
688
689     if (kc == KC_YOU && you.religion == GOD_BEOGH)
690         _beogh_spread_experience(experience / 2);
691 }
692
693 static void _give_experience(int player_exp, int monster_exp,
694                              killer_type killer, int killer_index,
695                              bool pet_kill, bool was_visible)
696 {
697     _give_player_experience(player_exp, killer, pet_kill, was_visible);
698     _give_monster_experience(monster_exp, killer_index);
699 }
700
701 static bool _is_pet_kill(killer_type killer, int i)
702 {
703     if (!MON_KILL(killer))
704         return false;
705
706     if (i == ANON_FRIENDLY_MONSTER)
707         return true;
708
709     if (invalid_monster_index(i))
710         return false;
711
712     const monster* m = &menv[i];
713     if (m->friendly()) // This includes enslaved monsters.
714         return true;
715
716     // Check if the monster was confused by you or a friendly, which
717     // makes casualties to this monster collateral kills.
718     const mon_enchant me = m->get_ench(ENCH_CONFUSION);
719     return (me.ench == ENCH_CONFUSION
720             && (me.who == KC_YOU || me.who == KC_FRIENDLY));
721 }
722
723 int exp_rate(int killer)
724 {
725     if (killer == MHITYOU)
726         return 2;
727
728     if (_is_pet_kill(KILL_MON, killer))
729         return 1;
730
731     return 0;
732 }
733
734 // Elyvilon will occasionally (5% chance) protect the life of one of
735 // your allies.
736 static bool _ely_protect_ally(monster* mons, killer_type killer)
737 {
738     if (you.religion != GOD_ELYVILON)
739         return false;
740
741     if (!MON_KILL(killer) && !YOU_KILL(killer))
742         return false;
743
744     if (!mons->is_holy()
745             && mons->holiness() != MH_NATURAL
746         || !mons->friendly()
747         || !you.can_see(mons) // for simplicity
748         || !one_chance_in(20))
749     {
750         return false;
751     }
752
753     mons->hit_points = 1;
754
755     snprintf(info, INFO_SIZE, " protects %s from harm!",
756              mons->name(DESC_THE).c_str());
757
758     simple_god_message(info);
759
760     return true;
761 }
762
763 // Elyvilon retribution effect: Heal hostile monsters that were about to
764 // be killed by you or one of your friends.
765 static bool _ely_heal_monster(monster* mons, killer_type killer, int i)
766 {
767     god_type god = GOD_ELYVILON;
768
769     if (!you.penance[god] || !god_hates_your_god(god))
770         return false;
771
772     const int ely_penance = you.penance[god];
773
774     if (mons->friendly() || !one_chance_in(10))
775         return false;
776
777     if (MON_KILL(killer) && !invalid_monster_index(i))
778     {
779         monster* mon = &menv[i];
780         if (!mon->friendly() || !one_chance_in(3))
781             return false;
782
783         if (!mons_near(mons))
784             return false;
785     }
786     else if (!YOU_KILL(killer))
787         return false;
788
789     dprf("monster hp: %d, max hp: %d", mons->hit_points, mons->max_hit_points);
790
791     mons->hit_points = min(1 + random2(ely_penance/3), mons->max_hit_points);
792
793     dprf("new hp: %d, ely penance: %d", mons->hit_points, ely_penance);
794
795     snprintf(info, INFO_SIZE, "%s heals %s%s",
796              god_name(god, false).c_str(),
797              mons->name(DESC_THE).c_str(),
798              mons->hit_points * 2 <= mons->max_hit_points ? "." : "!");
799
800     god_speaks(god, info);
801     dec_penance(god, 1);
802
803     return true;
804 }
805
806 static bool _yred_enslave_soul(monster* mons, killer_type killer)
807 {
808     if (you.religion == GOD_YREDELEMNUL && mons_enslaved_body_and_soul(mons)
809         && mons_near(mons) && killer != KILL_RESET
810         && killer != KILL_DISMISSED
811         && killer != KILL_BANISHED)
812     {
813         record_monster_defeat(mons, killer);
814         record_monster_defeat(mons, KILL_ENSLAVED);
815         yred_make_enslaved_soul(mons, player_under_penance());
816         return true;
817     }
818
819     return false;
820 }
821
822 static bool _beogh_forcibly_convert_orc(monster* mons, killer_type killer,
823                                         int i)
824 {
825     if (you.religion == GOD_BEOGH
826         && mons_genus(mons->type) == MONS_ORC
827         && !mons->is_summoned() && !mons->is_shapeshifter()
828         && !player_under_penance() && you.piety >= piety_breakpoint(2)
829         && mons_near(mons) && !mons_is_god_gift(mons))
830     {
831         bool convert = false;
832
833         if (YOU_KILL(killer))
834             convert = true;
835         else if (MON_KILL(killer) && !invalid_monster_index(i))
836         {
837             monster* mon = &menv[i];
838             if (is_follower(mon) && !one_chance_in(3))
839                 convert = true;
840         }
841
842         // Orcs may convert to Beogh under threat of death, either from
843         // you or, less often, your followers.  In both cases, the
844         // checks are made against your stats.  You're the potential
845         // messiah, after all.
846         if (convert)
847         {
848 #ifdef DEBUG_DIAGNOSTICS
849             mprf(MSGCH_DIAGNOSTICS, "Death convert attempt on %s, HD: %d, "
850                  "your xl: %d",
851                  mons->name(DESC_PLAIN).c_str(),
852                  mons->hit_dice,
853                  you.experience_level);
854 #endif
855             if (random2(you.piety) >= piety_breakpoint(0)
856                 && random2(you.experience_level) >= random2(mons->hit_dice)
857                 // Bias beaten-up-conversion towards the stronger orcs.
858                 && random2(mons->hit_dice) > 2)
859             {
860                 beogh_convert_orc(mons, true, MON_KILL(killer));
861                 return true;
862             }
863         }
864     }
865
866     return false;
867 }
868
869 static bool _monster_avoided_death(monster* mons, killer_type killer, int i)
870 {
871     if (mons->max_hit_points <= 0 || mons->hit_dice < 1)
872         return false;
873
874     // Before the hp check since this should not care about the power of the
875     // finishing blow
876     if (mons->holiness() == MH_UNDEAD && !mons_is_zombified(mons)
877         && soul_aura(mons->pos())
878         && killer != KILL_RESET
879         && killer != KILL_DISMISSED
880         && killer != KILL_BANISHED)
881     {
882         if (lost_soul_revive(mons))
883             return true;
884     }
885
886     if (mons->hit_points < -25 || mons->hit_points < -mons->max_hit_points)
887         return false;
888
889     // Elyvilon specials.
890     if (_ely_protect_ally(mons, killer))
891         return true;
892     if (_ely_heal_monster(mons, killer, i))
893         return true;
894
895     // Yredelemnul special.
896     if (_yred_enslave_soul(mons, killer))
897         return true;
898
899     // Beogh special.
900     if (_beogh_forcibly_convert_orc(mons, killer, i))
901         return true;
902
903     return false;
904 }
905
906 static void _jiyva_died()
907 {
908     if (you.religion == GOD_JIYVA)
909         return;
910
911     add_daction(DACT_REMOVE_JIYVA_ALTARS);
912
913     if (!player_in_branch(BRANCH_SLIME_PITS))
914         return;
915
916     if (silenced(you.pos()))
917     {
918         god_speaks(GOD_JIYVA, "With an infernal shudder, the power ruling "
919                    "this place vanishes!");
920     }
921     else
922     {
923         god_speaks(GOD_JIYVA, "With infernal noise, the power ruling this "
924                    "place vanishes!");
925     }
926 }
927
928 static void _fire_monster_death_event(monster* mons,
929                                       killer_type killer,
930                                       int i, bool polymorph)
931 {
932     int type = mons->type;
933
934     // Treat whatever the Royal Jelly polymorphed into as if it were still
935     // the Royal Jelly (but if a player chooses the character name
936     // "shaped Royal Jelly" don't unlock the vaults when the player's
937     // ghost is killed).
938     if (mons->mname == "shaped Royal Jelly"
939         && !mons_is_pghost(mons->type))
940     {
941         type = MONS_ROYAL_JELLY;
942     }
943
944     if (!polymorph)
945     {
946         dungeon_events.fire_event(
947             dgn_event(DET_MONSTER_DIED, mons->pos(), 0,
948                       mons->mid, killer));
949     }
950
951     if (killer == KILL_BANISHED)
952         return;
953
954     los_monster_died(mons);
955
956     if (type == MONS_ROYAL_JELLY && !polymorph)
957     {
958         you.royal_jelly_dead = true;
959
960         if (jiyva_is_dead())
961             _jiyva_died();
962     }
963 }
964
965 static void _mummy_curse(monster* mons, killer_type killer, int index)
966 {
967     int pow;
968
969     switch (killer)
970     {
971         // Mummy killed by trap or something other than the player or
972         // another monster, so no curse.
973         case KILL_MISC:
974         // Mummy sent to the Abyss wasn't actually killed, so no curse.
975         case KILL_RESET:
976         case KILL_DISMISSED:
977         case KILL_BANISHED:
978             return;
979
980         default:
981             break;
982     }
983
984     switch (mons->type)
985     {
986         case MONS_MENKAURE:
987         case MONS_MUMMY:          pow = 1; break;
988         case MONS_GUARDIAN_MUMMY: pow = 3; break;
989         case MONS_MUMMY_PRIEST:   pow = 8; break;
990         case MONS_GREATER_MUMMY:  pow = 11; break;
991         case MONS_KHUFU:          pow = 15; break;
992
993         default:
994             mpr("Unknown mummy type.", MSGCH_DIAGNOSTICS);
995             return;
996     }
997
998     // beam code might give an index of MHITYOU for the player.
999     if (YOU_KILL(killer))
1000         index = NON_MONSTER;
1001
1002     // Killed by a Zot trap, a god, etc.
1003     if (index != NON_MONSTER && invalid_monster_index(index))
1004         return;
1005
1006     actor* target;
1007     if (index == NON_MONSTER)
1008         target = &you;
1009     else
1010     {
1011         // Mummies committing suicide don't cause a death curse.
1012         if (index == mons->mindex())
1013             return;
1014         target = &menv[index];
1015     }
1016
1017     // Mummy was killed by a giant spore or ball lightning?
1018     if (!target->alive())
1019         return;
1020
1021     if ((mons->type == MONS_MUMMY || mons->type == MONS_MENKAURE)
1022         && YOU_KILL(killer))
1023     {
1024         // Kiku protects you from ordinary mummy curses.
1025         if (you.religion == GOD_KIKUBAAQUDGHA && !player_under_penance()
1026             && you.piety >= piety_breakpoint(1))
1027         {
1028             simple_god_message(" averts the curse.");
1029             return;
1030         }
1031
1032         mpr("You feel nervous for a moment...", MSGCH_MONSTER_SPELL);
1033         curse_an_item();
1034     }
1035     else
1036     {
1037         if (index == NON_MONSTER)
1038         {
1039             mpr("You feel extremely nervous for a moment...",
1040                 MSGCH_MONSTER_SPELL);
1041         }
1042         else if (you.can_see(target))
1043         {
1044             mprf(MSGCH_MONSTER_SPELL, "A malignant aura surrounds %s.",
1045                  target->name(DESC_THE).c_str());
1046         }
1047         MiscastEffect(target, mons->mindex(), SPTYP_NECROMANCY,
1048                       pow, random2avg(88, 3), "a mummy death curse");
1049     }
1050 }
1051
1052 static void _setup_base_explosion(bolt & beam, const monster& origin)
1053 {
1054     beam.is_tracer    = false;
1055     beam.is_explosion = true;
1056     beam.beam_source  = origin.mindex();
1057     beam.glyph        = dchar_glyph(DCHAR_FIRED_BURST);
1058     beam.source       = origin.pos();
1059     beam.source_name  = origin.base_name(DESC_BASENAME, true);
1060     beam.target       = origin.pos();
1061     beam.noise_msg    = "You hear an explosion!";
1062
1063     if (!crawl_state.game_is_arena() && origin.attitude == ATT_FRIENDLY
1064         && !origin.is_summoned())
1065     {
1066         beam.thrower = KILL_YOU;
1067     }
1068     else
1069         beam.thrower = KILL_MON;
1070
1071     beam.aux_source.clear();
1072     beam.attitude = origin.attitude;
1073 }
1074
1075 void setup_spore_explosion(bolt & beam, const monster& origin)
1076 {
1077     _setup_base_explosion(beam, origin);
1078     beam.flavour = BEAM_SPORE;
1079     beam.damage  = dice_def(3, 15);
1080     beam.name    = "explosion of spores";
1081     beam.colour  = LIGHTGREY;
1082     beam.ex_size = 2;
1083 }
1084
1085 static void _setup_lightning_explosion(bolt & beam, const monster& origin)
1086 {
1087     _setup_base_explosion(beam, origin);
1088     beam.flavour   = BEAM_ELECTRICITY;
1089     beam.damage    = dice_def(3, 20);
1090     beam.name      = "blast of lightning";
1091     beam.noise_msg = "You hear a clap of thunder!";
1092     beam.colour    = LIGHTCYAN;
1093     beam.ex_size   = coinflip() ? 3 : 2;
1094 }
1095
1096 static void _setup_prism_explosion(bolt& beam, const monster& origin)
1097 {
1098     _setup_base_explosion(beam, origin);
1099     beam.flavour = BEAM_MMISSILE;
1100     beam.damage  = (origin.number == 2 ? dice_def(3, 6 + origin.hit_dice * 7 / 4)
1101                     : dice_def(2, 6 + origin.hit_dice * 7 / 4));
1102     beam.name    = "blast of energy";
1103     beam.colour  = MAGENTA;
1104     beam.ex_size = origin.number;
1105 }
1106
1107 static void _setup_inner_flame_explosion(bolt & beam, const monster& origin,
1108                                          actor* agent)
1109 {
1110     _setup_base_explosion(beam, origin);
1111     const int size   = origin.body_size(PSIZE_BODY);
1112     beam.flavour     = BEAM_FIRE;
1113     beam.damage      = (size > SIZE_BIG)  ? dice_def(3, 25) :
1114                        (size > SIZE_TINY) ? dice_def(3, 20) :
1115                                             dice_def(3, 15);
1116     beam.name        = "fiery explosion";
1117     beam.colour      = RED;
1118     beam.ex_size     = (size > SIZE_BIG) ? 2 : 1;
1119     beam.source_name = origin.name(DESC_A, true);
1120     beam.thrower     = (agent && agent->is_player()) ? KILL_YOU_MISSILE
1121                                                      : KILL_MON_MISSILE;
1122 }
1123
1124 static bool _explode_monster(monster* mons, killer_type killer,
1125                              int killer_index, bool pet_kill, bool wizard)
1126 {
1127     if (mons->hit_points > 0 || mons->hit_points <= -15 || wizard
1128         || killer == KILL_RESET || killer == KILL_DISMISSED
1129         || killer == KILL_BANISHED)
1130     {
1131         if (killer != KILL_TIMEOUT)
1132             return false;
1133     }
1134
1135     bolt beam;
1136     const int type = mons->type;
1137     const char* sanct_msg = NULL;
1138     actor* agent = mons;
1139
1140     if (type == MONS_GIANT_SPORE)
1141     {
1142         setup_spore_explosion(beam, *mons);
1143         sanct_msg    = "By Zin's power, the giant spore's explosion is "
1144                        "contained.";
1145     }
1146     else if (type == MONS_BALL_LIGHTNING)
1147     {
1148         _setup_lightning_explosion(beam, *mons);
1149         sanct_msg    = "By Zin's power, the ball lightning's explosion "
1150                        "is contained.";
1151     }
1152     else if (type == MONS_LURKING_HORROR)
1153         sanct_msg = "The lurking horror fades away harmlessly.";
1154     else if (type == MONS_FULMINANT_PRISM)
1155     {
1156         _setup_prism_explosion(beam, *mons);
1157         sanct_msg = "By Zin's power, the prism's explosion is contained.";
1158     }
1159     else if (mons->has_ench(ENCH_INNER_FLAME))
1160     {
1161         mon_enchant i_f = mons->get_ench(ENCH_INNER_FLAME);
1162         ASSERT(i_f.ench == ENCH_INNER_FLAME);
1163         agent = actor_by_mid(i_f.source);
1164         _setup_inner_flame_explosion(beam, *mons, agent);
1165         // This might need to change if monsters ever get the ability to cast
1166         // Inner Flame...
1167         if (i_f.source == MID_ANON_FRIEND)
1168             mons_add_blame(mons, "hexed by Xom");
1169         else if (agent && agent->is_player())
1170             mons_add_blame(mons, "hexed by the player character");
1171         else if (agent)
1172             mons_add_blame(mons, "hexed by " + agent->name(DESC_A, true));
1173         mons->flags    |= MF_EXPLODE_KILL;
1174         sanct_msg       = "By Zin's power, the fiery explosion "
1175                           "is contained.";
1176         beam.aux_source = "exploding inner flame";
1177     }
1178     else
1179     {
1180         msg::streams(MSGCH_DIAGNOSTICS) << "Unknown spore type: "
1181                                         << static_cast<int>(type)
1182                                         << endl;
1183         return false;
1184     }
1185
1186     if (beam.aux_source.empty())
1187     {
1188         if (YOU_KILL(killer))
1189             beam.aux_source = "set off by themself";
1190         else if (pet_kill)
1191             beam.aux_source = "set off by their pet";
1192     }
1193
1194     bool saw = false;
1195     if (you.can_see(mons))
1196     {
1197         saw = true;
1198         viewwindow();
1199         if (is_sanctuary(mons->pos()))
1200             mpr(sanct_msg, MSGCH_GOD);
1201         else
1202             mprf(MSGCH_MONSTER_DAMAGE, MDAM_DEAD, "%s explodes!",
1203                  mons->full_name(DESC_THE).c_str());
1204     }
1205
1206     if (is_sanctuary(mons->pos()))
1207         return false;
1208
1209     // Explosion side-effects.
1210     if (type == MONS_LURKING_HORROR)
1211         torment(mons, mons->mindex(), mons->pos());
1212     else if (mons->has_ench(ENCH_INNER_FLAME))
1213     {
1214         for (adjacent_iterator ai(mons->pos(), false); ai; ++ai)
1215             if (!feat_is_solid(grd(*ai)) && env.cgrid(*ai) == EMPTY_CLOUD
1216                 && !one_chance_in(5))
1217             {
1218                 place_cloud(CLOUD_FIRE, *ai, 10 + random2(10), agent);
1219             }
1220     }
1221
1222     // Detach monster from the grid first, so it doesn't get hit by
1223     // its own explosion. (GDL)
1224     mgrd(mons->pos()) = NON_MONSTER;
1225
1226     // The explosion might cause a monster to be placed where the spore
1227     // used to be, so make sure that mgrd() doesn't get cleared a second
1228     // time (causing the new monster to become floating) when
1229     // mons->reset() is called.
1230     if (type == MONS_GIANT_SPORE)
1231         mons->set_position(coord_def(0,0));
1232
1233     // Exploding kills the monster a bit earlier than normal.
1234     mons->hit_points = -16;
1235     if (saw)
1236         viewwindow();
1237
1238     // FIXME: show_more == mons_near(mons)
1239     if (type == MONS_LURKING_HORROR)
1240     {
1241         targetter_los hitfunc(mons, LOS_SOLID);
1242         flash_view_delay(DARKGRAY, 300, &hitfunc);
1243     }
1244     else
1245         beam.explode();
1246
1247     activate_ballistomycetes(mons, beam.target, YOU_KILL(beam.killer()));
1248     // Monster died in explosion, so don't re-attach it to the grid.
1249     return true;
1250 }
1251
1252 static void _monster_die_cloud(const monster* mons, bool corpse, bool silent,
1253                         bool summoned)
1254 {
1255     // Chaos spawn always leave behind a cloud of chaos.
1256     if (mons->type == MONS_CHAOS_SPAWN)
1257     {
1258         summoned = true;
1259         corpse   = false;
1260     }
1261
1262     if (!summoned)
1263         return;
1264
1265     string prefix = " ";
1266     if (corpse)
1267     {
1268         if (mons_weight(mons_species(mons->type)) == 0)
1269             return;
1270
1271         prefix = "'s corpse ";
1272     }
1273
1274     string msg = summoned_poof_msg(mons) + "!";
1275
1276     cloud_type cloud = CLOUD_NONE;
1277     if (msg.find("smoke") != string::npos)
1278         cloud = random_smoke_type();
1279     else if (msg.find("chaos") != string::npos)
1280         cloud = CLOUD_CHAOS;
1281
1282     if (!silent)
1283         simple_monster_message(mons, (prefix + msg).c_str());
1284
1285     if (cloud != CLOUD_NONE)
1286         place_cloud(cloud, mons->pos(), 1 + random2(3), mons);
1287 }
1288
1289 void mons_relocated(monster* mons)
1290 {
1291     // If the main body teleports get rid of the tentacles
1292     if (mons_is_tentacle_head(mons_base_type(mons)))
1293     {
1294         int headnum = mons->mindex();
1295
1296         if (invalid_monster_index(headnum))
1297             return;
1298
1299         for (monster_iterator mi; mi; ++mi)
1300         {
1301             if (mi->is_child_tentacle_of(mons))
1302             {
1303                 for (monster_iterator connect; connect; ++connect)
1304                 {
1305                     if (connect->is_child_tentacle_of(*mi))
1306                         monster_die(*connect, KILL_RESET, -1, true, false);
1307                 }
1308                 monster_die(*mi, KILL_RESET, -1, true, false);
1309             }
1310         }
1311     }
1312     // If a tentacle/segment is relocated just kill the tentacle
1313     else if (mons->is_child_monster())
1314     {
1315         int base_id = mons->mindex();
1316
1317         monster* tentacle = mons;
1318
1319         if (mons->is_child_tentacle_segment()
1320                 && !::invalid_monster_index(base_id)
1321                 && menv[base_id].is_parent_monster_of(mons))
1322         {
1323             tentacle = &menv[base_id];
1324         }
1325
1326         for (monster_iterator connect; connect; ++connect)
1327         {
1328             if (connect->is_child_tentacle_of(tentacle))
1329                 monster_die(*connect, KILL_RESET, -1, true, false);
1330         }
1331
1332         monster_die(tentacle, KILL_RESET, -1, true, false);
1333     }
1334     else if (mons->type == MONS_ELDRITCH_TENTACLE
1335              || mons->type == MONS_ELDRITCH_TENTACLE_SEGMENT)
1336     {
1337         int base_id = mons->type == MONS_ELDRITCH_TENTACLE
1338                       ? mons->mindex() : mons->number;
1339
1340         monster_die(&menv[base_id], KILL_RESET, -1, true, false);
1341
1342         for (monster_iterator mit; mit; ++mit)
1343         {
1344             if (mit->type == MONS_ELDRITCH_TENTACLE_SEGMENT
1345                 && (int) mit->number == base_id)
1346             {
1347                 monster_die(*mit, KILL_RESET, -1, true, false);
1348             }
1349         }
1350
1351     }
1352
1353     mons->clear_clinging();
1354 }
1355
1356 // When given either a tentacle end or segment, kills the end and all segments
1357 // of that tentacle.
1358 static int _destroy_tentacle(monster* mons)
1359 {
1360     int seen = 0;
1361
1362     monster* head = mons_is_tentacle_segment(mons->type)
1363             ? mons_get_parent_monster(mons) : mons;
1364
1365     //If we tried to find the head, but failed (probably because it is already
1366     //dead), cancel trying to kill this tentacle
1367     if (head == NULL)
1368         return 0;
1369
1370     // Some issue with using monster_die leading to DEAD_MONSTER
1371     // or w/e. Using hurt seems to cause more problems though.
1372     for (monster_iterator mi; mi; ++mi)
1373     {
1374         if (mi->is_child_tentacle_of(head))
1375         {
1376             if (mons_near(*mi))
1377                 seen++;
1378             //mi->hurt(*mi, INSTANT_DEATH);
1379             monster_die(*mi, KILL_MISC, NON_MONSTER, true);
1380         }
1381     }
1382
1383     if (mons != head)
1384     {
1385         if (mons_near(head))
1386                 seen++;
1387
1388         //mprf("killing base, %d %d", origin->mindex(), tentacle_idx);
1389         //menv[tentacle_idx].hurt(&menv[tentacle_idx], INSTANT_DEATH);
1390         monster_die(head, KILL_MISC, NON_MONSTER, true);
1391     }
1392
1393     return seen;
1394 }
1395
1396 static int _destroy_tentacles(monster* head)
1397 {
1398     int seen = 0;
1399     for (monster_iterator mi; mi; ++mi)
1400     {
1401         if (mi->is_child_tentacle_of(head))
1402         {
1403             if (_destroy_tentacle(*mi))
1404                 seen++;
1405             if (!mi->is_child_tentacle_segment())
1406             {
1407                 monster_die(mi->as_monster(), KILL_MISC, NON_MONSTER, true);
1408                 seen++;
1409             }
1410         }
1411     }
1412     return seen;
1413 }
1414
1415 static string _killer_type_name(killer_type killer)
1416 {
1417     switch (killer)
1418     {
1419     case KILL_NONE:
1420         return "none";
1421     case KILL_YOU:
1422         return "you";
1423     case KILL_MON:
1424         return "mon";
1425     case KILL_YOU_MISSILE:
1426         return "you_missile";
1427     case KILL_MON_MISSILE:
1428         return "mon_missile";
1429     case KILL_YOU_CONF:
1430         return "you_conf";
1431     case KILL_MISCAST:
1432         return "miscast";
1433     case KILL_MISC:
1434         return "misc";
1435     case KILL_RESET:
1436         return "reset";
1437     case KILL_DISMISSED:
1438         return "dismissed";
1439     case KILL_BANISHED:
1440         return "banished";
1441     case KILL_UNSUMMONED:
1442         return "unsummoned";
1443     case KILL_TIMEOUT:
1444         return "timeout";
1445     case KILL_PACIFIED:
1446         return "pacified";
1447     case KILL_ENSLAVED:
1448         return "enslaved";
1449     }
1450     die("invalid killer type");
1451 }
1452
1453 static void _make_spectral_thing(monster* mons, bool quiet)
1454 {
1455     if (mons->holiness() == MH_NATURAL && mons_can_be_zombified(mons))
1456     {
1457         const monster_type spectre_type = mons_species(mons->type);
1458         enchant_type shapeshift = ENCH_NONE;
1459         if (mons->has_ench(ENCH_SHAPESHIFTER))
1460             shapeshift = ENCH_SHAPESHIFTER;
1461         else if (mons->has_ench(ENCH_GLOWING_SHAPESHIFTER))
1462             shapeshift = ENCH_GLOWING_SHAPESHIFTER;
1463
1464         // Headless hydras cannot be made spectral hydras, sorry.
1465         if (spectre_type == MONS_HYDRA && mons->number == 0)
1466         {
1467             mprf("A glowing mist gathers momentarily, then fades.");
1468             return;
1469         }
1470
1471         // Use the original monster type as the zombified type here, to
1472         // get the proper stats from it.
1473         if (monster *spectre = create_monster(
1474                 mgen_data(MONS_SPECTRAL_THING, BEH_FRIENDLY, &you,
1475                     0, SPELL_DEATH_CHANNEL, mons->pos(), MHITYOU,
1476                     0, static_cast<god_type>(you.attribute[ATTR_DIVINE_DEATH_CHANNEL]),
1477                     mons->type, mons->number)))
1478         {
1479             if (!quiet)
1480                 mpr("A glowing mist starts to gather...");
1481
1482             // If the original monster has been drained or levelled up,
1483             // its HD might be different from its class HD, in which
1484             // case its HP should be rerolled to match.
1485             if (spectre->hit_dice != mons->hit_dice)
1486             {
1487                 spectre->hit_dice = max(mons->hit_dice, 1);
1488                 roll_zombie_hp(spectre);
1489             }
1490
1491             name_zombie(spectre, mons);
1492
1493             spectre->add_ench(mon_enchant(ENCH_FAKE_ABJURATION, 6));
1494             if (shapeshift)
1495                 spectre->add_ench(shapeshift);
1496         }
1497     }
1498 }
1499
1500 static bool _mons_reaped(actor *killer, monster* victim);
1501
1502 static bool _reaping(monster *mons)
1503 {
1504     if (!mons->props.exists("reaping_damage"))
1505         return false;
1506
1507     int rd = mons->props["reaping_damage"].get_int();
1508     dprf("Reaping chance: %d/%d", rd, mons->damage_total);
1509     if (!x_chance_in_y(rd, mons->damage_total))
1510         return false;
1511
1512     actor *killer = actor_by_mid(mons->props["reaper"].get_int());
1513     if (killer)
1514         return _mons_reaped(killer, mons);
1515     return false;
1516 }
1517
1518 int monster_die(monster* mons, actor *killer, bool silent,
1519                 bool wizard, bool fake)
1520 {
1521     killer_type ktype = KILL_YOU;
1522     int kindex = NON_MONSTER;
1523
1524     if (killer->is_monster())
1525     {
1526         const monster *kmons = killer->as_monster();
1527         ktype = kmons->confused_by_you() ? KILL_YOU_CONF : KILL_MON;
1528         kindex = kmons->mindex();
1529     }
1530
1531     return monster_die(mons, ktype, kindex, silent, wizard, fake);
1532 }
1533
1534 // Returns the slot of a possibly generated corpse or -1.
1535 int monster_die(monster* mons, killer_type killer,
1536                 int killer_index, bool silent, bool wizard, bool fake)
1537 {
1538     if (invalid_monster(mons))
1539         return -1;
1540
1541     const bool was_visible = you.can_see(mons);
1542
1543     // If a monster was banished to the Abyss and then killed there,
1544     // then its death wasn't a banishment.
1545     if (player_in_branch(BRANCH_ABYSS))
1546         mons->flags &= ~MF_BANISHED;
1547
1548     if (!silent && !fake
1549         && _monster_avoided_death(mons, killer, killer_index))
1550     {
1551         mons->flags &= ~MF_EXPLODE_KILL;
1552         return -1;
1553     }
1554
1555     // If the monster was calling the tide, let go now.
1556     mons->del_ench(ENCH_TIDE);
1557
1558     // Same for silencers.
1559     mons->del_ench(ENCH_SILENCE);
1560
1561     // ... and liquefiers.
1562     mons->del_ench(ENCH_LIQUEFYING);
1563
1564     // Clean up any blood from the flayed effect
1565     if (mons->has_ench(ENCH_FLAYED))
1566         heal_flayed_effect(mons, true, true);
1567
1568     crawl_state.inc_mon_acting(mons);
1569
1570     ASSERT(!(YOU_KILL(killer) && crawl_state.game_is_arena()));
1571
1572     if (mons->props.exists("monster_dies_lua_key"))
1573     {
1574         lua_stack_cleaner clean(dlua);
1575
1576         dlua_chunk &chunk = mons->props["monster_dies_lua_key"];
1577
1578         if (!chunk.load(dlua))
1579         {
1580             push_monster(dlua, mons);
1581             clua_pushcxxstring(dlua, _killer_type_name(killer));
1582             dlua.callfn(NULL, 2, 0);
1583         }
1584         else
1585         {
1586             mprf(MSGCH_ERROR,
1587                  "Lua death function for monster '%s' didn't load: %s",
1588                  mons->full_name(DESC_PLAIN).c_str(),
1589                  dlua.error.c_str());
1590         }
1591     }
1592
1593     mons_clear_trapping_net(mons);
1594     mons->stop_constricting_all(false);
1595     mons->stop_being_constricted();
1596
1597     you.remove_beholder(mons);
1598     you.remove_fearmonger(mons);
1599     // Uniques leave notes and milestones, so this information is already leaked.
1600     remove_unique_annotation(mons);
1601
1602     // Clear auto exclusion now the monster is killed - if we know about it.
1603     if (mons_near(mons) || wizard || mons_is_unique(mons->type))
1604         remove_auto_exclude(mons);
1605
1606           int  duration      = 0;
1607     const bool summoned      = mons->is_summoned(&duration);
1608     const int monster_killed = mons->mindex();
1609     const bool hard_reset    = testbits(mons->flags, MF_HARD_RESET);
1610     bool unsummoned          = killer == KILL_UNSUMMONED;
1611     bool timeout             = killer == KILL_TIMEOUT;
1612     const bool gives_xp      = (!summoned && !mons_class_flag(mons->type,
1613                                 M_NO_EXP_GAIN) && !mons_is_phoenix(mons));
1614
1615     bool drop_items    = !hard_reset;
1616
1617     const bool mons_reset(killer == KILL_RESET || killer == KILL_DISMISSED);
1618
1619     bool fake_abjuration = (mons->has_ench(ENCH_FAKE_ABJURATION));
1620
1621     const bool submerged     = mons->submerged();
1622
1623     bool in_transit          = false;
1624     bool was_banished        = (killer == KILL_BANISHED);
1625
1626     // Award experience for suicide if the suicide was caused by the
1627     // player.
1628     if (MON_KILL(killer) && monster_killed == killer_index)
1629     {
1630         if (mons->confused_by_you())
1631         {
1632             ASSERT(!crawl_state.game_is_arena());
1633             killer = KILL_YOU_CONF;
1634         }
1635     }
1636     else if (MON_KILL(killer) && mons->has_ench(ENCH_CHARM))
1637     {
1638         ASSERT(!crawl_state.game_is_arena());
1639         killer = KILL_YOU_CONF; // Well, it was confused in a sense... (jpeg)
1640     }
1641
1642     // Take notes and mark milestones.
1643     record_monster_defeat(mons, killer);
1644
1645     // Various sources of berserk extension on kills.
1646     if (killer == KILL_YOU && you.berserk())
1647     {
1648         if (you.religion == GOD_TROG
1649             && !player_under_penance() && you.piety > random2(1000))
1650         {
1651             const int bonus = (3 + random2avg(10, 2)) / 2;
1652
1653             you.increase_duration(DUR_BERSERK, bonus);
1654
1655             mpr("You feel the power of Trog in you as your rage grows.",
1656                 MSGCH_GOD, GOD_TROG);
1657         }
1658         else if (player_equip_unrand_effect(UNRAND_BLOODLUST))
1659         {
1660             if (coinflip())
1661             {
1662                 const int bonus = (2 + random2(4)) / 2;
1663                 you.increase_duration(DUR_BERSERK, bonus);
1664                 mpr("The necklace of Bloodlust glows a violent red.");
1665             }
1666         }
1667         else if (!you.suppressed()
1668                  && you.wearing(EQ_AMULET, AMU_RAGE)
1669                  && one_chance_in(30))
1670         {
1671             const int bonus = (2 + random2(4)) / 2;
1672             you.increase_duration(DUR_BERSERK, bonus);
1673             mpr("Your amulet glows a violent red.");
1674         }
1675     }
1676
1677     if (you.prev_targ == monster_killed)
1678     {
1679         you.prev_targ = MHITNOT;
1680         crawl_state.cancel_cmd_repeat();
1681     }
1682
1683     if (killer == KILL_YOU)
1684         crawl_state.cancel_cmd_repeat();
1685
1686     const bool pet_kill = _is_pet_kill(killer, killer_index);
1687
1688     bool did_death_message = false;
1689
1690     if (mons->type == MONS_GIANT_SPORE
1691         || mons->type == MONS_BALL_LIGHTNING
1692         || mons->type == MONS_LURKING_HORROR
1693         || (mons->type == MONS_FULMINANT_PRISM && mons->number > 0)
1694         || mons->has_ench(ENCH_INNER_FLAME))
1695     {
1696         did_death_message =
1697             _explode_monster(mons, killer, killer_index, pet_kill, wizard);
1698     }
1699     else if (mons->type == MONS_FULMINANT_PRISM && mons->number == 0)
1700     {
1701         if (!silent && !hard_reset && !was_banished)
1702         {
1703             simple_monster_message(mons, " detonates feebly.",
1704                                    MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
1705             silent = true;
1706         }
1707     }
1708     else if (mons->type == MONS_FIRE_VORTEX
1709              || mons->type == MONS_SPATIAL_VORTEX
1710              || mons->type == MONS_TWISTER)
1711     {
1712         if (!silent && !mons_reset && !was_banished)
1713         {
1714             simple_monster_message(mons, " dissipates!",
1715                                    MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
1716             silent = true;
1717         }
1718
1719         if (mons->type == MONS_FIRE_VORTEX && !wizard && !mons_reset
1720             && !submerged && !was_banished)
1721         {
1722             place_cloud(CLOUD_FIRE, mons->pos(), 2 + random2(4), mons);
1723         }
1724
1725         if (killer == KILL_RESET)
1726             killer = KILL_DISMISSED;
1727     }
1728     else if (mons->type == MONS_SIMULACRUM)
1729     {
1730         if (!silent && !mons_reset && !was_banished)
1731         {
1732             simple_monster_message(mons, " vapourises!",
1733                                    MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
1734             silent = true;
1735         }
1736
1737         if (!wizard && !mons_reset && !submerged && !was_banished)
1738             place_cloud(CLOUD_COLD, mons->pos(), 2 + random2(4), mons);
1739
1740         if (killer == KILL_RESET)
1741             killer = KILL_DISMISSED;
1742     }
1743     else if (mons->type == MONS_DANCING_WEAPON)
1744     {
1745         if (!hard_reset)
1746         {
1747             if (killer == KILL_RESET)
1748                 killer = KILL_DISMISSED;
1749         }
1750
1751         int w_idx = mons->inv[MSLOT_WEAPON];
1752         ASSERT(w_idx != NON_ITEM);
1753
1754         // XXX: This can probably become mons->is_summoned(): there's no
1755         // feasible way for a dancing weapon to "drop" it's weapon and somehow
1756         // gain a summoned one, or vice versa.
1757         bool summoned_it = mitm[w_idx].flags & ISFLAG_SUMMONED;
1758
1759         if (!silent && !hard_reset && !was_banished)
1760         {
1761             if (!summoned_it)
1762             {
1763                 simple_monster_message(mons, " falls from the air.",
1764                                        MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
1765                 silent = true;
1766             }
1767             else
1768                 killer = KILL_RESET;
1769         }
1770
1771         if (was_banished && !summoned_it && !hard_reset && mons->has_ench(ENCH_ABJ))
1772         {
1773             if (is_unrandom_artefact(mitm[w_idx]))
1774                 set_unique_item_status(mitm[w_idx], UNIQ_LOST_IN_ABYSS);
1775
1776             destroy_item(w_idx);
1777         }
1778     }
1779     else if (mons->type == MONS_ELDRITCH_TENTACLE)
1780     {
1781         if (!silent && !mons_reset && !mons->has_ench(ENCH_SEVERED) && !was_banished)
1782         {
1783             if (you.can_see(mons))
1784             {
1785                 mpr(silenced(mons->pos()) ?
1786                     "The tentacle is hauled back through the portal!" :
1787                     "With a roar, the tentacle is hauled back through the portal!",
1788                     MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
1789             }
1790             silent = true;
1791         }
1792
1793         if (killer == KILL_RESET)
1794             killer = KILL_DISMISSED;
1795     }
1796     else if (mons->type == MONS_BATTLESPHERE)
1797     {
1798         if (!wizard && !mons_reset && !was_banished)
1799             place_cloud(CLOUD_MAGIC_TRAIL, mons->pos(), 3 + random2(3), mons);
1800         end_battlesphere(mons, true);
1801     }
1802
1803     const bool death_message = !silent && !did_death_message
1804                                && mons_near(mons)
1805                                && mons->visible_to(&you);
1806     const bool exploded      = mons->flags & MF_EXPLODE_KILL;
1807
1808     const bool created_friendly = testbits(mons->flags, MF_NO_REWARD);
1809           bool anon = (killer_index == ANON_FRIENDLY_MONSTER);
1810     mon_holy_type targ_holy = mons->holiness();
1811
1812     // Dual holiness, Trog and Kiku like dead demons but not undead.
1813     if ((mons->type == MONS_ABOMINATION_SMALL
1814          || mons->type == MONS_ABOMINATION_LARGE
1815          || mons->type == MONS_CRAWLING_CORPSE
1816          || mons->type == MONS_MACABRE_MASS)
1817         && (you.religion == GOD_TROG
1818          || you.religion == GOD_KIKUBAAQUDGHA))
1819     {
1820         targ_holy = MH_DEMONIC;
1821     }
1822
1823     switch (killer)
1824     {
1825         case KILL_YOU:          // You kill in combat.
1826         case KILL_YOU_MISSILE:  // You kill by missile or beam.
1827         case KILL_YOU_CONF:     // You kill by confusion.
1828         {
1829             const bool bad_kill    = god_hates_killing(you.religion, mons);
1830             const bool was_neutral = testbits(mons->flags, MF_WAS_NEUTRAL);
1831             // killing friendlies is good, more bloodshed!
1832             // Undead feel no pain though, tormenting them is not as satisfying.
1833             const bool good_kill   = !created_friendly && gives_xp
1834                 || (is_evil_god(you.religion) && !mons->is_summoned()
1835                     && !fake_abjuration
1836                     && (targ_holy == MH_NATURAL || targ_holy == MH_HOLY));
1837
1838             if (death_message)
1839             {
1840                 if (killer == KILL_YOU_CONF
1841                     && (anon || !invalid_monster_index(killer_index)))
1842                 {
1843                     mprf(MSGCH_MONSTER_DAMAGE, MDAM_DEAD, "%s is %s!",
1844                          mons->name(DESC_THE).c_str(),
1845                          exploded                        ? "blown up" :
1846                          _wounded_damaged(targ_holy)     ? "destroyed"
1847                                                          : "killed");
1848                 }
1849                 else
1850                 {
1851                     mprf(MSGCH_MONSTER_DAMAGE, MDAM_DEAD, "You %s %s!",
1852                          exploded                        ? "blow up" :
1853                          _wounded_damaged(targ_holy)     ? "destroy"
1854                                                          : "kill",
1855                          mons->name(DESC_THE).c_str());
1856                 }
1857
1858                 if ((created_friendly || was_neutral) && gives_xp)
1859                     mpr("That felt strangely unrewarding.");
1860             }
1861
1862             // Killing triggers hints mode lesson.
1863             if (gives_xp)
1864                 _hints_inspect_kill();
1865
1866             // Prevent summoned creatures from being good kills.
1867             if (bad_kill || good_kill)
1868             {
1869                 if (targ_holy == MH_NATURAL)
1870                 {
1871                     did_god_conduct(DID_KILL_LIVING,
1872                                     mons->hit_dice, true, mons);
1873
1874                     // TSO hates natural evil and unholy beings.
1875                     if (mons->is_unholy())
1876                     {
1877                         did_god_conduct(DID_KILL_NATURAL_UNHOLY,
1878                                         mons->hit_dice, true, mons);
1879                     }
1880                     else if (mons->is_evil())
1881                     {
1882                         did_god_conduct(DID_KILL_NATURAL_EVIL,
1883                                         mons->hit_dice, true, mons);
1884                     }
1885                 }
1886                 else if (targ_holy == MH_UNDEAD)
1887                 {
1888                     did_god_conduct(DID_KILL_UNDEAD,
1889                                     mons->hit_dice, true, mons);
1890                 }
1891                 else if (targ_holy == MH_DEMONIC)
1892                 {
1893                     did_god_conduct(DID_KILL_DEMON,
1894                                     mons->hit_dice, true, mons);
1895                 }
1896
1897                 // Zin hates unclean and chaotic beings.
1898                 if (mons->is_unclean())
1899                 {
1900                     did_god_conduct(DID_KILL_UNCLEAN,
1901                                     mons->hit_dice, true, mons);
1902                 }
1903                 else if (mons->is_chaotic())
1904                 {
1905                     did_god_conduct(DID_KILL_CHAOTIC,
1906                                     mons->hit_dice, true, mons);
1907                 }
1908
1909                 // jmf: Trog hates wizards.
1910                 if (mons->is_actual_spellcaster())
1911                 {
1912                     did_god_conduct(DID_KILL_WIZARD,
1913                                     mons->hit_dice, true, mons);
1914                 }
1915
1916                 // Beogh hates priests of other gods.
1917                 if (mons->is_priest())
1918                 {
1919                     did_god_conduct(DID_KILL_PRIEST,
1920                                     mons->hit_dice, true, mons);
1921                 }
1922
1923                 if (mons_is_slime(mons))
1924                 {
1925                     did_god_conduct(DID_KILL_SLIME, mons->hit_dice,
1926                                     true, mons);
1927                 }
1928
1929                 if (fedhas_protects(mons))
1930                 {
1931                     did_god_conduct(DID_KILL_PLANT, mons->hit_dice,
1932                                     true, mons);
1933                 }
1934
1935                 // Cheibriados hates fast monsters.
1936                 if (cheibriados_thinks_mons_is_fast(mons)
1937                     && !mons->cannot_move())
1938                 {
1939                     did_god_conduct(DID_KILL_FAST, mons->hit_dice,
1940                                     true, mons);
1941                 }
1942
1943                 // Yredelemnul hates artificial beings.
1944                 if (mons->is_artificial())
1945                 {
1946                     did_god_conduct(DID_KILL_ARTIFICIAL, mons->hit_dice,
1947                                     true, mons);
1948                 }
1949
1950                 // Holy kills are always noticed.
1951                 if (mons->is_holy())
1952                 {
1953                     did_god_conduct(DID_KILL_HOLY, mons->hit_dice,
1954                                     true, mons);
1955                 }
1956             }
1957
1958             // Divine health and mana restoration doesn't happen when
1959             // killing born-friendly monsters.
1960             if (good_kill
1961                 && (you.religion == GOD_MAKHLEB
1962                     || you.religion == GOD_SHINING_ONE
1963                        && (mons->is_evil() || mons->is_unholy()))
1964                 && !mons_is_object(mons->type)
1965                 && !player_under_penance()
1966                 && random2(you.piety) >= piety_breakpoint(0)
1967                 && !you.duration[DUR_DEATHS_DOOR])
1968             {
1969                 if (you.hp < you.hp_max)
1970                 {
1971                     int heal = (you.religion == GOD_MAKHLEB) ?
1972                                 mons->hit_dice + random2(mons->hit_dice) :
1973                                 random2(1 + 2 * mons->hit_dice);
1974                     if (heal > 0)
1975                         mprf("You feel a little better.");
1976                     inc_hp(heal);
1977                 }
1978             }
1979
1980             if (good_kill
1981                 && (you.religion == GOD_VEHUMET
1982                     || you.religion == GOD_SHINING_ONE
1983                        && (mons->is_evil() || mons->is_unholy()))
1984                 && !mons_is_object(mons->type)
1985                 && !player_under_penance()
1986                 && random2(you.piety) >= piety_breakpoint(0))
1987             {
1988                 if (you.species != SP_DJINNI ?
1989                         you.magic_points < you.max_magic_points :
1990                         you.hp < you.hp_max)
1991                 {
1992                     int mana = (you.religion == GOD_VEHUMET) ?
1993                             1 + random2(mons->hit_dice / 2) :
1994                             random2(2 + mons->hit_dice / 3);
1995                     if (mana > 0)
1996                     {
1997                         mpr("You feel your power returning.");
1998                         inc_mp(mana);
1999                     }
2000                 }
2001             }
2002
2003             // Randomly bless a follower.
2004             if (!created_friendly
2005                 && gives_xp
2006                 && (you.religion == GOD_BEOGH
2007                     && random2(you.piety) >= piety_breakpoint(2))
2008                 && !mons_is_object(mons->type)
2009                 && !player_under_penance())
2010             {
2011                 bless_follower();
2012             }
2013
2014             if (you.duration[DUR_DEATH_CHANNEL] && gives_xp)
2015                 _make_spectral_thing(mons, !death_message);
2016             break;
2017         }
2018
2019         case KILL_MON:          // Monster kills in combat.
2020         case KILL_MON_MISSILE:  // Monster kills by missile or beam.
2021             if (death_message)
2022             {
2023                 const char* msg =
2024                     exploded                     ? " is blown up!" :
2025                     _wounded_damaged(targ_holy)  ? " is destroyed!"
2026                                                  : " dies!";
2027                 simple_monster_message(mons, msg, MSGCH_MONSTER_DAMAGE,
2028                                        MDAM_DEAD);
2029             }
2030
2031             if (crawl_state.game_is_arena())
2032                 break;
2033
2034             // No piety loss if god gifts killed by other monsters.
2035             // Also, dancing weapons aren't really friendlies.
2036             if (mons->friendly() && !mons_is_object(mons->type))
2037             {
2038                 const int mon_intel = mons_class_intel(mons->type) - I_ANIMAL;
2039
2040                 did_god_conduct(mon_intel > 0 ? DID_SOULED_FRIEND_DIED
2041                                               : DID_FRIEND_DIED,
2042                                 1 + (mons->hit_dice / 2),
2043                                 true, mons);
2044             }
2045
2046             if (pet_kill && fedhas_protects(mons))
2047             {
2048                 did_god_conduct(DID_PLANT_KILLED_BY_SERVANT, 1 + (mons->hit_dice / 2),
2049                                 true, mons);
2050             }
2051
2052             // Trying to prevent summoning abuse here, so we're trying to
2053             // prevent summoned creatures from being done_good kills.  Only
2054             // affects creatures which were friendly when summoned.
2055             if (!created_friendly && gives_xp && pet_kill
2056                 && (anon || !invalid_monster_index(killer_index)))
2057             {
2058                 bool notice = false;
2059
2060                 monster* killer_mon = NULL;
2061                 if (!anon)
2062                 {
2063                     killer_mon = &menv[killer_index];
2064
2065                     // If the killer is already dead, treat it like an
2066                     // anonymous monster.
2067                     if (killer_mon->type == MONS_NO_MONSTER)
2068                         anon = true;
2069                 }
2070
2071                 const mon_holy_type killer_holy =
2072                     anon ? MH_NATURAL : killer_mon->holiness();
2073
2074                 if (you.religion == GOD_ZIN
2075                     || you.religion == GOD_SHINING_ONE
2076                     || you.religion == GOD_YREDELEMNUL
2077                     || you.religion == GOD_KIKUBAAQUDGHA
2078                     || you.religion == GOD_MAKHLEB
2079                     || you.religion == GOD_LUGONU
2080                     || !anon && mons_is_god_gift(killer_mon))
2081                 {
2082                     if (killer_holy == MH_UNDEAD)
2083                     {
2084                         const bool confused =
2085                             anon ? false : !killer_mon->friendly();
2086
2087                         // Yes, these are hacks, but they make sure that
2088                         // confused monsters doing kills are not
2089                         // referred to as "slaves", and I think it's
2090                         // okay that e.g. Yredelemnul ignores kills done
2091                         // by confused monsters as opposed to enslaved
2092                         // or friendly ones. (jpeg)
2093                         if (targ_holy == MH_NATURAL)
2094                         {
2095                             notice |= did_god_conduct(
2096                                           !confused ? DID_LIVING_KILLED_BY_UNDEAD_SLAVE :
2097                                                       DID_LIVING_KILLED_BY_SERVANT,
2098                                           mons->hit_dice);
2099                         }
2100                         else if (targ_holy == MH_UNDEAD)
2101                         {
2102                             notice |= did_god_conduct(
2103                                           !confused ? DID_UNDEAD_KILLED_BY_UNDEAD_SLAVE :
2104                                                       DID_UNDEAD_KILLED_BY_SERVANT,
2105                                           mons->hit_dice);
2106                         }
2107                         else if (targ_holy == MH_DEMONIC)
2108                         {
2109                             notice |= did_god_conduct(
2110                                           !confused ? DID_DEMON_KILLED_BY_UNDEAD_SLAVE :
2111                                                       DID_DEMON_KILLED_BY_SERVANT,
2112                                           mons->hit_dice);
2113                         }
2114
2115                         if (mons->is_unclean())
2116                         {
2117                             notice |= did_god_conduct(DID_UNCLEAN_KILLED_BY_SERVANT,
2118                                                       mons->hit_dice);
2119                         }
2120
2121                         if (mons->is_chaotic())
2122                         {
2123                             notice |= did_god_conduct(DID_CHAOTIC_KILLED_BY_SERVANT,
2124                                                       mons->hit_dice);
2125                         }
2126
2127                         if (mons->is_artificial())
2128                         {
2129                             notice |= did_god_conduct(
2130                                           !confused ? DID_ARTIFICIAL_KILLED_BY_UNDEAD_SLAVE :
2131                                                       DID_ARTIFICIAL_KILLED_BY_SERVANT,
2132                                           mons->hit_dice);
2133                         }
2134                     }
2135                     // Yes, we are splitting undead pets from the others
2136                     // as a way to focus Necromancy vs. Summoning
2137                     // (ignoring Haunt here)... at least we're being
2138                     // nice and putting the natural creature summons
2139                     // together with the demonic ones.  Note that
2140                     // Vehumet gets a free pass here since those
2141                     // followers are assumed to come from summoning
2142                     // spells...  the others are from invocations (TSO,
2143                     // Makhleb, Kiku). - bwr
2144                     else if (targ_holy == MH_NATURAL)
2145                     {
2146                         notice |= did_god_conduct(DID_LIVING_KILLED_BY_SERVANT,
2147                                                   mons->hit_dice);
2148
2149                         if (mons->is_unholy())
2150                         {
2151                             notice |= did_god_conduct(
2152                                           DID_NATURAL_UNHOLY_KILLED_BY_SERVANT,
2153                                           mons->hit_dice);
2154                         }
2155
2156                         if (mons->is_evil())
2157                         {
2158                             notice |= did_god_conduct(
2159                                           DID_NATURAL_EVIL_KILLED_BY_SERVANT,
2160                                           mons->hit_dice);
2161                         }
2162                     }
2163                     else if (targ_holy == MH_UNDEAD)
2164                     {
2165                         notice |= did_god_conduct(DID_UNDEAD_KILLED_BY_SERVANT,
2166                                                   mons->hit_dice);
2167                     }
2168                     else if (targ_holy == MH_DEMONIC)
2169                     {
2170                         notice |= did_god_conduct(DID_DEMON_KILLED_BY_SERVANT,
2171                                                   mons->hit_dice);
2172                     }
2173
2174                     if (mons->is_unclean())
2175                     {
2176                         notice |= did_god_conduct(DID_UNCLEAN_KILLED_BY_SERVANT,
2177                                                   mons->hit_dice);
2178                     }
2179
2180                     if (mons->is_chaotic())
2181                     {
2182                         notice |= did_god_conduct(DID_CHAOTIC_KILLED_BY_SERVANT,
2183                                                   mons->hit_dice);
2184                     }
2185
2186                     if (mons->is_artificial())
2187                     {
2188                         notice |= did_god_conduct(DID_ARTIFICIAL_KILLED_BY_SERVANT,
2189                                                   mons->hit_dice);
2190                     }
2191                 }
2192
2193                 // Holy kills are always noticed.
2194                 if (mons->is_holy())
2195                 {
2196                     if (killer_holy == MH_UNDEAD)
2197                     {
2198                         const bool confused =
2199                             anon ? false : !killer_mon->friendly();
2200
2201                         // Yes, this is a hack, but it makes sure that
2202                         // confused monsters doing kills are not
2203                         // referred to as "slaves", and I think it's
2204                         // okay that Yredelemnul ignores kills done by
2205                         // confused monsters as opposed to enslaved or
2206                         // friendly ones. (jpeg)
2207                         notice |= did_god_conduct(
2208                                       !confused ? DID_HOLY_KILLED_BY_UNDEAD_SLAVE :
2209                                                   DID_HOLY_KILLED_BY_SERVANT,
2210                                       mons->hit_dice);
2211                     }
2212                     else
2213                         notice |= did_god_conduct(DID_HOLY_KILLED_BY_SERVANT,
2214                                                   mons->hit_dice);
2215                 }
2216
2217                 if (you.religion == GOD_SHINING_ONE
2218                     && (mons->is_evil() || mons->is_unholy())
2219                     && !player_under_penance()
2220                     && random2(you.piety) >= piety_breakpoint(0)
2221                     && !invalid_monster_index(killer_index))
2222                 {
2223                     // Randomly bless the follower who killed.
2224                     if (!one_chance_in(3) && killer_mon->alive()
2225                         && bless_follower(killer_mon))
2226                     {
2227                         break;
2228                     }
2229
2230                     if (killer_mon->alive()
2231                         && killer_mon->hit_points < killer_mon->max_hit_points)
2232                     {
2233                         simple_monster_message(killer_mon,
2234                                                " looks invigorated.");
2235                         killer_mon->heal(1 + random2(mons->hit_dice / 4));
2236                     }
2237                 }
2238
2239                 if (you.religion == GOD_BEOGH
2240                     && random2(you.piety) >= piety_breakpoint(2)
2241                     && !player_under_penance()
2242                     && !one_chance_in(3)
2243                     && !invalid_monster_index(killer_index))
2244                 {
2245                     // Randomly bless the follower who killed.
2246                     bless_follower(killer_mon);
2247                 }
2248
2249                 if (you.duration[DUR_DEATH_CHANNEL] && gives_xp && was_visible)
2250                     _make_spectral_thing(mons, !death_message);
2251             }
2252             break;
2253
2254         // Monster killed by trap/inanimate thing/itself/poison not from you.
2255         case KILL_MISC:
2256         case KILL_MISCAST:
2257             if (death_message)
2258             {
2259                 if (fake_abjuration)
2260                 {
2261                     if (mons_genus(mons->type) == MONS_ADDER)
2262                     {
2263                         // Sticks to Snake
2264                         simple_monster_message(mons, " withers and dies!",
2265                             MSGCH_MONSTER_DAMAGE, MDAM_DEAD);
2266                     }
2267                     else if (mons->type == MONS_SPECTRAL_THING)
2268                     {
2269                         // Death Channel
2270                         simple_monster_message(mons, " fades into mist!");
2271                     }
2272                     else
2273                     {
2274                         string msg = " " + summoned_poof_msg(mons) + "!";
2275                         simple_monster_message(mons, msg.c_str());
2276                     }
2277                 }
2278                 else
2279                 {
2280                     const char* msg =
2281                         exploded                     ? " is blown up!" :
2282                         _wounded_damaged(targ_holy)  ? " is destroyed!"
2283                                                      : " dies!";
2284                     simple_monster_message(mons, msg, MSGCH_MONSTER_DAMAGE,
2285                                            MDAM_DEAD);
2286                 }
2287             }
2288             break;
2289
2290         case KILL_BANISHED:
2291             // Monster doesn't die, just goes back to wherever it came from.
2292             // This must only be called by monsters running out of time (or
2293             // abjuration), because it uses the beam variables!  Or does it???
2294             // Pacified monsters leave the level when this happens.
2295
2296             // KILL_RESET monsters no longer lose their whole inventory, only
2297             // items they were generated with.
2298             if (mons->pacified() || !mons->needs_abyss_transit())
2299             {
2300                 // A banished monster that doesn't go on the transit list
2301                 // loses all items.
2302                 if (!mons->is_summoned())
2303                     drop_items = false;
2304                 break;
2305             }
2306
2307             // Monster goes to the Abyss.
2308             mons->flags |= MF_BANISHED;
2309             {
2310                 unwind_var<int> dt(mons->damage_total, 0);
2311                 unwind_var<int> df(mons->damage_friendly, 0);
2312                 mons->set_transit(level_id(BRANCH_ABYSS));
2313             }
2314             set_unique_annotation(mons, BRANCH_ABYSS);
2315             in_transit = true;
2316             drop_items = false;
2317             mons->firing_pos.reset();
2318             // Make monster stop patrolling and/or travelling.
2319             mons->patrol_point.reset();
2320             mons->travel_path.clear();
2321             mons->travel_target = MTRAV_NONE;
2322             break;
2323
2324         case KILL_RESET:
2325             drop_items = false;
2326             break;
2327
2328         case KILL_TIMEOUT:
2329         case KILL_UNSUMMONED:
2330         case KILL_DISMISSED:
2331             break;
2332
2333         default:
2334             drop_items = false;
2335             break;
2336     }
2337
2338     // Make sure Boris has a foe to address.
2339     if (mons->foe == MHITNOT)
2340     {
2341         if (!mons->wont_attack() && !crawl_state.game_is_arena())
2342             mons->foe = MHITYOU;
2343         else if (!invalid_monster_index(killer_index))
2344             mons->foe = killer_index;
2345     }
2346
2347     // Make sure that the monster looks dead.
2348     if (mons->alive() && (!summoned || duration > 0))
2349     {
2350         dprf("Granting xp for non-damage kill.");
2351         if (YOU_KILL(killer))
2352             mons->damage_friendly += mons->hit_points * 2;
2353         else if (pet_kill)
2354             mons->damage_friendly += mons->hit_points;
2355         mons->damage_total += mons->hit_points;
2356
2357         if (!in_transit) // banishment only
2358             mons->hit_points = -1;
2359     }
2360
2361     if (!silent && !wizard && you.see_cell(mons->pos()))
2362     {
2363         // Make sure that the monster looks dead.
2364         if (mons->alive() && !in_transit && (!summoned || duration > 0))
2365             mons->hit_points = -1;
2366         // Hack: with cleanup_dead=false, a tentacle [segment] of a dead
2367         // [malign] kraken has no valid head reference.
2368         if (!mons_is_tentacle_or_tentacle_segment(mons->type))
2369             mons_speaks(mons);
2370     }
2371
2372     if (mons->type == MONS_BORIS && !in_transit && !mons->pacified())
2373     {
2374         // XXX: Actual blood curse effect for Boris? - bwr
2375
2376         // Now that Boris is dead, he's a valid target for monster
2377         // creation again. - bwr
2378         you.unique_creatures.set(mons->type, false);
2379         // And his vault can be placed again.
2380         you.uniq_map_names.erase("uniq_boris");
2381     }
2382     if (mons->type == MONS_JORY && !in_transit)
2383         blood_spray(mons->pos(), MONS_JORY, 50);
2384     else if (mons_is_kirke(mons)
2385              && !in_transit
2386              && !testbits(mons->flags, MF_WAS_NEUTRAL))
2387     {
2388         hogs_to_humans();
2389     }
2390     else if (mons_is_pikel(mons))
2391     {
2392         // His slaves don't care if he's dead or not, just whether or not
2393         // he goes away.
2394         pikel_band_neutralise();
2395     }
2396     else if (mons->is_named() && mons->friendly() && killer != KILL_RESET)
2397         take_note(Note(NOTE_ALLY_DEATH, 0, 0, mons->mname.c_str()));
2398     else if (mons_is_tentacle_head(mons_base_type(mons)))
2399     {
2400         if (_destroy_tentacles(mons)
2401             && !in_transit
2402             && you.see_cell(mons->pos()))
2403         {
2404             if (mons_base_type(mons) == MONS_KRAKEN)
2405                 mpr("The dead kraken's tentacles slide back into the water.");
2406             else if (mons->type == MONS_TENTACLED_STARSPAWN)
2407                 mpr("The starspawn's tentacles wither and die.");
2408         }
2409     }
2410     else if (mons_is_tentacle_or_tentacle_segment(mons->type)
2411              && killer != KILL_MISC
2412                  || mons->type == MONS_ELDRITCH_TENTACLE)
2413     {
2414         _destroy_tentacle(mons);
2415     }
2416     else if (mons->type == MONS_ELDRITCH_TENTACLE_SEGMENT
2417              && killer != KILL_MISC)
2418     {
2419         if (!invalid_monster_index(mons->number)
2420              && mons_base_type(&menv[mons->number]) == MONS_ELDRITCH_TENTACLE
2421              && menv[mons->number].alive())
2422         {
2423             monster_die(&menv[mons->number], killer, killer_index, silent,
2424                         wizard, fake);
2425         }
2426     }
2427     else if (mons_is_elven_twin(mons) && mons_near(mons))
2428         elven_twin_died(mons, in_transit, killer, killer_index);
2429     else if (mons_is_shedu(mons))
2430     {
2431         if (was_banished) // Don't try resurrecting them.
2432             mons->number = 0;
2433         else
2434             shedu_do_resurrection(mons);
2435     }
2436     else if (mons_is_phoenix(mons))
2437     {
2438         if (!was_banished)
2439             phoenix_died(mons);
2440     }
2441     else if (mons->type == MONS_VAULT_WARDEN)
2442         timeout_terrain_changes(0, true);
2443     else if (mons->type == MONS_FLAYED_GHOST)
2444         end_flayed_effect(mons);
2445     else if (mons->type == MONS_PLAGUE_SHAMBLER && !was_banished
2446              && !mons->pacified() && (!summoned || duration > 0) && !wizard)
2447     {
2448         if (you.can_see(mons))
2449         {
2450             mprf(MSGCH_WARN, "Miasma billows from the fallen %s!",
2451                  mons->name(DESC_PLAIN).c_str());
2452         }
2453
2454         map_cloud_spreader_marker *marker =
2455             new map_cloud_spreader_marker(mons->pos(), CLOUD_MIASMA, 10,
2456                                           18 + random2(7), 4, 8, mons);
2457         // Start the cloud at radius 1, regardless of the speed of the killing blow
2458         marker->speed_increment -= you.time_taken;
2459         env.markers.add(marker);
2460         env.markers.clear_need_activate();
2461     }
2462     else if (mons_is_mimic(mons->type))
2463         drop_items = false;
2464     else if (!mons->is_summoned())
2465     {
2466         if (mons_genus(mons->type) == MONS_MUMMY)
2467             _mummy_curse(mons, killer, killer_index);
2468     }
2469
2470     if (mons->mons_species() == MONS_BALLISTOMYCETE)
2471     {
2472         activate_ballistomycetes(mons, mons->pos(),
2473                                  YOU_KILL(killer) || pet_kill);
2474     }
2475
2476     if (!wizard && !submerged && !was_banished)
2477     {
2478         _monster_die_cloud(mons, !mons_reset && !fake_abjuration && !unsummoned
2479                                  && !timeout, silent, summoned);
2480     }
2481
2482     int corpse = -1;
2483     if (!mons_reset && !summoned && !fake_abjuration && !unsummoned
2484         && !timeout && !was_banished)
2485     {
2486         // Have to add case for disintegration effect here? {dlb}
2487         int corpse2 = -1;
2488
2489         if (mons->type == MONS_SPRIGGAN_RIDER)
2490         {
2491             corpse2 = mounted_kill(mons, MONS_FIREFLY, killer, killer_index);
2492             mons->type = MONS_SPRIGGAN;
2493         }
2494         corpse = place_monster_corpse(mons, silent);
2495         if (corpse == -1)
2496             corpse = corpse2;
2497     }
2498
2499     if ((killer == KILL_YOU
2500          || killer == KILL_YOU_MISSILE
2501          || killer == KILL_YOU_CONF
2502          || pet_kill)
2503              && corpse >= 0 && player_mutation_level(MUT_POWERED_BY_DEATH))
2504     {
2505         const int pbd_dur = player_mutation_level(MUT_POWERED_BY_DEATH) * 8
2506                             + roll_dice(2, 8);
2507         if (pbd_dur > you.duration[DUR_POWERED_BY_DEATH])
2508             you.set_duration(DUR_POWERED_BY_DEATH, pbd_dur);
2509     }
2510
2511     unsigned int player_exp = 0, monster_exp = 0;
2512     if (!mons_reset && !fake_abjuration && !timeout && !unsummoned)
2513     {
2514         player_exp = _calc_player_experience(mons);
2515         monster_exp = _calc_monster_experience(mons, killer, killer_index);
2516     }
2517
2518     if (!mons_reset && !fake_abjuration && !crawl_state.game_is_arena()
2519         && !unsummoned && !timeout && !in_transit)
2520     {
2521         you.kills->record_kill(mons, killer, pet_kill);
2522     }
2523
2524     if (fake)
2525     {
2526         if (corpse != -1 && _reaping(mons))
2527             corpse = -1;
2528
2529         _give_experience(player_exp, monster_exp, killer, killer_index,
2530                          pet_kill, was_visible);
2531         crawl_state.dec_mon_acting(mons);
2532
2533         return corpse;
2534     }
2535
2536     mons_remove_from_grid(mons);
2537     _fire_monster_death_event(mons, killer, killer_index, false);
2538
2539     if (crawl_state.game_is_arena())
2540         arena_monster_died(mons, killer, killer_index, silent, corpse);
2541
2542     // Monsters haloes should be removed when they die.
2543     if (mons->holiness() == MH_HOLY)
2544         invalidate_agrid();
2545     // Likewise silence and umbras
2546     if (mons->type == MONS_SILENT_SPECTRE
2547         || mons->type == MONS_PROFANE_SERVITOR
2548         || mons->type == MONS_MOTH_OF_SUPPRESSION
2549         || mons->type == MONS_LOST_SOUL)
2550     {
2551         invalidate_agrid();
2552     }
2553
2554     // Done before items are dropped so that we can clone them
2555     if (soul_aura(mons->pos()) && mons->holiness() == MH_NATURAL
2556         && killer != KILL_RESET
2557         && killer != KILL_DISMISSED
2558         && killer != KILL_BANISHED)
2559     {
2560         lost_soul_spectralize(mons);
2561     }
2562
2563     const coord_def mwhere = mons->pos();
2564     if (drop_items)
2565         monster_drop_things(mons, YOU_KILL(killer) || pet_kill);
2566     else
2567     {
2568         // Destroy the items belonging to MF_HARD_RESET monsters so they
2569         // don't clutter up mitm[].
2570         mons->destroy_inventory();
2571     }
2572
2573     if (!silent && !wizard && !mons_reset && corpse != -1
2574         && !fake_abjuration
2575         && !timeout
2576         && !unsummoned
2577         && !(mons->flags & MF_KNOWN_SHIFTER)
2578         && mons->is_shapeshifter())
2579     {
2580         simple_monster_message(mons, "'s shape twists and changes as "
2581                                "it dies.");
2582     }
2583
2584     if (mons->is_divine_companion()
2585         && killer != KILL_RESET
2586         && !(mons->flags & MF_BANISHED))
2587     {
2588         remove_companion(mons);
2589     }
2590
2591     // If we kill an invisible monster reactivate autopickup.
2592     // We need to check for actual invisibility rather than whether we
2593     // can see the monster. There are several edge cases where a monster
2594     // is visible to the player but we still need to turn autopickup
2595     // back on, such as TSO's halo or sticky flame. (jpeg)
2596     if (mons_near(mons) && mons->has_ench(ENCH_INVIS))
2597         autotoggle_autopickup(false);
2598
2599     if (corpse != -1 && _reaping(mons))
2600         corpse = -1;
2601
2602     crawl_state.dec_mon_acting(mons);
2603     monster_cleanup(mons);
2604
2605     // Force redraw for monsters that die.
2606     if (in_bounds(mwhere) && you.see_cell(mwhere))
2607     {
2608         view_update_at(mwhere);
2609         update_screen();
2610     }
2611
2612     if (gives_xp)
2613     {
2614         _give_experience(player_exp, monster_exp, killer, killer_index,
2615                          pet_kill, was_visible);
2616     }
2617
2618     return corpse;
2619 }
2620
2621 // Clean up after a dead monster.
2622 void monster_cleanup(monster* mons)
2623 {
2624     crawl_state.mon_gone(mons);
2625
2626     if (mons->has_ench(ENCH_AWAKEN_FOREST))
2627     {
2628         forest_message(mons->pos(), "The forest abruptly stops moving.");
2629         env.forest_awoken_until = 0;
2630     }
2631
2632     // May have been constricting something. No message because that depends
2633     // on the order in which things are cleaned up: If the constrictee is
2634     // cleaned up first, we wouldn't get a message anyway.
2635     mons->stop_constricting_all(false, true);
2636
2637     if (mons_is_tentacle_head(mons_base_type(mons)))
2638         _destroy_tentacles(mons);
2639
2640     env.mid_cache.erase(mons->mid);
2641     unsigned int monster_killed = mons->mindex();
2642     mons->reset();
2643
2644     for (monster_iterator mi; mi; ++mi)
2645         if (mi->foe == monster_killed)
2646             mi->foe = MHITNOT;
2647
2648     if (you.pet_target == monster_killed)
2649         you.pet_target = MHITNOT;
2650 }
2651
2652 int mounted_kill(monster* daddy, monster_type mc, killer_type killer,
2653                 int killer_index)
2654 {
2655     monster mon;
2656     mon.type = mc;
2657     mon.moveto(daddy->pos());
2658     define_monster(&mon);
2659     mon.flags = daddy->flags;
2660     mon.attitude = daddy->attitude;
2661     mon.damage_friendly = daddy->damage_friendly;
2662     mon.damage_total = daddy->damage_total;
2663     // Keep the rider's name, if it had one (Mercenary card).
2664     if (!daddy->mname.empty() && mon.type == MONS_SPRIGGAN)
2665         mon.mname = daddy->mname;
2666     if (daddy->props.exists("reaping_damage"))
2667     {
2668         dprf("Mounted kill: marking the other monster as reaped as well.");
2669         mon.props["reaping_damage"].get_int() = daddy->props["reaping_damage"].get_int();
2670         mon.props["reaper"].get_int() = daddy->props["reaper"].get_int();
2671     }
2672
2673     return monster_die(&mon, killer, killer_index, false, false, true);
2674 }
2675
2676 // If you're invis and throw/zap whatever, alerts menv to your position.
2677 void alert_nearby_monsters(void)
2678 {
2679     // Judging from the above comment, this function isn't
2680     // intended to wake up monsters, so we're only going to
2681     // alert monsters that aren't sleeping.  For cases where an
2682     // event should wake up monsters and alert them, I'd suggest
2683     // calling noisy() before calling this function. - bwr
2684     for (monster_iterator mi(you.get_los()); mi; ++mi)
2685         if (!mi->asleep())
2686              behaviour_event(*mi, ME_ALERT, &you);
2687 }
2688
2689 static bool _valid_morph(monster* mons, monster_type new_mclass)
2690 {
2691     const dungeon_feature_type current_tile = grd(mons->pos());
2692
2693     // 'morph targets are _always_ "base" classes, not derived ones.
2694     new_mclass = mons_species(new_mclass);
2695     monster_type old_mclass = mons_base_type(mons);
2696
2697     // Shapeshifters cannot polymorph into glowing shapeshifters or
2698     // vice versa.
2699     if ((new_mclass == MONS_GLOWING_SHAPESHIFTER
2700              && mons->has_ench(ENCH_SHAPESHIFTER))
2701          || (new_mclass == MONS_SHAPESHIFTER
2702              && mons->has_ench(ENCH_GLOWING_SHAPESHIFTER)))
2703     {
2704         return false;
2705     }
2706
2707     // [ds] Non-base draconians are much more trouble than their HD
2708     // suggests.
2709     if (mons_genus(new_mclass) == MONS_DRACONIAN
2710         && new_mclass != MONS_DRACONIAN
2711         && !player_in_branch(BRANCH_HALL_OF_ZOT)
2712         && !one_chance_in(10))
2713     {
2714         return false;
2715     }
2716
2717     // Various inappropriate polymorph targets.
2718     if (mons_class_holiness(new_mclass) != mons_class_holiness(old_mclass)
2719         || mons_class_flag(new_mclass, M_UNFINISHED)  // no unfinished monsters
2720         || mons_class_flag(new_mclass, M_CANT_SPAWN)  // no dummy monsters
2721         || mons_class_flag(new_mclass, M_NO_POLY_TO)  // explicitly disallowed
2722         || mons_class_flag(new_mclass, M_UNIQUE)      // no uniques
2723         || mons_class_flag(new_mclass, M_NO_EXP_GAIN) // not helpless
2724         || new_mclass == mons_species(old_mclass)  // must be different
2725         || new_mclass == MONS_PROGRAM_BUG
2726
2727         // They act as separate polymorph classes on their own.
2728         || mons_class_is_zombified(new_mclass)
2729         || mons_is_zombified(mons) && !mons_zombie_size(new_mclass)
2730         // Currently unused (no zombie shapeshifters, no polymorph).
2731         || mons->type == MONS_SKELETON && !mons_skeleton(new_mclass)
2732         || mons->type == MONS_ZOMBIE && !mons_zombifiable(new_mclass)
2733
2734         // These require manual setting of the ghost demon struct to
2735         // indicate their characteristics, which we currently aren't
2736         // smart enough to handle.
2737         || mons_is_ghost_demon(new_mclass)
2738
2739         // Other poly-unsuitable things.
2740         || mons_is_statue(new_mclass)
2741         || mons_is_projectile(new_mclass)
2742         || mons_is_tentacle_or_tentacle_segment(new_mclass)
2743
2744         // The spell on Prince Ribbit can't be broken so easily.
2745         || (new_mclass == MONS_HUMAN
2746             && (mons->type == MONS_PRINCE_RIBBIT
2747                 || mons->mname == "Prince Ribbit")))
2748     {
2749         return false;
2750     }
2751
2752     // Determine if the monster is happy on current tile.
2753     return monster_habitable_grid(new_mclass, current_tile);
2754 }
2755
2756 static bool _is_poly_power_unsuitable(poly_power_type power,
2757                                        int src_pow, int tgt_pow, int relax)
2758 {
2759     switch (power)
2760     {
2761     case PPT_LESS:
2762         return (tgt_pow > src_pow - 3 + (relax * 3) / 2)
2763                 || (power == PPT_LESS && (tgt_pow < src_pow - (relax / 2)));
2764     case PPT_MORE:
2765         return (tgt_pow < src_pow + 2 - relax)
2766                 || (power == PPT_MORE && (tgt_pow > src_pow + relax));
2767     default:
2768     case PPT_SAME:
2769         return (tgt_pow < src_pow - relax)
2770                 || (tgt_pow > src_pow + (relax * 3) / 2);
2771     }
2772 }
2773
2774 static bool _jiyva_slime_target(monster_type targetc)
2775 {
2776     return (you.religion == GOD_JIYVA
2777             && (targetc == MONS_DEATH_OOZE
2778                || targetc == MONS_OOZE
2779                || targetc == MONS_JELLY
2780                || targetc == MONS_BROWN_OOZE
2781                || targetc == MONS_SLIME_CREATURE
2782                || targetc == MONS_GIANT_AMOEBA
2783                || targetc == MONS_ACID_BLOB
2784                || targetc == MONS_AZURE_JELLY));
2785
2786 }
2787
2788 void change_monster_type(monster* mons, monster_type targetc)
2789 {
2790     bool could_see     = you.can_see(mons);
2791     bool degenerated = (targetc == MONS_PULSATING_LUMP);
2792     bool slimified = _jiyva_slime_target(targetc);
2793
2794     // Quietly remove the old monster's invisibility before transforming
2795     // it.  If we don't do this, it'll stay invisible even after losing
2796     // the invisibility enchantment below.
2797     mons->del_ench(ENCH_INVIS, false, false);
2798
2799     // Remove replacement tile, since it probably doesn't work for the
2800     // new monster.
2801     mons->props.erase("monster_tile_name");
2802     mons->props.erase("monster_tile");
2803
2804     // Even if the monster transforms from one type that can behold the
2805     // player into a different type which can also behold the player,
2806     // the polymorph disrupts the beholding process.  Do this before
2807     // changing mons->type, since unbeholding can only happen while
2808     // the monster is still a mermaid/siren.
2809     you.remove_beholder(mons);
2810     you.remove_fearmonger(mons);
2811
2812     if (mons_is_tentacle_head(mons_base_type(mons)))
2813         _destroy_tentacles(mons);
2814
2815     // Inform listeners that the original monster is gone.
2816     _fire_monster_death_event(mons, KILL_MISC, NON_MONSTER, true);
2817
2818     // the actual polymorphing:
2819     uint64_t flags =
2820         mons->flags & ~(MF_INTERESTING | MF_SEEN | MF_ATT_CHANGE_ATTEMPT
2821                            | MF_WAS_IN_VIEW | MF_BAND_MEMBER | MF_KNOWN_SHIFTER
2822                            | MF_MELEE_MASK | MF_SPELL_MASK);
2823
2824     string name;
2825
2826     // Preserve the names of uniques and named monsters.
2827     if (mons->type == MONS_ROYAL_JELLY
2828         || mons->mname == "shaped Royal Jelly")
2829     {
2830         name   = "shaped Royal Jelly";
2831         flags |= MF_INTERESTING | MF_NAME_SUFFIX;
2832     }
2833     else if (mons->type == MONS_LERNAEAN_HYDRA
2834              || mons->mname == "shaped Lernaean hydra")
2835     {
2836         name   = "shaped Lernaean hydra";
2837         flags |= MF_INTERESTING | MF_NAME_SUFFIX;
2838     }
2839     else if (mons->mons_species() == MONS_SERPENT_OF_HELL
2840              || mons->mname == "shaped Serpent of Hell")
2841     {
2842         name   = "shaped Serpent of Hell";
2843         flags |= MF_INTERESTING | MF_NAME_SUFFIX;
2844     }
2845     else if (!mons->mname.empty())
2846     {
2847         if (flags & MF_NAME_MASK)
2848         {
2849             // Remove the replacement name from the new monster
2850             flags = flags & ~(MF_NAME_MASK | MF_NAME_DESCRIPTOR
2851                               | MF_NAME_DEFINITE | MF_NAME_SPECIES
2852                               | MF_NAME_ZOMBIE | MF_NAME_NOCORPSE);
2853         }
2854         else
2855             name = mons->mname;
2856     }
2857     else if (mons_is_unique(mons->type))
2858     {
2859         flags |= MF_INTERESTING;
2860
2861         name = mons->name(DESC_PLAIN, true);
2862
2863         // "Blork the orc" and similar.
2864         const size_t the_pos = name.find(" the ");
2865         if (the_pos != string::npos)
2866             name = name.substr(0, the_pos);
2867     }
2868
2869     const monster_type real_targetc =
2870         (mons->has_ench(ENCH_GLOWING_SHAPESHIFTER)) ? MONS_GLOWING_SHAPESHIFTER :
2871         (mons->has_ench(ENCH_SHAPESHIFTER))         ? MONS_SHAPESHIFTER
2872                                                     : targetc;
2873
2874     const god_type god =
2875         (player_will_anger_monster(real_targetc)
2876             || (you.religion == GOD_BEOGH
2877                 && mons_genus(real_targetc) != MONS_ORC)) ? GOD_NO_GOD
2878                                                           : mons->god;
2879
2880     if (god == GOD_NO_GOD)
2881         flags &= ~MF_GOD_GIFT;
2882
2883     const int  old_hp             = mons->hit_points;
2884     const int  old_hp_max         = mons->max_hit_points;
2885     const bool old_mon_caught     = mons->caught();
2886     const char old_ench_countdown = mons->ench_countdown;
2887
2888     // XXX: mons_is_unique should be converted to monster::is_unique, and that
2889     // function should be testing the value of props["original_was_unique"]
2890     // which would make things a lot simpler.
2891     // See also record_monster_defeat.
2892     bool old_mon_unique           = mons_is_unique(mons->type);
2893     if (mons->props.exists("original_was_unique")
2894         && mons->props["original_was_unique"].get_bool())
2895     {
2896         old_mon_unique = true;
2897     }
2898
2899     mon_enchant abj       = mons->get_ench(ENCH_ABJ);
2900     mon_enchant fabj      = mons->get_ench(ENCH_FAKE_ABJURATION);
2901     mon_enchant charm     = mons->get_ench(ENCH_CHARM);
2902     mon_enchant shifter   = mons->get_ench(ENCH_GLOWING_SHAPESHIFTER,
2903                                            ENCH_SHAPESHIFTER);
2904     mon_enchant sub       = mons->get_ench(ENCH_SUBMERGED);
2905     mon_enchant summon    = mons->get_ench(ENCH_SUMMON);
2906     mon_enchant tp        = mons->get_ench(ENCH_TP);
2907
2908     monster_spells spl    = mons->spells;
2909     const bool need_save_spells
2910             = (!name.empty()
2911                && (!mons->can_use_spells() || mons->is_actual_spellcaster())
2912                && !degenerated && !slimified);
2913
2914     // deal with mons_sec
2915     if (mons_is_zombified(mons))
2916         mons->base_monster = targetc;
2917     else
2918     {
2919         mons->type         = targetc;
2920         mons->base_monster = MONS_NO_MONSTER;
2921     }
2922     mons->number       = 0;
2923
2924     // Note: define_monster() will clear out all enchantments! - bwr
2925     define_monster(mons);
2926
2927     mons->mname = name;
2928     mons->props["original_name"] = name;
2929     mons->props["original_was_unique"] = old_mon_unique;
2930     mons->god   = god;
2931     mons->props.erase("dbname");
2932
2933     mons->flags = flags;
2934     // Line above might clear melee and/or spell flags; restore.
2935     mons->bind_melee_flags();
2936     mons->bind_spell_flags();
2937
2938     // Forget various speech/shout Lua functions.
2939     mons->props.erase("speech_prefix");
2940
2941     // Keep spells for named monsters, but don't override innate ones
2942     // for dragons and the like. This means that Sigmund polymorphed
2943     // into a goblin will still cast spells, but if he ends up as a
2944     // swamp drake he'll breathe fumes and, if polymorphed further,
2945     // won't remember his spells anymore.
2946     if (need_save_spells
2947         && (!mons->can_use_spells() || mons->is_actual_spellcaster()))
2948     {
2949         mons->spells = spl;
2950     }
2951
2952     mons->add_ench(abj);
2953     mons->add_ench(fabj);
2954     mons->add_ench(charm);
2955     mons->add_ench(shifter);
2956     mons->add_ench(sub);
2957     mons->add_ench(summon);
2958     mons->add_ench(tp);
2959
2960     // Allows for handling of submerged monsters which polymorph into
2961     // monsters that can't submerge on this square.
2962     if (mons->has_ench(ENCH_SUBMERGED)
2963         && !monster_can_submerge(mons, grd(mons->pos())))
2964     {
2965         mons->del_ench(ENCH_SUBMERGED);
2966     }
2967
2968     mons->ench_countdown = old_ench_countdown;
2969
2970     if (mons_class_flag(mons->type, M_INVIS))
2971         mons->add_ench(ENCH_INVIS);
2972
2973     mons->hit_points = mons->max_hit_points
2974                                 * ((old_hp * 100) / old_hp_max) / 100
2975                                 + random2(mons->max_hit_points);
2976
2977     mons->hit_points = min(mons->max_hit_points, mons->hit_points);
2978
2979     // Don't kill it.
2980     mons->hit_points = max(mons->hit_points, 1);
2981
2982     mons->speed_increment = 67 + random2(6);
2983
2984     monster_drop_things(mons);
2985
2986     // New monster type might be interesting.
2987     mark_interesting_monst(mons);
2988
2989     // If new monster is visible to player, then we've seen it.
2990     if (you.can_see(mons))
2991     {
2992         seen_monster(mons);
2993         // If the player saw both the beginning and end results of a
2994         // shifter changing, then s/he knows it must be a shifter.
2995         if (could_see && shifter.ench != ENCH_NONE)
2996             discover_shifter(mons);
2997     }
2998
2999     if (old_mon_caught)
3000         check_net_will_hold_monster(mons);
3001
3002     // Even if the new form can constrict, it might be with a different
3003     // body part.  Likewise, the new form might be too large for its
3004     // current constrictor.  Rather than trying to handle these as special
3005     // cases, just stop the constriction entirely.  The usual message about
3006     // evaporating and reforming justifies this behaviour.
3007     mons->stop_constricting_all(false);
3008     mons->stop_being_constricted();
3009
3010     mons->check_clinging(false);
3011 }
3012
3013 // If targetc == RANDOM_MONSTER, then relpower indicates the desired
3014 // power of the new monster, relative to the current monster.
3015 // Relaxation still takes effect when needed, no matter what relpower
3016 // says.
3017 bool monster_polymorph(monster* mons, monster_type targetc,
3018                        poly_power_type power,
3019                        bool force_beh)
3020 {
3021     // Don't attempt to polymorph a monster that is busy using the stairs.
3022     if (mons->flags & MF_TAKING_STAIRS)
3023         return false;
3024     ASSERT(!(mons->flags & MF_BANISHED) || player_in_branch(BRANCH_ABYSS));
3025
3026     int source_power, target_power, relax;
3027     int source_tier, target_tier;
3028     int tries = 1000;
3029
3030     // Used to be mons_power, but that just returns hit_dice
3031     // for the monster class.  By using the current hit dice
3032     // the player gets the opportunity to use draining more
3033     // effectively against shapeshifters. - bwr
3034     source_power = mons->hit_dice;
3035     source_tier = mons_demon_tier(mons->type);
3036
3037     // There's not a single valid target on the '&' demon tier, so unless we
3038     // make one, let's ban this outright.
3039     if (source_tier == -1)
3040     {
3041         return simple_monster_message(mons,
3042             "'s appearance momentarily alters.");
3043     }
3044     relax = 1;
3045
3046     if (targetc == RANDOM_MONSTER)
3047     {
3048         do
3049         {
3050             // Pick a monster species that's guaranteed happy at this grid.
3051             targetc = random_monster_at_grid(mons->pos(), true);
3052
3053             target_power = mons_power(targetc);
3054             // Can't compare tiers in valid_morph, since we want to affect only
3055             // random polymorphs, and not absolutely, too.
3056             target_tier = mons_demon_tier(targetc);
3057
3058             if (one_chance_in(200))
3059                 relax++;
3060
3061             if (relax > 50)
3062                 return simple_monster_message(mons, " shudders.");
3063         }
3064         while (tries-- && (!_valid_morph(mons, targetc)
3065                            || source_tier != target_tier && !x_chance_in_y(relax, 200)
3066                            || _is_poly_power_unsuitable(power, source_power,
3067                                                         target_power, relax)));
3068     }
3069
3070     if (!_valid_morph(mons, targetc))
3071         return simple_monster_message(mons, " looks momentarily different.");
3072
3073     bool could_see = you.can_see(mons);
3074     bool need_note = (could_see && MONST_INTERESTING(mons));
3075     string old_name_a = mons->full_name(DESC_A);
3076     string old_name_the = mons->full_name(DESC_THE);
3077     monster_type oldc = mons->type;
3078
3079     change_monster_type(mons, targetc);
3080
3081     bool can_see = you.can_see(mons);
3082
3083     // Messaging
3084     bool player_messaged = true;
3085     if (could_see)
3086     {
3087         string verb = "";
3088         string obj = "";
3089
3090         if (!can_see)
3091             obj = "something you cannot see";
3092         else
3093         {
3094             obj = mons_type_name(targetc, DESC_A);
3095             if (targetc == MONS_PULSATING_LUMP)
3096                 obj += " of flesh";
3097         }
3098
3099         if (oldc == MONS_OGRE && targetc == MONS_TWO_HEADED_OGRE)
3100         {
3101             verb = "grows a second head";
3102             obj = "";
3103         }
3104         else if (mons->is_shapeshifter())
3105             verb = "changes into ";
3106         else if (targetc == MONS_PULSATING_LUMP)
3107             verb = "degenerates into ";
3108         else if (_jiyva_slime_target(targetc))
3109             verb = "quivers uncontrollably and liquefies into ";
3110         else
3111             verb = "evaporates and reforms as ";
3112
3113         mprf("%s %s%s!", old_name_the.c_str(), verb.c_str(), obj.c_str());
3114     }
3115     else if (can_see)
3116     {
3117         mprf("%s appears out of thin air!", mons->name(DESC_A).c_str());
3118         autotoggle_autopickup(false);
3119     }
3120     else
3121         player_messaged = false;
3122
3123     if (need_note || could_see && can_see && MONST_INTERESTING(mons))
3124     {
3125         string new_name = can_see ? mons->full_name(DESC_A)
3126                                   : "something unseen";
3127
3128         take_note(Note(NOTE_POLY_MONSTER, 0, 0, old_name_a.c_str(),
3129                        new_name.c_str()));
3130
3131         if (can_see)
3132             mons->flags |= MF_SEEN;
3133     }
3134
3135     if (!force_beh)
3136         player_angers_monster(mons);
3137
3138     // Xom likes watching monsters being polymorphed.
3139     if (can_see)
3140     {
3141         xom_is_stimulated(mons->is_shapeshifter()               ? 12 :
3142                           power == PPT_LESS || mons->friendly() ? 25 :
3143                           power == PPT_SAME                     ? 50
3144                                                                 : 100);
3145     }
3146
3147     return player_messaged;
3148 }
3149
3150 // If the returned value is mon.pos(), then nothing was found.
3151 static coord_def _random_monster_nearby_habitable_space(const monster& mon,
3152                                                         bool allow_adjacent,
3153                                                         bool respect_los)
3154 {
3155     const bool respect_sanctuary = mon.wont_attack();
3156
3157     coord_def target;
3158     int tries;
3159
3160     for (tries = 0; tries < 150; ++tries)
3161     {
3162         const coord_def delta(random2(13) - 6, random2(13) - 6);
3163
3164         // Check that we don't get something too close to the
3165         // starting point.
3166         if (delta.origin())
3167             continue;
3168
3169         if (delta.rdist() == 1 && !allow_adjacent)
3170             continue;
3171
3172         // Update target.
3173         target = delta + mon.pos();
3174
3175         // Check that the target is valid and survivable.
3176         if (!in_bounds(target))
3177             continue;
3178
3179         if (!monster_habitable_grid(&mon, grd(target)))
3180             continue;
3181
3182         if (respect_sanctuary && is_sanctuary(target))
3183             continue;
3184
3185         if (target == you.pos())
3186             continue;
3187
3188         // Check that we didn't go through clear walls.
3189         if (num_feats_between(mon.pos(), target,
3190                               DNGN_MINSEE,
3191                               DNGN_MAX_NONREACH,
3192                               true, true) > 0)
3193         {
3194             continue;
3195         }
3196
3197         if (respect_los && !mon.see_cell(target))
3198             continue;
3199
3200         // Survived everything, break out (with a good value of target.)
3201         break;
3202     }
3203
3204     if (tries == 150)
3205         target = mon.pos();
3206
3207     return target;
3208 }
3209
3210 bool monster_blink(monster* mons, bool quiet)
3211 {
3212     coord_def near = _random_monster_nearby_habitable_space(*mons, false,
3213                                                             true);
3214
3215     return mons->blink_to(near, quiet);
3216 }
3217
3218 bool mon_can_be_slimified(monster* mons)
3219 {
3220     const mon_holy_type holi = mons->holiness();
3221
3222     return (!(mons->flags & MF_GOD_GIFT)
3223             && !mons->is_insubstantial()
3224             && !mons_is_tentacle_or_tentacle_segment(mons->type)
3225             && (holi == MH_UNDEAD
3226                  || holi == MH_NATURAL && !mons_is_slime(mons))
3227           );
3228 }
3229
3230 void slimify_monster(monster* mon, bool hostile)
3231 {
3232     monster_type target = MONS_JELLY;
3233
3234     const int x = mon->hit_dice + (coinflip() ? 1 : -1) * random2(5);
3235
3236     if (x < 3)
3237         target = MONS_OOZE;
3238     else if (x >= 3 && x < 5)
3239         target = MONS_JELLY;
3240     else if (x >= 5 && x < 7)
3241         target = MONS_BROWN_OOZE;
3242     else if (x >= 7 && x <= 11)
3243     {
3244         if (coinflip())
3245             target = MONS_SLIME_CREATURE;
3246         else
3247             target = MONS_GIANT_AMOEBA;
3248     }
3249     else
3250     {
3251         if (coinflip())
3252             target = MONS_ACID_BLOB;
3253         else
3254             target = MONS_AZURE_JELLY;
3255     }
3256
3257     if (feat_is_water(grd(mon->pos()))) // Pick something amphibious.
3258         target = (x < 7) ? MONS_JELLY : MONS_SLIME_CREATURE;
3259
3260     if (mon->holiness() == MH_UNDEAD)
3261         target = MONS_DEATH_OOZE;
3262
3263     // Bail out if jellies can't live here.
3264     if (!monster_habitable_grid(target, grd(mon->pos())))
3265     {
3266         simple_monster_message(mon, " quivers momentarily.");
3267         return;
3268     }
3269
3270     monster_polymorph(mon, target);
3271
3272     if (!mons_eats_items(mon))
3273         mon->add_ench(ENCH_EAT_ITEMS);
3274
3275     if (!hostile)
3276         mon->attitude = ATT_STRICT_NEUTRAL;
3277     else
3278         mon->attitude = ATT_HOSTILE;
3279
3280     mons_make_god_gift(mon, GOD_JIYVA);
3281
3282     // Don't want shape-shifters to shift into non-slimes.
3283     mon->del_ench(ENCH_GLOWING_SHAPESHIFTER);
3284     mon->del_ench(ENCH_SHAPESHIFTER);
3285
3286     mons_att_changed(mon);
3287 }
3288
3289 void corrode_monster(monster* mons, const actor* evildoer)
3290 {
3291     item_def *has_shield = mons->mslot_item(MSLOT_SHIELD);
3292     item_def *has_armour = mons->mslot_item(MSLOT_ARMOUR);
3293
3294     if (!one_chance_in(3) && (has_shield || has_armour))
3295     {
3296         item_def &thing_chosen = (has_armour ? *has_armour : *has_shield);
3297         corrode_item(thing_chosen, mons);
3298     }
3299     else if (!one_chance_in(3) && !(has_shield || has_armour)
3300              && mons->can_bleed() && !mons->res_acid())
3301     {
3302         mons->add_ench(mon_enchant(ENCH_BLEED, 3, evildoer, (5 + random2(5))*10));
3303
3304         if (you.can_see(mons))
3305         {
3306             mprf("%s writhes in agony as %s flesh is eaten away!",
3307                  mons->name(DESC_THE).c_str(),
3308                  mons->pronoun(PRONOUN_POSSESSIVE).c_str());
3309         }
3310     }
3311 }
3312
3313 // Swap monster to this location.  Player is swapped elsewhere.
3314 bool swap_places(monster* mons, const coord_def &loc)
3315 {
3316     ASSERT(map_bounds(loc));
3317     ASSERT(monster_habitable_grid(mons, grd(loc)));
3318
3319     if (monster_at(loc))
3320     {
3321         mpr("Something prevents you from swapping places.");
3322         return false;
3323     }
3324
3325     mpr("You swap places.");
3326
3327     mgrd(mons->pos()) = NON_MONSTER;
3328
3329     mons->moveto(loc);
3330
3331     mgrd(mons->pos()) = mons->mindex();
3332
3333     return true;
3334 }
3335
3336 // Returns true if this is a valid swap for this monster.  If true, then
3337 // the valid location is set in loc. (Otherwise loc becomes garbage.)
3338 bool swap_check(monster* mons, coord_def &loc, bool quiet)
3339 {
3340     loc = you.pos();
3341
3342     if (you.form == TRAN_TREE)
3343     {
3344         mpr("You can't move.");
3345         return false;
3346     }
3347
3348     // Don't move onto dangerous terrain.
3349     if (is_feat_dangerous(grd(mons->pos())) && !you.can_cling_to(mons->pos()))
3350     {
3351         canned_msg(MSG_UNTHINKING_ACT);
3352         return false;
3353     }
3354
3355     if (mons->is_projectile())
3356     {
3357         if (!quiet)
3358             mpr("It's unwise to walk into this.");
3359         return false;
3360     }
3361
3362     if (mons->caught())
3363     {
3364         if (!quiet)
3365         {
3366             simple_monster_message(mons,
3367                 make_stringf(" is %s!", held_status(mons)).c_str());
3368         }
3369         return false;
3370     }
3371
3372     if (mons->is_constricted())
3373     {
3374         if (!quiet)
3375             simple_monster_message(mons, " is being constricted!");
3376         return false;
3377     }
3378
3379     // First try: move monster onto your position.
3380     bool swap = !monster_at(loc) && monster_habitable_grid(mons, grd(loc));
3381
3382     // Choose an appropriate habitat square at random around the target.
3383     if (!swap)
3384     {
3385         int num_found = 0;
3386
3387         for (adjacent_iterator ai(mons->pos()); ai; ++ai)
3388             if (!monster_at(*ai) && monster_habitable_grid(mons, grd(*ai))
3389