68509ce6b569c384728c4b8d76c34b0c4de089d3
[crawl.git] / crawl-ref / source / godabil.cc
1 /**
2  * @file
3  * @brief God-granted abilities.
4 **/
5
6 #include "AppHdr.h"
7
8 #include "godabil.h"
9
10 #include <queue>
11 #include <sstream>
12
13 #include "act-iter.h"
14 #include "areas.h"
15 #include "attitude-change.h"
16 #include "branch.h"
17 #include "butcher.h"
18 #include "cloud.h"
19 #include "colour.h"
20 #include "coordit.h"
21 #include "dactions.h"
22 #include "database.h"
23 #include "dgn-overview.h"
24 #include "directn.h"
25 #include "dungeon.h"
26 #include "effects.h"
27 #include "english.h"
28 #include "fight.h"
29 #include "files.h"
30 #include "food.h"
31 #include "godblessing.h"
32 #include "godcompanions.h"
33 #include "goditem.h"
34 #include "hiscores.h"
35 #include "invent.h"
36 #include "itemprop.h"
37 #include "items.h"
38 #include "item_use.h"
39 #include "libutil.h"
40 #include "losglobal.h"
41 #include "macro.h"
42 #include "mapmark.h"
43 #include "maps.h"
44 #include "message.h"
45 #include "misc.h"
46 #include "mon-act.h"
47 #include "mon-behv.h"
48 #include "mon-book.h"
49 #include "mon-cast.h"
50 #include "mon-death.h"
51 #include "mon-place.h"
52 #include "mon-poly.h"
53 #include "mutation.h"
54 #include "notes.h"
55 #include "ouch.h"
56 #include "output.h"
57 #include "place.h"
58 #include "player-equip.h"
59 #include "player-stats.h"
60 #include "potion.h"
61 #include "prompt.h"
62 #include "religion.h"
63 #include "shout.h"
64 #include "skill_menu.h"
65 #include "spl-book.h"
66 #include "spl-monench.h"
67 #include "spl-summoning.h"
68 #include "spl-transloc.h"
69 #include "spl-util.h"
70 #include "sprint.h"
71 #include "state.h"
72 #include "stringutil.h"
73 #include "target.h"
74 #include "terrain.h"
75 #include "throw.h"
76 #ifdef USE_TILE
77  #include "tiledef-main.h"
78 #endif
79 #include "traps.h"
80 #include "viewchar.h"
81 #include "view.h"
82
83 // Load the sacrifice_def definition and the sac_data array.
84 #include "sacrifice-data.h"
85
86 static void _zin_saltify(monster* mon);
87
88 string zin_recite_text(const int seed, const int prayertype, int step)
89 {
90     // 'prayertype':
91     // This is in enum.h; there are currently four prayers.
92
93     // 'step':
94     // -1: We're either starting or stopping, so we just want the passage name.
95     // 2/1/0: That many rounds are left. So, if step = 2, we want to show the passage #1/3.
96
97     // That's too confusing, so:
98
99     if (step > -1)
100     {
101         step = abs(step-3);
102         if (step > 3)
103             step = 0;
104     }
105
106     // We change it to turn 1, turn 2, turn 3.
107
108     // 'trits':
109     // To have deterministic passages we need to store a random seed.
110     // Ours consists of an array of trinary bits.
111
112     // Yes, really.
113
114     const int trits[7] = { seed % 3, (seed / 3) % 3, (seed / 9) % 3,
115                            (seed / 27) % 3, (seed / 81) % 3, (seed / 243) % 3,
116                            (seed / 729) % 3};
117     const int chapter = 1 + trits[0] + trits[1] * 3 + trits[2] * 9;
118     const int verse = 1 + trits[3] + trits[4] * 3 + trits[5] * 9 + trits[6] * 27;
119
120     string sinner_text[12] =
121     {
122         "hordes of the Abyss",
123         "bastard children of Xom",
124         "amorphous wretches",
125         "fetid masses",
126         "agents of filth",
127         "squalid dregs",
128         "unbelievers",
129         "heretics",
130         "guilty",
131         "legions of the damned",
132         "servants of Hell",
133         "forces of darkness",
134     };
135
136     string sin_text[12] =
137     {
138         "chaotic",
139         "discordant",
140         "anarchic",
141         "unclean",
142         "impure",
143         "contaminated",
144         "unfaithful",
145         "disloyal",
146         "doubting",
147         "profane",
148         "blasphemous",
149         "sacrilegious",
150     };
151
152     string long_sin_text[12] =
153     {
154         "chaos",
155         "discord",
156         "anarchy",
157         "uncleanliness",
158         "impurity",
159         "contamination",
160         "unfaithfulness",
161         "disloyalty",
162         "doubt",
163         "profanity",
164         "blasphemy",
165         "sacrilege",
166     };
167
168     string virtue_text[12] =
169     {
170         "ordered",
171         "harmonic",
172         "lawful",
173         "clean",
174         "pure",
175         "hygienic",
176         "faithful",
177         "loyal",
178         "believing",
179         "reverent",
180         "pious",
181         "obedient",
182     };
183
184     string long_virtue_text[12] =
185     {
186         "order",
187         "harmony",
188         "lawfulness",
189         "cleanliness",
190         "purity",
191         "hygiene",
192         "faithfulness",
193         "loyalty",
194         "belief",
195         "reverence",
196         "piety",
197         "obedience",
198     };
199
200     string smite_text[9] =
201     {
202         "purify",
203         "censure",
204         "condemn",
205         "strike down",
206         "expel",
207         "oust",
208         "smite",
209         "castigate",
210         "rebuke",
211     };
212
213     string smitten_text[9] =
214     {
215         "purified",
216         "censured",
217         "condemned",
218         "struck down",
219         "expelled",
220         "ousted",
221         "smitten",
222         "castigated",
223         "rebuked",
224     };
225
226     string sinner = sinner_text[trits[3] + prayertype * 3];
227     string sin[2] = {sin_text[trits[6] + prayertype * 3],
228                      long_sin_text[trits[6] + prayertype * 3]};
229     string virtue[2] = {virtue_text[trits[6] + prayertype * 3],
230                         long_virtue_text[trits[6] + prayertype * 3]};
231     string smite[2] = {smite_text[(trits[4] + trits[5] * 3)],
232                        smitten_text[(trits[4] + trits[5] * 3)]};
233
234     string turn[4] = {"This is only here because arrays start from 0.",
235                       "Zin is a buggy god.", "Please report this.",
236                       "This isn't right at all."};
237
238     switch (chapter)
239     {
240         case 1:
241             turn[1] = make_stringf("It was the word of Zin that there would not be %s...",
242                                    sin[1].c_str());
243             turn[2] = make_stringf("...and did the people not suffer until they had %s...",
244                                    smite[1].c_str());
245             turn[3] = make_stringf("...the %s, after which all was well?", sinner.c_str());
246             break;
247         case 2:
248             turn[1] = make_stringf("The voice of Zin, pure and clear, did say that the %s...",
249                                    sinner.c_str());
250             turn[2] = make_stringf("...were not %s! And hearing this, the people rose up...",
251                                    virtue[0].c_str());
252             turn[3] = make_stringf("...and embraced %s, for they feared Zin's wrath.",
253                                    virtue[1].c_str());
254             break;
255         case 3:
256             turn[1] = make_stringf("Zin spoke of the doctrine of %s, and...",
257                                    virtue[1].c_str());
258             turn[2] = make_stringf("...saw the %s filled with fear, for they were...",
259                                    sinner.c_str());
260             turn[3] = make_stringf("...%s and knew Zin's wrath would come for them.",
261                                    sin[0].c_str());
262             break;
263         case 4:
264             turn[1] = make_stringf("And so Zin bade the %s to come before...",
265                                    sinner.c_str());
266             turn[2] = make_stringf("...the altar, that judgement might be passed...");
267             turn[3] = make_stringf("...upon those who were not %s.", virtue[0].c_str());
268             break;
269         case 5:
270             turn[1] = make_stringf("To the devout, Zin provideth. From the rest...");
271             turn[2] = make_stringf("...ye %s, ye guilty...", sinner.c_str());
272             turn[3] = make_stringf("...of %s, Zin taketh.", sin[1].c_str());
273             break;
274         case 6:
275             turn[1] = make_stringf("Zin saw the %s of the %s, and...",
276                                    sin[1].c_str(), sinner.c_str());
277             turn[2] = make_stringf("...was displeased, for did the law not say that...");
278             turn[3] = make_stringf("...those who did not become %s would be %s?",
279                                    virtue[0].c_str(), smite[1].c_str());
280             break;
281         case 7:
282             turn[1] = make_stringf("Zin said that %s shall be the law of the land, and...",
283                                    virtue[1].c_str());
284             turn[2] = make_stringf("...those who turn to %s will be %s. This was fair...",
285                                    sin[1].c_str(), smite[1].c_str());
286             turn[3] = make_stringf("...and just, and not a voice dissented.");
287             break;
288         case 8:
289             turn[1] = make_stringf("Damned, damned be the %s and...", sinner.c_str());
290             turn[2] = make_stringf("...all else who abandon %s! Let them...",
291                                    virtue[1].c_str());
292             turn[3] = make_stringf("...be %s by the jurisprudence of Zin!",
293                                    smite[1].c_str());
294             break;
295         case 9:
296             turn[1] = make_stringf("And Zin said to all in attendance, 'Which of ye...");
297             turn[2] = make_stringf("...number among the %s? Come before me, that...",
298                                    sinner.c_str());
299             turn[3] = make_stringf("...I may %s you now for your %s!'",
300                                    smite[0].c_str(), sin[1].c_str());
301             break;
302         case 10:
303             turn[1] = make_stringf("Yea, I say unto thee, bring forth...");
304             turn[2] = make_stringf("...the %s that they may know...", sinner.c_str());
305             turn[3] = make_stringf("...the wrath of Zin, and thus be %s!",
306                                    smite[1].c_str());
307             break;
308         case 11:
309             turn[1] = make_stringf("In a great set of silver scales are weighed the...");
310             turn[2] = make_stringf("...souls of the %s, and with their %s...",
311                                    sinner.c_str(), sin[0].c_str());
312             turn[3] = make_stringf("...ways, the balance hath tipped against them!");
313             break;
314         case 12:
315             turn[1] = make_stringf("It is just that the %s shall be %s...",
316                                    sinner.c_str(), smite[1].c_str());
317             turn[2] = make_stringf("...in due time, for %s is what Zin has declared...",
318                                    virtue[1].c_str());
319             turn[3] = make_stringf("...the law of the land, and Zin's word is law!");
320             break;
321         case 13:
322             turn[1] = make_stringf("Thus the people made the covenant of %s with...",
323                                    virtue[1].c_str());
324             turn[2] = make_stringf("...Zin, and all was good, for they knew that the...");
325             turn[3] = make_stringf("...%s would trouble them no longer.", sinner.c_str());
326             break;
327         case 14:
328             turn[1] = make_stringf("What of the %s? %s for their...",
329                                    sinner.c_str(), uppercase_first(smite[1]).c_str());
330             turn[2] = make_stringf("...%s they shall be! Zin will %s them again...",
331                                    sin[1].c_str(), smite[0].c_str());
332             turn[3] = make_stringf("...and again, and again!");
333             break;
334         case 15:
335             turn[1] = make_stringf("And lo, the wrath of Zin did find...");
336             turn[2] = make_stringf("...them wherever they hid, and the %s...",
337                                    sinner.c_str());
338             turn[3] = make_stringf("...were %s for their %s!",
339                                    smite[1].c_str(), sin[1].c_str());
340             break;
341         case 16:
342             turn[1] = make_stringf("Zin looked out upon the remains of the %s...",
343                                    sinner.c_str());
344             turn[2] = make_stringf("...and declared it good that they had been...");
345             turn[3] = make_stringf("...%s. And thus justice was done.", smite[1].c_str());
346             break;
347         case 17:
348             turn[1] = make_stringf("The law of Zin demands thee...");
349             turn[2] = make_stringf("...be %s, and that the punishment for %s...",
350                                    virtue[0].c_str(), sin[1].c_str());
351             turn[3] = make_stringf("...shall be swift and harsh!");
352             break;
353         case 18:
354             turn[1] = make_stringf("It was then that Zin bade them...");
355             turn[2] = make_stringf("...not to stray from %s, lest...", virtue[1].c_str());
356             turn[3] = make_stringf("...they become as damned as the %s.", sinner.c_str());
357             break;
358         case 19:
359             turn[1] = make_stringf("Only the %s shall be judged worthy, and...",
360                                    virtue[0].c_str());
361             turn[2] = make_stringf("...all the %s will be found wanting. Such is...",
362                                    sinner.c_str());
363             turn[3] = make_stringf("...the word of Zin, and such is the law!");
364             break;
365         case 20:
366             turn[1] = make_stringf("To those who would swear an oath of %s on my altar...",
367                                    virtue[1].c_str());
368             turn[2] = make_stringf("...I bring ye salvation. To the rest, ye %s...",
369                                    sinner.c_str());
370             turn[3] = make_stringf("...and the %s, the name of Zin shall be thy damnation.",
371                                    sin[0].c_str());
372             break;
373         case 21:
374             turn[1] = make_stringf("And Zin decreed that the people would be...");
375             turn[2] = make_stringf("...protected from %s in all its forms, and...",
376                                    sin[1].c_str());
377             turn[3] = make_stringf("...preserved in their %s for all the days to come.",
378                                    virtue[1].c_str());
379             break;
380         case 22:
381             turn[1] = make_stringf("For those who would enter Zin's holy bosom...");
382             turn[2] = make_stringf("...and live in %s, Zin provideth. Such is...",
383                                    virtue[1].c_str());
384             turn[3] = make_stringf("...the covenant, and such is the way of things.");
385             break;
386         case 23:
387             turn[1] = make_stringf("Zin hath not damned the %s, but it is they...",
388                                    sinner.c_str());
389             turn[2] = make_stringf("...that have damned themselves for their %s, for...",
390                                    sin[1].c_str());
391             turn[3] = make_stringf("...did Zin not decree that to be %s was wrong?",
392                                    sin[0].c_str());
393             break;
394         case 24:
395             turn[1] = make_stringf("And Zin, furious at their %s, held...", sin[1].c_str());
396             turn[2] = make_stringf("...aloft a silver sceptre! The %s...", sinner.c_str());
397             turn[3] = make_stringf("...were %s, and thus the way of things was maintained.",
398                                    smite[1].c_str());
399             break;
400         case 25:
401             turn[1] = make_stringf("When the law of the land faltered, Zin rose...");
402             turn[2] = make_stringf("...from the silver throne, and the %s were...",
403                                    sinner.c_str());
404             turn[3] = make_stringf("...%s. And it was thus that the law was made good.",
405                                    smite[1].c_str());
406             break;
407         case 26:
408             turn[1] = make_stringf("Zin descended from on high in a silver chariot...");
409             turn[2] = make_stringf("...to %s the %s for their...",
410                                    smite[0].c_str(), sinner.c_str());
411             turn[3] = make_stringf("...%s, and thus judgement was rendered.",
412                                    sin[1].c_str());
413             break;
414         case 27:
415             turn[1] = make_stringf("The %s stood before Zin, and in that instant...",
416                                    sinner.c_str());
417             turn[2] = make_stringf("...they knew they would be found guilty of %s...",
418                                    sin[1].c_str());
419             turn[3] = make_stringf("...for that is the word of Zin, and Zin's word is law.");
420             break;
421     }
422
423     string recite = "Hail Satan.";
424
425     if (step == -1)
426     {
427         string bookname = (prayertype == RECITE_CHAOTIC)  ?  "Abominations"  :
428                           (prayertype == RECITE_IMPURE)   ?  "Ablutions"     :
429                           (prayertype == RECITE_HERETIC)  ?  "Apostates"     :
430                           (prayertype == RECITE_UNHOLY)   ?  "Anathema"      :
431                                                              "Bugginess";
432         ostringstream numbers;
433         numbers << chapter;
434         numbers << ":";
435         numbers << verse;
436         recite = bookname + " " + numbers.str();
437     }
438     else
439         recite = turn[step];
440
441     return recite;
442 }
443
444 /** How vulnerable to RECITE_HERETIC is this monster?
445  *
446  * @param[in] mon The monster to check.
447  * @returns the susceptibility.
448  */
449 static int _heretic_recite_weakness(const monster *mon)
450 {
451     int degree = 0;
452
453     // Sleeping or paralyzed monsters will wake up or still perceive their
454     // surroundings, respectively.  So, you can still recite to them.
455     if (mons_intel(mon) >= I_NORMAL
456         && !(mon->has_ench(ENCH_DUMB) || mons_is_confused(mon)))
457     {
458         // In the eyes of Zin, everyone is a sinner until proven otherwise!
459             degree++;
460
461         // Any priest is a heretic...
462         if (mon->is_priest())
463             degree++;
464
465         // Or those who believe in themselves...
466         if (mon->type == MONS_DEMIGOD)
467             degree++;
468
469         // ...but evil gods are worse.
470         if (is_evil_god(mon->god) || is_unknown_god(mon->god))
471             degree++;
472
473         // (The above mean that worshipers will be treated as
474         // priests for reciting, even if they aren't actually.)
475
476
477         // Sanity check: monsters that won't attack you, and aren't
478         // priests/evil, don't get recited against.
479         if (mon->wont_attack() && degree <= 1)
480             degree = 0;
481
482         // Sanity check: monsters that are holy, know holy spells, or worship
483         // holy gods aren't heretics.
484         if (mon->is_holy() || is_good_god(mon->god))
485             degree = 0;
486     }
487
488     return degree;
489 }
490
491 typedef FixedVector<int, NUM_RECITE_TYPES> recite_counts;
492 /** Check whether this monster might be influenced by Recite.
493  *
494  * @param[in] mon The monster to check.
495  * @param[out] eligibility A vector, indexed by recite_type, that indicates
496  *             which recitation types the monster is affected by, if any:
497  *             eligibility[RECITE_FOO] is nonzero if the monster is affected
498  *             by RECITE_FOO. Only modified if the function returns 0 or 1.
499  * @param quiet[in]     Whether to suppress messenging.
500  * @return  -1 if the monster is already affected. The eligibility vector
501  *          is unchanged.
502  * @return  0 if the monster is otherwise ineligible for recite. The
503  *          eligibility vector is filled with zeros.
504  * @return  1 if the monster is eligible for recite. The eligibility vector
505  *          indicates which types of recitation it is vulnerable to.
506  */
507 static int _zin_check_recite_to_single_monster(const monster *mon,
508                                                recite_counts &eligibility,
509                                                bool quiet = false)
510 {
511     ASSERT(mon);
512
513     // Can't recite if they were recently recited to.
514     if (mon->has_ench(ENCH_RECITE_TIMER))
515         return -1;
516
517     const mon_holy_type holiness = mon->holiness();
518
519     eligibility.init(0);
520
521     // Too high HD to ever be affected.
522     if (mon->get_hit_dice() >= zin_recite_power())
523         return 0;
524
525     // Anti-chaos prayer: Hits things vulnerable to silver, or with chaotic spells/gods.
526     eligibility[RECITE_CHAOTIC] = mon->how_chaotic(true);
527
528     // Anti-impure prayer: Hits things that Zin hates in general.
529     // Don't look at the monster's god; that's what RECITE_HERETIC is for.
530     eligibility[RECITE_IMPURE] = mon->how_unclean(false);
531     // Sanity check: if a monster is 'really' natural, don't consider it impure.
532     if (mons_intel(mon) < I_NORMAL
533         && (holiness == MH_NATURAL || holiness == MH_PLANT)
534         && mon->type != MONS_UGLY_THING
535         && mon->type != MONS_VERY_UGLY_THING
536         && mon->type != MONS_DEATH_DRAKE)
537     {
538         eligibility[RECITE_IMPURE] = 0;
539     }
540
541     // Anti-unholy prayer: Hits demons and incorporeal undead.
542     if (holiness == MH_UNDEAD && mon->is_insubstantial()
543         || holiness == MH_DEMONIC)
544     {
545         eligibility[RECITE_UNHOLY]++;
546     }
547
548     // Anti-heretic prayer: Hits intelligent monsters, especially priests.
549     eligibility[RECITE_HERETIC] = _heretic_recite_weakness(mon);
550
551 #ifdef DEBUG_DIAGNOSTICS
552     if (!quiet)
553     {
554         string elig;
555         for (int i = 0; i < NUM_RECITE_TYPES; i++)
556             elig += '0' + eligibility[i];
557         dprf("Eligibility: %s", elig.c_str());
558     }
559 #endif
560
561     // Checking to see whether they were eligible for anything at all.
562     for (int i = 0; i < NUM_RECITE_TYPES; i++)
563         if (eligibility[i] > 0)
564             return 1;
565
566     return 0;
567 }
568
569 int zin_recite_power()
570 {
571     // Resistance is now based on HD.
572     // You can affect up to (30+30)/2 = 30 'power' (HD).
573     const int power_mult = 10;
574     const int invo_power = you.skill_rdiv(SK_INVOCATIONS, power_mult)
575                            + 3 * power_mult;
576     const int piety_power = you.piety * 3 / 2;
577     return (invo_power + piety_power) / 2 / power_mult;
578 }
579
580 bool zin_check_able_to_recite(bool quiet)
581 {
582     if (you.duration[DUR_RECITE])
583     {
584         if (!quiet)
585             mpr("Finish your current sermon first, please.");
586         return false;
587     }
588
589     if (you.duration[DUR_BREATH_WEAPON])
590     {
591         if (!quiet)
592             mpr("You're too short of breath to recite.");
593         return false;
594     }
595
596     if (you.duration[DUR_WATER_HOLD] && !you.res_water_drowning())
597     {
598         if (!quiet)
599             mpr("You cannot recite while unable to breathe!");
600         return false;
601     }
602
603     return true;
604 }
605
606 /**
607  * Check whether there are monsters who might be influenced by Recite.
608  * If prayertype is null, we're just checking whether we can.
609  * Otherwise we're actually reciting, and may need to present a menu.
610  *
611  * @param quiet     Whether to suppress messages.
612  * @return  0 if no monsters were found, or if all the found monsters returned
613  *          zero from _zin_check_recite_to_single_monster().
614  * @return  1 if an eligible audience was found.
615  * @return  -1 if only an ineligible audience was found: no eligibile
616  *          monsters, and at least one returned -1 from
617  *          _zin_check_recite_to_single_monster().
618  */
619 int zin_check_recite_to_monsters(bool quiet)
620 {
621     bool found_ineligible = false;
622     bool found_eligible = false;
623
624     for (radius_iterator ri(you.pos(), LOS_DEFAULT); ri; ++ri)
625     {
626         const monster *mon = monster_at(*ri);
627         if (!mon || !you.can_see(mon))
628             continue;
629
630         recite_counts retval;
631         switch (_zin_check_recite_to_single_monster(mon, retval, quiet))
632         {
633         case -1:
634             found_ineligible = true;
635         // Intentional fallthrough
636         case 0:
637             continue;
638         }
639
640         for (int i = 0; i < NUM_RECITE_TYPES; i++)
641             if (retval[i] > 0)
642                 found_eligible = true;
643     }
644
645     if (!found_eligible && !found_ineligible)
646     {
647         if (!quiet)
648             dprf("No audience found!");
649         return 0;
650     }
651     else if (!found_eligible && found_ineligible)
652     {
653         if (!quiet)
654             dprf("No sensible audience found!");
655         return -1;
656     }
657     else
658         return 1; // We just recite against everything.
659 }
660
661 enum zin_eff
662 {
663     ZIN_NOTHING,
664     ZIN_DAZE,
665     ZIN_CONFUSE,
666     ZIN_PARALYSE,
667     ZIN_BLEED,
668     ZIN_SMITE,
669     ZIN_BLIND,
670     ZIN_SILVER_CORONA,
671     ZIN_ANTIMAGIC,
672     ZIN_MUTE,
673     ZIN_MAD,
674     ZIN_DUMB,
675     ZIN_IGNITE_CHAOS,
676     ZIN_SALTIFY,
677     ZIN_ROT,
678     ZIN_HOLY_WORD,
679 };
680
681 bool zin_recite_to_single_monster(const coord_def& where)
682 {
683     // That's a pretty good sanity check, I guess.
684     ASSERT(you_worship(GOD_ZIN));
685
686     monster* mon = monster_at(where);
687
688     // Once you're already reciting, invis is ok.
689     if (!mon || !cell_see_cell(where, you.pos(), LOS_DEFAULT))
690         return false;
691
692     recite_counts eligibility;
693     bool affected = false;
694
695     if (_zin_check_recite_to_single_monster(mon, eligibility) < 1)
696         return false;
697
698     recite_type prayertype = RECITE_HERETIC;
699     for (int i = NUM_RECITE_TYPES - 1; i >= RECITE_HERETIC; i--)
700     {
701         if (eligibility[i] > 0)
702         {
703             prayertype = static_cast <recite_type>(i);
704             break;
705         }
706     }
707
708     // Second check: because this affects the whole screen over several turns,
709     // its effects are staggered. There's a 50% chance per monster, per turn,
710     // that nothing will happen - so the cumulative odds of nothing happening
711     // are one in eight, since you recite three times.
712     if (coinflip())
713         return false;
714
715     const int power = zin_recite_power();
716     // Old recite was mostly deterministic, which is bad.
717     const int resist = mon->get_hit_dice() + random2(6);
718     const int check = power - resist;
719
720     // We abort if we didn't *beat* their HD - but first we might get a cute message.
721     if (mon->can_speak() && one_chance_in(5))
722     {
723         if (check < -10)
724             simple_monster_message(mon, " guffaws at your puny god.");
725         else if (check < -5)
726             simple_monster_message(mon, " sneers at your recitation.");
727     }
728
729     if (check <= 0)
730         return false;
731
732     // To what degree are they eligible for this prayertype?
733     const int degree = eligibility[prayertype];
734     const bool minor = degree <= (prayertype == RECITE_HERETIC ? 2 : 1);
735     const int spellpower = power * 2 + degree * 20;
736     zin_eff effect = ZIN_NOTHING;
737
738     switch (prayertype)
739     {
740     case RECITE_HERETIC:
741         if (degree == 1)
742         {
743             if (mon->asleep())
744                 break;
745             // This is the path for 'conversion' effects.
746             // Their degree is only 1 if they weren't a priest,
747             // a worshiper of an evil or chaotic god, etc.
748
749             // Right now, it only has the 'failed conversion' effects, though.
750             // This branch can't hit sleeping monsters - until they wake up.
751
752             if (check < 5)
753                 effect = ZIN_DAZE;
754             else if (check < 10)
755             {
756                 if (coinflip())
757                     effect = ZIN_CONFUSE;
758                 else
759                     effect = ZIN_DAZE;
760             }
761             else if (check < 15)
762                 effect = ZIN_CONFUSE;
763             else
764             {
765                 if (one_chance_in(3))
766                     effect = ZIN_PARALYSE;
767                 else
768                     effect = ZIN_CONFUSE;
769             }
770         }
771         else
772         {
773             // This is the path for 'smiting' effects.
774             // Their degree is only greater than 1 if
775             // they're unable to be redeemed.
776             if (check < 5)
777             {
778                 if (coinflip())
779                     effect = ZIN_BLEED;
780                 else
781                     effect = ZIN_SMITE;
782             }
783             else if (check < 10)
784             {
785                 if (one_chance_in(3))
786                     effect = ZIN_BLIND;
787                 else if (mon->antimagic_susceptible())
788                     effect = ZIN_ANTIMAGIC;
789                 else
790                     effect = ZIN_SILVER_CORONA;
791             }
792             else if (check < 15)
793             {
794                 if (one_chance_in(3))
795                     effect = ZIN_BLIND;
796                 else if (coinflip())
797                     effect = ZIN_PARALYSE;
798                 else
799                     effect = ZIN_MUTE;
800             }
801             else
802             {
803                 if (coinflip())
804                     effect = ZIN_MAD;
805                 else
806                     effect = ZIN_DUMB;
807             }
808         }
809         break;
810
811     case RECITE_CHAOTIC:
812         if (check < 5)
813         {
814             // nastier -- fallthrough if immune
815             if (coinflip() && mon->can_bleed())
816                 effect = ZIN_BLEED;
817             else
818                 effect = ZIN_SMITE;
819         }
820         else if (check < 10)
821         {
822             if (coinflip())
823                 effect = ZIN_SILVER_CORONA;
824             else
825                 effect = ZIN_SMITE;
826         }
827         else if (check < 15)
828         {
829             if (coinflip())
830                 effect = ZIN_IGNITE_CHAOS;
831             else
832                 effect = ZIN_SILVER_CORONA;
833         }
834         else
835             effect = ZIN_SALTIFY;
836         break;
837
838     case RECITE_IMPURE:
839         // Many creatures normally resistant to rotting are still affected,
840         // because this is divine punishment.  Those with no real flesh are
841         // immune, of course.
842         if (check < 5)
843         {
844             if (coinflip() && mon->can_bleed())
845                 effect = ZIN_BLEED;
846             else
847                 effect = ZIN_SMITE;
848         }
849         else if (check < 10)
850         {
851             if (coinflip() && mon->res_rotting() <= 1)
852                 effect = ZIN_ROT;
853             else
854                 effect = ZIN_SILVER_CORONA;
855         }
856         else if (check < 15)
857         {
858             if (mon->undead_or_demonic() && coinflip())
859                 effect = ZIN_HOLY_WORD;
860             else
861                 effect = ZIN_SILVER_CORONA;
862         }
863         else
864             effect = ZIN_SALTIFY;
865         break;
866
867     case RECITE_UNHOLY:
868         if (check < 5)
869         {
870             if (mons_intel(mon) > I_INSECT && coinflip())
871                 effect = ZIN_DAZE;
872             else
873                 effect = ZIN_CONFUSE;
874         }
875         else if (check < 10)
876         {
877             if (coinflip())
878                 effect = ZIN_CONFUSE;
879             else
880                 effect = ZIN_SILVER_CORONA;
881         }
882         // Half of the time, the anti-unholy prayer will be capped at this
883         // level of effect.
884         else if (check < 15 || coinflip())
885         {
886             if (coinflip())
887                 effect = ZIN_HOLY_WORD;
888             else
889                 effect = ZIN_SILVER_CORONA;
890         }
891         else
892             effect = ZIN_SALTIFY;
893         break;
894
895     case NUM_RECITE_TYPES:
896         die("invalid recite type");
897     }
898
899     // And the actual effects...
900     switch (effect)
901     {
902     case ZIN_NOTHING:
903         break;
904
905     case ZIN_DAZE:
906         if (mon->add_ench(mon_enchant(ENCH_DAZED, degree, &you,
907                           (degree + random2(spellpower)) * BASELINE_DELAY)))
908         {
909             simple_monster_message(mon, " is dazed by your recitation.");
910             affected = true;
911         }
912         break;
913
914     case ZIN_CONFUSE:
915         if (mons_class_is_confusable(mon->type)
916             && !mon->check_clarity(false)
917             && mon->add_ench(mon_enchant(ENCH_CONFUSION, degree, &you,
918                              (degree + random2(spellpower)) * BASELINE_DELAY)))
919         {
920             if (prayertype == RECITE_HERETIC)
921                 simple_monster_message(mon, " is confused by your recitation.");
922             else
923                 simple_monster_message(mon, " stumbles about in disarray.");
924             affected = true;
925         }
926         break;
927
928     case ZIN_PARALYSE:
929         if (mon->add_ench(mon_enchant(ENCH_PARALYSIS, 0, &you,
930                           (degree + random2(spellpower)) * BASELINE_DELAY)))
931         {
932             simple_monster_message(mon,
933                 minor ? " is awed by your recitation."
934                       : " is aghast at the heresy of your recitation.");
935             affected = true;
936         }
937         break;
938
939     case ZIN_BLEED:
940         if (mon->can_bleed()
941             && mon->add_ench(mon_enchant(ENCH_BLEED, degree, &you,
942                              (degree + random2(spellpower)) * BASELINE_DELAY)))
943         {
944             mon->add_ench(mon_enchant(ENCH_SICK, degree, &you,
945                           (degree + random2(spellpower)) * BASELINE_DELAY));
946             switch (prayertype)
947             {
948             case RECITE_HERETIC:
949                 if (minor)
950                     simple_monster_message(mon, "'s eyes and ears begin to bleed.");
951                 else
952                 {
953                     mprf("%s bleeds profusely from %s eyes and ears.",
954                          mon->name(DESC_THE).c_str(),
955                          mon->pronoun(PRONOUN_POSSESSIVE).c_str());
956                 }
957                 break;
958             case RECITE_CHAOTIC:
959                 simple_monster_message(mon,
960                     minor ? "'s chaotic flesh is covered in bleeding sores."
961                           : "'s chaotic flesh erupts into weeping sores!");
962                 break;
963             case RECITE_IMPURE:
964                 simple_monster_message(mon,
965                     minor ? "'s impure flesh is covered in bleeding sores."
966                           : "'s impure flesh erupts into weeping sores!");
967                 break;
968             default:
969                 die("bad recite bleed");
970             }
971             affected = true;
972         }
973         break;
974
975     case ZIN_SMITE:
976         if (minor)
977             simple_monster_message(mon, " is smitten by the wrath of Zin.");
978         else
979             simple_monster_message(mon, " is blasted by the fury of Zin!");
980         // XXX: This duplicates code in cast_smiting().
981         mon->hurt(&you, 7 + (random2(spellpower) * 33 / 191));
982         if (mon->alive())
983             print_wounds(mon);
984         affected = true;
985         break;
986
987     case ZIN_BLIND:
988         if (mon->add_ench(mon_enchant(ENCH_BLIND, degree, &you, INFINITE_DURATION)))
989         {
990             simple_monster_message(mon, " is struck blind by the wrath of Zin!");
991             affected = true;
992         }
993         break;
994
995     case ZIN_SILVER_CORONA:
996         if (mon->add_ench(mon_enchant(ENCH_SILVER_CORONA, degree, &you,
997                           (degree + random2(spellpower)) * BASELINE_DELAY)))
998         {
999             simple_monster_message(mon, " is limned with silver light.");
1000             affected = true;
1001         }
1002         break;
1003
1004     case ZIN_ANTIMAGIC:
1005         ASSERT(prayertype == RECITE_HERETIC);
1006         if (mon->add_ench(mon_enchant(ENCH_ANTIMAGIC, degree, &you,
1007                           (degree + random2(spellpower)) * BASELINE_DELAY)))
1008         {
1009             simple_monster_message(mon,
1010                 minor ? " quails at your recitation."
1011                       : " looks feeble and powerless before your recitation.");
1012             affected = true;
1013         }
1014         break;
1015
1016     case ZIN_MUTE:
1017         if (mon->add_ench(mon_enchant(ENCH_MUTE, degree, &you, INFINITE_DURATION)))
1018         {
1019             simple_monster_message(mon, " is struck mute by the wrath of Zin!");
1020             affected = true;
1021         }
1022         break;
1023
1024     case ZIN_MAD:
1025         if (mon->add_ench(mon_enchant(ENCH_MAD, degree, &you, INFINITE_DURATION)))
1026         {
1027             simple_monster_message(mon, " is driven mad by the wrath of Zin!");
1028             affected = true;
1029         }
1030         break;
1031
1032     case ZIN_DUMB:
1033         if (mon->add_ench(mon_enchant(ENCH_DUMB, degree, &you, INFINITE_DURATION)))
1034         {
1035             simple_monster_message(mon, " is left stupefied by the wrath of Zin!");
1036             affected = true;
1037         }
1038         break;
1039
1040     case ZIN_IGNITE_CHAOS:
1041         ASSERT(prayertype == RECITE_CHAOTIC);
1042         {
1043             bolt beam;
1044             dice_def dam_dice(0, 5 + spellpower/7);  // Dice added below if applicable.
1045             dam_dice.num = degree;
1046
1047             int damage = dam_dice.roll();
1048             if (damage > 0)
1049             {
1050                 mon->hurt(&you, damage, BEAM_MISSILE, KILLED_BY_BEAM,
1051                           "", "", false);
1052
1053                 if (mon->alive())
1054                 {
1055                     simple_monster_message(mon,
1056                       (damage < 25) ? "'s chaotic flesh sizzles and spatters!" :
1057                       (damage < 50) ? "'s chaotic flesh bubbles and boils."
1058                                     : "'s chaotic flesh runs like molten wax.");
1059
1060                     print_wounds(mon);
1061                     behaviour_event(mon, ME_WHACK, &you);
1062                     affected = true;
1063                 }
1064                 else
1065                 {
1066                     simple_monster_message(mon,
1067                         " melts away into a sizzling puddle of chaotic flesh.");
1068                     monster_die(mon, KILL_YOU, NON_MONSTER);
1069                 }
1070             }
1071         }
1072         break;
1073
1074     case ZIN_SALTIFY:
1075         _zin_saltify(mon);
1076         break;
1077
1078     case ZIN_ROT:
1079         ASSERT(prayertype == RECITE_IMPURE);
1080         if (mon->res_rotting() <= 1
1081             && mon->add_ench(mon_enchant(ENCH_ROT, degree, &you,
1082                              (degree + random2(spellpower)) * BASELINE_DELAY)))
1083         {
1084             mon->add_ench(mon_enchant(ENCH_SICK, degree, &you,
1085                           (degree + random2(spellpower)) * BASELINE_DELAY));
1086             simple_monster_message(mon,
1087                 minor ? "'s impure flesh begins to rot away."
1088                       : "'s impure flesh sloughs off!");
1089             affected = true;
1090         }
1091         break;
1092
1093     case ZIN_HOLY_WORD:
1094         holy_word_monsters(where, spellpower, HOLY_WORD_ZIN, &you);
1095         affected = true;
1096         break;
1097     }
1098
1099     // Recite time, to prevent monsters from being recited against
1100     // more than once in a given recite instance.
1101     if (affected)
1102         mon->add_ench(mon_enchant(ENCH_RECITE_TIMER, degree, &you, 40));
1103
1104     // Monsters that have been affected may shout.
1105     if (affected
1106         && one_chance_in(3)
1107         && mon->alive()
1108         && !mon->asleep()
1109         && !mon->cannot_move()
1110         && mons_shouts(mon->type, false) != S_SILENT)
1111     {
1112         handle_monster_shouts(mon, true);
1113     }
1114
1115     return true;
1116 }
1117
1118 static void _zin_saltify(monster* mon)
1119 {
1120     const coord_def where = mon->pos();
1121     const monster_type pillar_type =
1122         mons_is_zombified(mon) ? mons_zombie_base(mon)
1123                                : mons_species(mon->type);
1124     const int hd = mon->get_hit_dice();
1125
1126     simple_monster_message(mon, " is turned into a pillar of salt by the wrath of Zin!");
1127
1128     // If the monster leaves a corpse when it dies, destroy the corpse.
1129     int corpse = monster_die(mon, KILL_YOU, NON_MONSTER);
1130     if (corpse != -1)
1131         destroy_item(corpse);
1132
1133     if (monster *pillar = create_monster(
1134                         mgen_data(MONS_PILLAR_OF_SALT,
1135                                   BEH_HOSTILE,
1136                                   0,
1137                                   0,
1138                                   0,
1139                                   where,
1140                                   MHITNOT,
1141                                   MG_FORCE_PLACE,
1142                                   GOD_NO_GOD,
1143                                   pillar_type),
1144                                   false))
1145     {
1146         // Enemies with more HD leave longer-lasting pillars of salt.
1147         int time_left = (random2(8) + hd) * BASELINE_DELAY;
1148         mon_enchant temp_en(ENCH_SLOWLY_DYING, 1, 0, time_left);
1149         pillar->update_ench(temp_en);
1150     }
1151 }
1152
1153 void zin_recite_interrupt()
1154 {
1155     if (!you.duration[DUR_RECITE])
1156         return;
1157     mprf(MSGCH_DURATION, "Your recitation is interrupted.");
1158     mpr("You feel short of breath.");
1159     you.duration[DUR_RECITE] = 0;
1160
1161     you.increase_duration(DUR_BREATH_WEAPON, random2(10) + random2(30));
1162 }
1163
1164 bool zin_vitalisation()
1165 {
1166     simple_god_message(" grants you divine stamina.");
1167
1168     // Feed the player slightly.
1169     if (you.hunger_state < HS_FULL)
1170         lessen_hunger(250, false);
1171
1172     // Add divine stamina.
1173     const int stamina_amt = max(1, you.skill_rdiv(SK_INVOCATIONS, 1, 3));
1174     you.attribute[ATTR_DIVINE_STAMINA] = stamina_amt;
1175     you.set_duration(DUR_DIVINE_STAMINA, 60 + roll_dice(2, 10));
1176
1177     notify_stat_change(STAT_STR, stamina_amt, true);
1178     notify_stat_change(STAT_INT, stamina_amt, true);
1179     notify_stat_change(STAT_DEX, stamina_amt, true);
1180
1181     return true;
1182 }
1183
1184 void zin_remove_divine_stamina()
1185 {
1186     mprf(MSGCH_DURATION, "Your divine stamina fades away.");
1187     notify_stat_change(STAT_STR, -you.attribute[ATTR_DIVINE_STAMINA], true);
1188     notify_stat_change(STAT_INT, -you.attribute[ATTR_DIVINE_STAMINA], true);
1189     notify_stat_change(STAT_DEX, -you.attribute[ATTR_DIVINE_STAMINA], true);
1190     you.duration[DUR_DIVINE_STAMINA] = 0;
1191     you.attribute[ATTR_DIVINE_STAMINA] = 0;
1192 }
1193
1194 bool zin_remove_all_mutations()
1195 {
1196     if (!how_mutated())
1197     {
1198         mpr("You have no mutations to be cured!");
1199         return false;
1200     }
1201
1202     you.one_time_ability_used.set(GOD_ZIN);
1203     take_note(Note(NOTE_GOD_GIFT, you.religion));
1204
1205     simple_god_message(" draws all chaos from your body!");
1206     delete_all_mutations("Zin's power");
1207
1208     return true;
1209 }
1210
1211 bool zin_sanctuary()
1212 {
1213     // Casting is disallowed while previous sanctuary in effect.
1214     // (Checked in ability.cc.)
1215     if (env.sanctuary_time)
1216         return false;
1217
1218     // Yes, shamelessly stolen from NetHack...
1219     if (!silenced(you.pos())) // How did you manage that?
1220         mprf(MSGCH_SOUND, "You hear a choir sing!");
1221     else
1222         mpr("You are suddenly bathed in radiance!");
1223
1224     flash_view(UA_PLAYER, WHITE);
1225
1226     holy_word(100, HOLY_WORD_ZIN, you.pos(), true, &you);
1227
1228 #ifndef USE_TILE_LOCAL
1229     // Allow extra time for the flash to linger.
1230     scaled_delay(1000);
1231 #endif
1232
1233     // Pets stop attacking and converge on you.
1234     you.pet_target = MHITYOU;
1235
1236     create_sanctuary(you.pos(), 7 + you.skill_rdiv(SK_INVOCATIONS) / 2);
1237
1238     return true;
1239 }
1240
1241 // shield bonus = attribute for duration turns, then decreasing by 1
1242 //                every two out of three turns
1243 // overall shield duration = duration + attribute
1244 // recasting simply resets those two values (to better values, presumably)
1245 void tso_divine_shield()
1246 {
1247     if (!you.duration[DUR_DIVINE_SHIELD])
1248     {
1249         if (you.shield()
1250             || you.duration[DUR_CONDENSATION_SHIELD])
1251         {
1252             mprf("Your shield is strengthened by %s divine power.",
1253                  apostrophise(god_name(GOD_SHINING_ONE)).c_str());
1254         }
1255         else
1256             mpr("A divine shield forms around you!");
1257     }
1258     else
1259         mpr("Your divine shield is renewed.");
1260
1261     you.redraw_armour_class = true;
1262
1263     // duration of complete shield bonus from 35 to 80 turns
1264     you.set_duration(DUR_DIVINE_SHIELD,
1265                      35 + you.skill_rdiv(SK_INVOCATIONS, 4, 3));
1266
1267     // affects size of SH bonus, decreases near end of duration
1268     you.attribute[ATTR_DIVINE_SHIELD] = 3 + you.skill_rdiv(SK_INVOCATIONS, 1, 5);
1269
1270     you.redraw_armour_class = true;
1271 }
1272
1273 void tso_remove_divine_shield()
1274 {
1275     mprf(MSGCH_DURATION, "Your divine shield disappears!");
1276     you.duration[DUR_DIVINE_SHIELD] = 0;
1277     you.attribute[ATTR_DIVINE_SHIELD] = 0;
1278     you.redraw_armour_class = true;
1279 }
1280
1281 void elyvilon_purification()
1282 {
1283     mpr("You feel purified!");
1284
1285     you.disease = 0;
1286     you.rotting = 0;
1287     you.duration[DUR_POISONING] = 0;
1288     you.duration[DUR_CONF] = 0;
1289     you.duration[DUR_SLOW] = 0;
1290     you.duration[DUR_PETRIFYING] = 0;
1291     you.duration[DUR_WEAK] = 0;
1292     restore_stat(STAT_ALL, 0, false);
1293     unrot_hp(9999);
1294     you.redraw_evasion = true;
1295 }
1296
1297 bool elyvilon_divine_vigour()
1298 {
1299     bool success = false;
1300
1301     if (!you.duration[DUR_DIVINE_VIGOUR])
1302     {
1303         mprf("%s grants you divine vigour.",
1304              god_name(GOD_ELYVILON).c_str());
1305
1306         const int vigour_amt = 1 + you.skill_rdiv(SK_INVOCATIONS, 1, 3);
1307         const int old_hp_max = you.hp_max;
1308         const int old_mp_max = you.max_magic_points;
1309         you.attribute[ATTR_DIVINE_VIGOUR] = vigour_amt;
1310         you.set_duration(DUR_DIVINE_VIGOUR,
1311                          40 + you.skill_rdiv(SK_INVOCATIONS, 5, 2));
1312
1313         calc_hp();
1314         inc_hp((you.hp_max * you.hp + old_hp_max - 1)/old_hp_max - you.hp);
1315         calc_mp();
1316         if (old_mp_max > 0)
1317         {
1318             inc_mp((you.max_magic_points * you.magic_points + old_mp_max - 1)
1319                      / old_mp_max
1320                    - you.magic_points);
1321         }
1322
1323         success = true;
1324     }
1325     else
1326         canned_msg(MSG_NOTHING_HAPPENS);
1327
1328     return success;
1329 }
1330
1331 void elyvilon_remove_divine_vigour()
1332 {
1333     mprf(MSGCH_DURATION, "Your divine vigour fades away.");
1334     you.duration[DUR_DIVINE_VIGOUR] = 0;
1335     you.attribute[ATTR_DIVINE_VIGOUR] = 0;
1336     calc_hp();
1337     calc_mp();
1338 }
1339
1340 bool vehumet_supports_spell(spell_type spell)
1341 {
1342     if (spell_typematch(spell, SPTYP_CONJURATION))
1343         return true;
1344
1345     // Conjurations work by conjuring up a chunk of short-lived matter and
1346     // propelling it towards the victim.  This is the most popular way, but
1347     // by no means it has a monopoly for being destructive.
1348     // Vehumet loves all direct physical destruction.
1349     if (spell == SPELL_SHATTER
1350         || spell == SPELL_LRD
1351         || spell == SPELL_SANDBLAST
1352         || spell == SPELL_AIRSTRIKE
1353         || spell == SPELL_TORNADO
1354         || spell == SPELL_FREEZE
1355         || spell == SPELL_IGNITE_POISON
1356         || spell == SPELL_OZOCUBUS_REFRIGERATION
1357         || spell == SPELL_OLGREBS_TOXIC_RADIANCE
1358         || spell == SPELL_INNER_FLAME)
1359     {
1360         return true;
1361     }
1362
1363     return false;
1364 }
1365
1366 // Returns false if the invocation fails (no spellbooks in sight, etc.).
1367 bool trog_burn_spellbooks()
1368 {
1369     if (!you_worship(GOD_TROG))
1370         return false;
1371
1372     god_acting gdact;
1373
1374     // XXX: maybe this should be allowed with less than immunity.
1375     if (player_res_fire(false) <= 3)
1376     {
1377         for (stack_iterator si(you.pos()); si; ++si)
1378         {
1379             if (item_is_spellbook(*si))
1380             {
1381                 mprf("Burning your own %s might not be such a smart idea!",
1382                         you.foot_name(true).c_str());
1383                 return false;
1384             }
1385         }
1386     }
1387
1388     int totalpiety = 0;
1389     int totalblocked = 0;
1390     vector<coord_def> mimics;
1391
1392     for (radius_iterator ri(you.pos(), LOS_DEFAULT); ri; ++ri)
1393     {
1394         const unsigned short cloud = env.cgrid(*ri);
1395         int count = 0;
1396         int rarity = 0;
1397         for (stack_iterator si(*ri); si; ++si)
1398         {
1399             if (!item_is_spellbook(*si))
1400                 continue;
1401
1402             // If a grid is blocked, books lying there will be ignored.
1403             // Allow bombing of monsters.
1404             if (cell_is_solid(*ri)
1405                 || cloud != EMPTY_CLOUD && env.cloud[cloud].type != CLOUD_FIRE)
1406             {
1407                 totalblocked++;
1408                 continue;
1409             }
1410
1411             if (si->flags & ISFLAG_MIMIC)
1412             {
1413                 totalblocked++;
1414                 mimics.push_back(*ri);
1415                 continue;
1416             }
1417
1418             // Ignore {!D} inscribed books.
1419             if (!check_warning_inscriptions(*si, OPER_DESTROY))
1420             {
1421                 mpr("Won't ignite {!D} inscribed spellbook.");
1422                 continue;
1423             }
1424
1425             totalpiety += 2;
1426
1427             // Rarity influences the duration of the pyre.
1428             rarity += book_rarity(si->sub_type);
1429
1430             dprf("Burned spellbook rarity: %d", rarity);
1431             destroy_spellbook(*si);
1432             item_was_destroyed(*si);
1433             destroy_item(si.link());
1434             count++;
1435         }
1436
1437         if (count)
1438         {
1439             if (cloud != EMPTY_CLOUD)
1440             {
1441                 // Reinforce the cloud.
1442                 mpr("The fire roars with new energy!");
1443                 const int extra_dur = count + random2(rarity / 2);
1444                 env.cloud[cloud].decay += extra_dur * 5;
1445                 env.cloud[cloud].set_whose(KC_YOU);
1446                 continue;
1447             }
1448
1449             const int duration = min(4 + count + random2(rarity/2), 23);
1450             place_cloud(CLOUD_FIRE, *ri, duration, &you);
1451
1452             mprf(MSGCH_GOD, "The spellbook%s burst%s into flames.",
1453                  count == 1 ? ""  : "s",
1454                  count == 1 ? "s" : "");
1455         }
1456     }
1457
1458     if (totalpiety)
1459     {
1460         simple_god_message(" is delighted!", GOD_TROG);
1461         gain_piety(totalpiety);
1462     }
1463     else if (totalblocked)
1464     {
1465         mprf("The spellbook%s fail%s to ignite!",
1466              totalblocked == 1 ? ""  : "s",
1467              totalblocked == 1 ? "s" : "");
1468         for (auto c : mimics)
1469             discover_mimic(c);
1470         return false;
1471     }
1472     else
1473     {
1474         mpr("You cannot see a spellbook to ignite!");
1475         return false;
1476     }
1477
1478     return true;
1479 }
1480
1481 void trog_do_trogs_hand(int pow)
1482 {
1483     you.increase_duration(DUR_TROGS_HAND,
1484                           5 + roll_dice(2, pow / 3 + 1), 100,
1485                           "Your skin crawls.");
1486     mprf(MSGCH_DURATION, "You feel resistant to hostile enchantments.");
1487 }
1488
1489 void trog_remove_trogs_hand()
1490 {
1491     if (you.duration[DUR_REGENERATION] == 0)
1492         mprf(MSGCH_DURATION, "Your skin stops crawling.");
1493     mprf(MSGCH_DURATION, "You feel less resistant to hostile enchantments.");
1494     you.duration[DUR_TROGS_HAND] = 0;
1495 }
1496
1497 bool beogh_water_walk()
1498 {
1499     return in_good_standing(GOD_BEOGH, 4);
1500 }
1501
1502 /**
1503  * Has the monster been given a Beogh gift?
1504  *
1505  * @param mon the orc in question.
1506  * @returns whether you have given the monster a Beogh gift before now.
1507  */
1508 static bool _given_gift(const monster* mon)
1509 {
1510     return mon->props.exists(BEOGH_WPN_GIFT_KEY)
1511             || mon->props.exists(BEOGH_ARM_GIFT_KEY)
1512             || mon->props.exists(BEOGH_SH_GIFT_KEY);
1513 }
1514
1515 /**
1516  * Checks whether the target monster is a valid target for beogh item-gifts.
1517  *
1518  * @param mons[in]  The monster to consider giving an item to.
1519  * @param quiet     Whether to print messages if the target is invalid.
1520  * @return          Whether the player can give an item to the monster.
1521  */
1522 bool beogh_can_gift_items_to(const monster* mons, bool quiet)
1523 {
1524     if (!mons || !mons->visible_to(&you))
1525     {
1526         if (!quiet)
1527             canned_msg(MSG_NOTHING_THERE);
1528         return false;
1529     }
1530
1531     if (!is_orcish_follower(mons))
1532     {
1533         if (!quiet)
1534             mpr("That's not an orcish ally!");
1535         return false;
1536     }
1537
1538     if (!mons->is_named())
1539     {
1540         if (!quiet)
1541             mpr("That orc has not proved itself worthy of your gift.");
1542         return false;
1543     }
1544
1545     if (_given_gift(mons))
1546     {
1547         if (!quiet)
1548         {
1549             mprf("%s has already been given a gift.",
1550                  mons->name(DESC_THE, false).c_str());
1551         }
1552         return false;
1553     }
1554
1555     return true;
1556 }
1557
1558 /**
1559  * Checks whether there are any valid targets for beogh gifts in LOS.
1560  */
1561 static bool _valid_beogh_gift_targets_in_sight()
1562 {
1563     for (monster_near_iterator rad(you.pos(), LOS_NO_TRANS); rad; ++rad)
1564         if (beogh_can_gift_items_to(*rad))
1565             return true;
1566     return false;
1567 }
1568
1569 /**
1570  * Allow the player to give an item to a named orcish ally that hasn't
1571  * been given a gift before
1572  *
1573  * @returns whether an item was given.
1574  */
1575 bool beogh_gift_item()
1576 {
1577     if (!_valid_beogh_gift_targets_in_sight())
1578     {
1579         mpr("No worthy followers in sight.");
1580         return false;
1581     }
1582
1583     dist spd;
1584
1585     direction_chooser_args args;
1586     args.restricts = DIR_TARGET;
1587     args.mode = TARG_BEOGH_GIFTABLE;
1588     args.range = LOS_RADIUS;
1589     args.needs_path = false;
1590     args.may_target_monster = true;
1591     args.cancel_at_self = true;
1592     args.show_floor_desc = true;
1593     args.top_prompt = "Select a follower to give a gift to.";
1594
1595     direction(spd, args);
1596
1597     if (!spd.isValid)
1598         return false;
1599
1600     monster* mons = monster_at(spd.target);
1601     if (!beogh_can_gift_items_to(mons, false))
1602         return false;
1603
1604     int item_slot = prompt_invent_item("Give which item?",
1605                                        MT_INVLIST, OSEL_ANY, true);
1606
1607     if (item_slot == PROMPT_ABORT || item_slot == PROMPT_NOTHING)
1608     {
1609         canned_msg(MSG_OK);
1610         return false;
1611     }
1612
1613     item_def& gift = you.inv[item_slot];
1614
1615     const bool shield = is_shield(gift);
1616     const bool body_armour = gift.base_type == OBJ_ARMOUR
1617                              && get_armour_slot(gift) == EQ_BODY_ARMOUR;
1618     const bool weapon = gift.base_type == OBJ_WEAPONS;
1619     const bool range_weapon = weapon && is_range_weapon(gift);
1620     const item_def* mons_weapon = mons->weapon();
1621
1622     if (!(weapon && mons->could_wield(gift)
1623           || body_armour && check_armour_size(gift, mons->body_size())
1624           || shield
1625              && (!mons_weapon
1626                  || mons->hands_reqd(*mons_weapon) != HANDS_TWO)))
1627     {
1628         mprf("%s can't use that.", mons->name(DESC_THE, false).c_str());
1629
1630         return false;
1631     }
1632
1633     // if we're giving a ranged weapon to an orc holding a melee weapon in
1634     // their hands, or vice versa, put it in their carried slot instead.
1635     // this will of course drop anything that's there.
1636     const bool use_alt_slot = weapon && mons_weapon
1637                               && is_range_weapon(gift) !=
1638                                  is_range_weapon(*mons_weapon);
1639
1640     mons->take_item(item_slot, body_armour ? MSLOT_ARMOUR :
1641                                     shield ? MSLOT_SHIELD :
1642                               use_alt_slot ? MSLOT_ALT_WEAPON :
1643                                              MSLOT_WEAPON);
1644     if (use_alt_slot)
1645         mons->swap_weapons(true);
1646
1647     dprf("is_ranged weap: %d", range_weapon);
1648     if (range_weapon)
1649         gift_ammo_to_orc(mons, true); // give a small initial ammo freebie
1650
1651
1652     if (shield)
1653         mons->props[BEOGH_SH_GIFT_KEY] = true;
1654     else if (body_armour)
1655         mons->props[BEOGH_ARM_GIFT_KEY] = true;
1656     else
1657         mons->props[BEOGH_WPN_GIFT_KEY] = true;
1658
1659     return true;
1660 }
1661
1662 void jiyva_paralyse_jellies()
1663 {
1664     mprf("You call upon nearby slimes to pray to %s.",
1665          god_name(you.religion).c_str());
1666
1667     int jelly_count = 0;
1668     for (radius_iterator ri(you.pos(), LOS_DEFAULT); ri; ++ri)
1669     {
1670         monster* mon = monster_at(*ri);
1671         const int dur = 16 + random2(9);
1672         if (mon != nullptr && mons_is_slime(mon) && !mon->is_shapeshifter())
1673         {
1674             mon->add_ench(mon_enchant(ENCH_PARALYSIS, 0,
1675                                       &you, dur * BASELINE_DELAY));
1676             jelly_count++;
1677         }
1678     }
1679
1680     if (jelly_count > 0)
1681     {
1682         if (jelly_count > 1)
1683             mpr("The nearby slimes join the prayer.");
1684         else
1685             mpr("A nearby slime joins the prayer.");
1686
1687         lose_piety(max(5, min(jelly_count, 20)));
1688     }
1689 }
1690
1691 bool jiyva_remove_bad_mutation()
1692 {
1693     if (!how_mutated())
1694     {
1695         mpr("You have no bad mutations to be cured!");
1696         return false;
1697     }
1698
1699     // Ensure that only bad mutations are removed.
1700     if (!delete_mutation(RANDOM_BAD_MUTATION, "Jiyva's power", true, false, true, true))
1701     {
1702         canned_msg(MSG_NOTHING_HAPPENS);
1703         return false;
1704     }
1705
1706     mpr("You feel cleansed.");
1707     return true;
1708 }
1709
1710 bool yred_injury_mirror()
1711 {
1712     return in_good_standing(GOD_YREDELEMNUL, 1)
1713            && you.duration[DUR_MIRROR_DAMAGE]
1714            && crawl_state.which_god_acting() != GOD_YREDELEMNUL;
1715 }
1716
1717 bool yred_can_animate_dead()
1718 {
1719     return in_good_standing(GOD_YREDELEMNUL, 2);
1720 }
1721
1722 /**
1723  * Animates corpses/skeletons where you are or in LOS, depending on piety.
1724  *
1725  * @returns false if it did nothing and you could have known so.
1726  */
1727 bool yred_animate_remains_or_dead()
1728 {
1729     if (yred_can_animate_dead())
1730     {
1731         canned_msg(MSG_CALL_DEAD);
1732
1733         animate_dead(&you, you.skill_rdiv(SK_INVOCATIONS) + 1, BEH_FRIENDLY,
1734                      MHITYOU, &you, "", GOD_YREDELEMNUL);
1735     }
1736     else
1737     {
1738         canned_msg(MSG_ANIMATE_REMAINS);
1739
1740         if (animate_remains(you.pos(), CORPSE_BODY, BEH_FRIENDLY,
1741                             MHITYOU, &you, "", GOD_YREDELEMNUL) < 0)
1742         {
1743             mpr("There are no remains here to animate!");
1744             return false;
1745         }
1746     }
1747     return true;
1748 }
1749
1750 void yred_make_enslaved_soul(monster* mon, bool force_hostile)
1751 {
1752     ASSERT(mons_enslaved_body_and_soul(mon));
1753
1754     add_daction(DACT_OLD_ENSLAVED_SOULS_POOF);
1755     remove_enslaved_soul_companion();
1756
1757     const string whose = you.can_see(mon) ? apostrophise(mon->name(DESC_THE))
1758                                           : mon->pronoun(PRONOUN_POSSESSIVE);
1759
1760     // Remove the monster's soul-enslaving enchantment, as it's no
1761     // longer needed.
1762     mon->del_ench(ENCH_SOUL_RIPE, false, false);
1763
1764     // Remove the monster's invisibility enchantment. If we don't do
1765     // this, it'll stay invisible after being remade as a spectral thing
1766     // below.
1767     mon->del_ench(ENCH_INVIS, false, false);
1768
1769     // If the monster's held in a net, get it out.
1770     mons_clear_trapping_net(mon);
1771
1772     // Drop the monster's holy equipment, and keep wielding the rest.  Also
1773     // remove any of its active avatars.
1774     monster_drop_things(mon, false, is_holy_item);
1775     mon->remove_avatars();
1776
1777     const monster orig = *mon;
1778
1779     // Use the original monster type as the zombified type here, to get
1780     // the proper stats from it.
1781     define_zombie(mon, mon->type, MONS_SPECTRAL_THING);
1782
1783     // If the original monster has been levelled up, its HD might be different
1784     // from its class HD, in which case its HP should be rerolled to match.
1785     if (mon->get_experience_level() != orig.get_experience_level())
1786     {
1787         mon->set_hit_dice(max(orig.get_experience_level(), 1));
1788         roll_zombie_hp(mon);
1789     }
1790
1791     mon->colour = ETC_UNHOLY;
1792
1793     mon->flags |= MF_NO_REWARD;
1794     mon->flags |= MF_ENSLAVED_SOUL;
1795
1796     // If the original monster type has melee abilities, make sure
1797     // its spectral thing has them as well.
1798     mon->flags |= orig.flags & MF_MELEE_MASK;
1799     mon->spells = orig.spells;
1800
1801     name_zombie(mon, &orig);
1802
1803     mons_make_god_gift(mon, GOD_YREDELEMNUL);
1804     add_companion(mon);
1805
1806     mon->attitude = !force_hostile ? ATT_FRIENDLY : ATT_HOSTILE;
1807     behaviour_event(mon, ME_ALERT, force_hostile ? &you : 0);
1808
1809     mon->stop_constricting_all(false);
1810     mon->stop_being_constricted();
1811
1812     mprf("%s soul %s.", whose.c_str(),
1813          !force_hostile ? "is now yours" : "fights you");
1814 }
1815
1816 bool kiku_receive_corpses(int pow)
1817 {
1818     // pow = necromancy * 4, ranges from 0 to 108
1819     dprf("kiku_receive_corpses() power: %d", pow);
1820
1821     // Kiku gives branch-appropriate corpses (like shadow creatures).
1822     // 1d2 at 0 Nec, up to 8 at 27 Nec.
1823     int expected_extra_corpses = 1 + random2(2) + random2(pow / 18);
1824     int corpse_delivery_radius = 1;
1825
1826     // We should get the same number of corpses
1827     // in a hallway as in an open room.
1828     int spaces_for_corpses = 0;
1829     for (radius_iterator ri(you.pos(), corpse_delivery_radius, C_ROUND,
1830                             LOS_NO_TRANS, true); ri; ++ri)
1831     {
1832         if (mons_class_can_pass(MONS_HUMAN, grd(*ri)))
1833             spaces_for_corpses++;
1834     }
1835     // floating over lava, heavy tomb abuse, etc
1836     if (!spaces_for_corpses)
1837         spaces_for_corpses++;
1838
1839     int percent_chance_a_square_receives_extra_corpse = // can be > 100
1840         int(float(expected_extra_corpses) / float(spaces_for_corpses) * 100.0);
1841
1842     int corpses_created = 0;
1843
1844     for (radius_iterator ri(you.pos(), corpse_delivery_radius, C_ROUND,
1845                             LOS_NO_TRANS); ri; ++ri)
1846     {
1847         bool square_is_walkable = mons_class_can_pass(MONS_HUMAN, grd(*ri));
1848         bool square_is_player_square = (*ri == you.pos());
1849         bool square_gets_corpse =
1850             random2(100) < percent_chance_a_square_receives_extra_corpse
1851             || square_is_player_square && random2(100) < 97;
1852
1853         if (!square_is_walkable || !square_gets_corpse)
1854             continue;
1855
1856         corpses_created++;
1857
1858         // Find an appropriate monster corpse for level and power.
1859         const int adjusted_power = min(pow / 4, random2(random2(pow)));
1860         // Pick a place based on the power.  This may be below the branch's
1861         // start, that's ok.
1862         const level_id lev(you.where_are_you, adjusted_power
1863                            - absdungeon_depth(you.where_are_you, 0));
1864         const monster_type mon_type = pick_local_corpsey_monster(lev);
1865         ASSERT(mons_class_can_be_zombified(mons_species(mon_type)));
1866
1867         // Create corpse object.
1868         monster dummy;
1869         dummy.type = mon_type;
1870         define_monster(&dummy);
1871         int index_of_corpse_created = get_mitm_slot();
1872
1873         if (index_of_corpse_created == NON_ITEM)
1874             break;
1875
1876         int valid_corpse = fill_out_corpse(&dummy,
1877                                            dummy.type,
1878                                            mitm[index_of_corpse_created],
1879                                            false);
1880         if (valid_corpse == -1)
1881         {
1882             mitm[index_of_corpse_created].clear();
1883             continue;
1884         }
1885
1886         // no scumming for hides
1887         if (mons_class_leaves_hide(mon_type))
1888             mitm[index_of_corpse_created].props[MANGLED_CORPSE_KEY] = true;
1889
1890         ASSERT(valid_corpse >= 0);
1891
1892         // Higher piety means fresher corpses.
1893         int rottedness = 200 -
1894             (!one_chance_in(10) ? random2(200 - you.piety)
1895                                 : random2(100 + random2(75)));
1896         mitm[index_of_corpse_created].special = rottedness;
1897
1898         // Place the corpse.
1899         move_item_to_grid(&index_of_corpse_created, *ri);
1900     }
1901
1902     if (corpses_created)
1903     {
1904         if (you_worship(GOD_KIKUBAAQUDGHA))
1905         {
1906             simple_god_message(corpses_created > 1 ? " delivers you corpses!"
1907                                                    : " delivers you a corpse!");
1908         }
1909         maybe_update_stashes();
1910         return true;
1911     }
1912     else
1913     {
1914         if (you_worship(GOD_KIKUBAAQUDGHA))
1915             simple_god_message(" can find no cadavers for you!");
1916         return false;
1917     }
1918 }
1919
1920 /**
1921  * Destroy a corpse at the player's location
1922  *
1923  * @return  True if a corpse was destroyed, false otherwise.
1924 */
1925 bool kiku_take_corpse()
1926 {
1927     for (int i = you.visible_igrd(you.pos()); i != NON_ITEM; i = mitm[i].link)
1928     {
1929         item_def &item(mitm[i]);
1930
1931         if (item.base_type != OBJ_CORPSES || item.sub_type != CORPSE_BODY)
1932             continue;
1933         item_was_destroyed(item);
1934         destroy_item(i);
1935         return true;
1936     }
1937
1938     return false;
1939 }
1940
1941 bool fedhas_passthrough_class(const monster_type mc)
1942 {
1943     return you_worship(GOD_FEDHAS)
1944            && mons_class_is_plant(mc)
1945            && mons_class_is_stationary(mc)
1946            && mc != MONS_SNAPLASHER_VINE
1947            && mc != MONS_SNAPLASHER_VINE_SEGMENT;
1948 }
1949
1950 // Fedhas allows worshipers to walk on top of stationary plants and
1951 // fungi.
1952 bool fedhas_passthrough(const monster* target)
1953 {
1954     return target
1955            && fedhas_passthrough_class(target->type)
1956            && (mons_species(target->type) != MONS_OKLOB_PLANT
1957                || target->attitude != ATT_HOSTILE);
1958 }
1959
1960 bool fedhas_passthrough(const monster_info* target)
1961 {
1962     return target
1963            && fedhas_passthrough_class(target->type)
1964            && (mons_species(target->type) != MONS_OKLOB_PLANT
1965                || target->attitude != ATT_HOSTILE);
1966 }
1967
1968 // Fedhas worshipers can shoot through non-hostile plants, can a
1969 // particular beam go through a particular monster?
1970 bool fedhas_shoot_through(const bolt& beam, const monster* victim)
1971 {
1972     actor *originator = beam.agent();
1973     if (!victim || !originator)
1974         return false;
1975
1976     bool origin_worships_fedhas;
1977     mon_attitude_type origin_attitude;
1978     if (originator->is_player())
1979     {
1980         origin_worships_fedhas = you_worship(GOD_FEDHAS);
1981         origin_attitude = ATT_FRIENDLY;
1982     }
1983     else
1984     {
1985         monster* temp = originator->as_monster();
1986         if (!temp)
1987             return false;
1988         origin_worships_fedhas = temp->god == GOD_FEDHAS;
1989         origin_attitude = temp->attitude;
1990     }
1991
1992     return origin_worships_fedhas
1993            && fedhas_protects(victim)
1994            && !beam.is_enchantment()
1995            && !(beam.is_explosion && beam.in_explosion_phase)
1996            && beam.name != "lightning arc"
1997            && (mons_atts_aligned(victim->attitude, origin_attitude)
1998                || victim->neutral());
1999 }
2000
2001 // Turns corpses in LOS into skeletons and grows toadstools on them.
2002 // Can also turn zombies into skeletons and destroy ghoul-type monsters.
2003 // Returns the number of corpses consumed.
2004 int fedhas_fungal_bloom()
2005 {
2006     int seen_mushrooms = 0;
2007     int seen_corpses = 0;
2008     int processed_count = 0;
2009     bool kills = false;
2010
2011     for (radius_iterator i(you.pos(), LOS_NO_TRANS); i; ++i)
2012     {
2013         monster* target = monster_at(*i);
2014         if (!can_spawn_mushrooms(*i))
2015             continue;
2016
2017         if (target && target->type != MONS_TOADSTOOL)
2018         {
2019             bool piety = !target->is_summoned();
2020             switch (mons_genus(target->mons_species()))
2021             {
2022             case MONS_ZOMBIE:
2023                 // Maybe turn a zombie into a skeleton.
2024                 if (mons_skeleton(mons_zombie_base(target)))
2025                 {
2026                     simple_monster_message(target, "'s flesh rots away.");
2027
2028                     downgrade_zombie_to_skeleton(target);
2029
2030                     behaviour_event(target, ME_ALERT, &you);
2031
2032                     if (piety)
2033                         processed_count++;
2034
2035                     continue;
2036                 }
2037                 // Else fall through and destroy the zombie.
2038                 // Ghoul-type monsters are always destroyed.
2039             case MONS_GHOUL:
2040             {
2041                 simple_monster_message(target, " rots away and dies.");
2042
2043                 kills = true;
2044
2045                 const coord_def pos = target->pos();
2046                 const int colour = target->colour;
2047                 const int corpse = monster_die(target, KILL_MISC, NON_MONSTER,
2048                                                true);
2049
2050                 // If a corpse didn't drop, create a toadstool.
2051                 // If one did drop, we will create toadstools from it as usual
2052                 // later on.
2053                 // Give neither piety nor toadstools for summoned creatures.
2054                 // Assumes that summoned creatures do not drop corpses (hence
2055                 // will not give piety in the next loop).
2056                 if (corpse < 0 && piety)
2057                 {
2058                     if (create_monster(
2059                                 mgen_data(MONS_TOADSTOOL,
2060                                           BEH_GOOD_NEUTRAL,
2061                                           &you,
2062                                           0,
2063                                           0,
2064                                           pos,
2065                                           MHITNOT,
2066                                           MG_FORCE_PLACE,
2067                                           GOD_NO_GOD,
2068                                           MONS_NO_MONSTER,
2069                                           0,
2070                                           colour),
2071                                           false))
2072                     {
2073                         seen_mushrooms++;
2074                     }
2075
2076                     processed_count++;
2077                     continue;
2078                 }
2079
2080                 // Verify that summoned creatures do not drop a corpse.
2081                 ASSERT(corpse < 0 || piety);
2082
2083                 break;
2084             }
2085
2086             default:
2087                 continue;
2088             }
2089         }
2090
2091         for (stack_iterator j(*i); j; ++j)
2092         {
2093             bool corpse_on_pos = false;
2094
2095             if (j->base_type == OBJ_CORPSES && j->sub_type == CORPSE_BODY)
2096             {
2097                 corpse_on_pos = true;
2098
2099                 const int trial_prob = mushroom_prob(*j);
2100                 const int target_count = 1 + binomial_generator(20, trial_prob);
2101                 int seen_per;
2102                 spawn_corpse_mushrooms(*j, target_count, seen_per,
2103                                        BEH_GOOD_NEUTRAL, true);
2104
2105                 // Either turn this corpse into a skeleton or destroy it.
2106                 if (mons_skeleton(j->mon_type))
2107                     turn_corpse_into_skeleton(*j);
2108                 else
2109                 {
2110                     item_was_destroyed(*j);
2111                     destroy_item(j->index());
2112                 }
2113
2114                 seen_mushrooms += seen_per;
2115
2116                 processed_count++;
2117             }
2118
2119             if (corpse_on_pos && you.see_cell(*i))
2120                 seen_corpses++;
2121         }
2122     }
2123
2124     if (seen_mushrooms > 0)
2125         mushroom_spawn_message(seen_mushrooms, seen_corpses);
2126
2127     if (kills)
2128         mpr("That felt like a moral victory.");
2129
2130     if (processed_count)
2131     {
2132         simple_god_message(" appreciates your contribution to the "
2133                            "ecosystem.");
2134         // Doubling the expected value per sacrifice to approximate the
2135         // extra piety gain blood god worshipers get for the initial kill.
2136         // -cao
2137
2138         int piety_gain = 0;
2139         for (int i = 0; i < processed_count * 2; ++i)
2140             piety_gain += random2(15); // avg 1.4 piety per corpse
2141         gain_piety(piety_gain, 10);
2142     }
2143
2144     return processed_count;
2145 }
2146
2147 static bool _create_plant(coord_def& target, int hp_adjust = 0)
2148 {
2149     if (actor_at(target) || !mons_class_can_pass(MONS_PLANT, grd(target)))
2150         return 0;
2151
2152     if (monster *plant = create_monster(mgen_data(MONS_PLANT,
2153                                             BEH_FRIENDLY,
2154                                             &you,
2155                                             0,
2156                                             0,
2157                                             target,
2158                                             MHITNOT,
2159                                             MG_FORCE_PLACE,
2160                                             GOD_FEDHAS)))
2161     {
2162         plant->flags |= MF_NO_REWARD;
2163         plant->flags |= MF_ATT_CHANGE_ATTEMPT;
2164
2165         mons_make_god_gift(plant, GOD_FEDHAS);
2166
2167         plant->max_hit_points += hp_adjust;
2168         plant->hit_points += hp_adjust;
2169
2170         if (you.see_cell(target))
2171         {
2172             if (hp_adjust)
2173             {
2174                 mprf("A plant, strengthened by %s, grows up from the ground.",
2175                      god_name(GOD_FEDHAS).c_str());
2176             }
2177             else
2178                 mpr("A plant grows up from the ground.");
2179         }
2180         return true;
2181     }
2182
2183     return false;
2184 }
2185
2186 #define SUNLIGHT_DURATION 80
2187
2188 spret_type fedhas_sunlight(bool fail)
2189 {
2190     dist spelld;
2191
2192     bolt temp_bolt;
2193     temp_bolt.colour = YELLOW;
2194
2195     direction_chooser_args args;
2196     args.restricts = DIR_TARGET;
2197     args.mode = TARG_HOSTILE_SUBMERGED;
2198     args.range = LOS_RADIUS;
2199     args.needs_path = false;
2200     args.may_target_monster = false;
2201     args.top_prompt = "Select sunlight destination.";
2202     direction(spelld, args);
2203
2204     if (!spelld.isValid)
2205         return SPRET_ABORT;
2206
2207     fail_check();
2208
2209     const coord_def base = spelld.target;
2210
2211     int revealed_count = 0;
2212
2213     for (adjacent_iterator ai(base, false); ai; ++ai)
2214     {
2215         if (!in_bounds(*ai) || cell_is_solid(*ai))
2216             continue;
2217
2218         for (size_t i = 0; i < env.sunlight.size(); ++i)
2219             if (env.sunlight[i].first == *ai)
2220             {
2221                 erase_any(env.sunlight, i);
2222                 break;
2223             }
2224         const int expiry = you.elapsed_time + (distance2(*ai, base) <= 1
2225                                                ? SUNLIGHT_DURATION
2226                                                : SUNLIGHT_DURATION / 2);
2227         env.sunlight.emplace_back(*ai, expiry);
2228
2229         temp_bolt.explosion_draw_cell(*ai);
2230
2231         monster *victim = monster_at(*ai);
2232         if (victim && you.see_cell(*ai) && !victim->visible_to(&you))
2233         {
2234             // Like entering/exiting angel halos, flipping autopickup would
2235             // be probably too much hassle.
2236             revealed_count++;
2237         }
2238
2239         if (victim)
2240             behaviour_event(victim, ME_ALERT, &you);
2241     }
2242
2243     {
2244         unwind_var<int> no_time(you.time_taken, 0);
2245         process_sunlights(false);
2246     }
2247
2248 #ifndef USE_TILE_LOCAL
2249     // Move the cursor out of the way (it looks weird).
2250     coord_def temp = grid2view(base);
2251     cgotoxy(temp.x, temp.y, GOTO_DNGN);
2252 #endif
2253     scaled_delay(200);
2254
2255     if (revealed_count)
2256     {
2257         mprf("In the bright light, you notice %s.", revealed_count == 1 ?
2258              "an invisible shape" : "some invisible shapes");
2259     }
2260
2261     return SPRET_SUCCESS;
2262 }
2263
2264 void process_sunlights(bool future)
2265 {
2266     int time_cap = future ? INT_MAX - SUNLIGHT_DURATION : you.elapsed_time;
2267
2268     int evap_count = 0;
2269
2270     for (int i = env.sunlight.size() - 1; i >= 0; --i)
2271     {
2272         coord_def c = env.sunlight[i].first;
2273         int until = env.sunlight[i].second;
2274
2275         if (until <= time_cap)
2276             erase_any(env.sunlight, i);
2277
2278         until = min(until, time_cap);
2279         int from = you.elapsed_time - you.time_taken;
2280
2281         // Deterministic roll, to guarantee evaporation when shined long enough.
2282         struct { level_id place; coord_def coord; int64_t game_start; } to_hash;
2283         to_hash.place = level_id::current();
2284         to_hash.coord = c;
2285         to_hash.game_start = you.birth_time;
2286         int h = hash32(&to_hash, sizeof(to_hash)) % SUNLIGHT_DURATION;
2287
2288         if ((from + h) / SUNLIGHT_DURATION == (until + h) / SUNLIGHT_DURATION)
2289             continue;
2290
2291         // Anything further on goes only on a successful evaporation roll, at
2292         // most once peer coord per invocation.
2293
2294         // If this is a water square we will evaporate it.
2295         dungeon_feature_type ftype = grd(c);
2296         dungeon_feature_type orig_type = ftype;
2297
2298         switch (ftype)
2299         {
2300         case DNGN_SHALLOW_WATER:
2301             ftype = DNGN_FLOOR;
2302             break;
2303
2304         case DNGN_DEEP_WATER:
2305             ftype = DNGN_SHALLOW_WATER;
2306             break;
2307
2308         default:
2309             break;
2310         }
2311
2312         if (orig_type != ftype)
2313         {
2314             dungeon_terrain_changed(c, ftype);
2315
2316             if (you.see_cell(c))
2317                 evap_count++;
2318
2319             // This is a little awkward but if we evaporated all the way to
2320             // the dungeon floor that may have given a monster
2321             // ENCH_AQUATIC_LAND, and if that happened the player should get
2322             // credit if the monster dies. The enchantment is inflicted via
2323             // the dungeon_terrain_changed call chain and that doesn't keep
2324             // track of what caused the terrain change. -cao
2325             monster* mons = monster_at(c);
2326             if (mons && ftype == DNGN_FLOOR
2327                 && mons->has_ench(ENCH_AQUATIC_LAND))
2328             {
2329                 mon_enchant temp = mons->get_ench(ENCH_AQUATIC_LAND);
2330                 temp.who = KC_YOU;
2331                 temp.source = MID_PLAYER;
2332                 mons->add_ench(temp);
2333             }
2334         }
2335     }
2336
2337     if (evap_count)
2338         mpr("Some water evaporates in the bright sunlight.");
2339
2340     invalidate_agrid(true);
2341 }
2342
2343 template<typename T>
2344 static bool less_second(const T & left, const T & right)
2345 {
2346     return left.second < right.second;
2347 }
2348
2349 typedef pair<coord_def, int> point_distance;
2350
2351 // Find the distance from origin to each of the targets, those results
2352 // are stored in distances (which is the same size as targets). Exclusion
2353 // is a set of points which are considered disconnected for the search.
2354 static void _path_distance(const coord_def& origin,
2355                            const vector<coord_def>& targets,
2356                            set<int> exclusion,
2357                            vector<int>& distances)
2358 {
2359     queue<point_distance> fringe;
2360     fringe.push(point_distance(origin,0));
2361     distances.clear();
2362     distances.resize(targets.size(), INT_MAX);
2363
2364     while (!fringe.empty())
2365     {
2366         point_distance current = fringe.front();
2367         fringe.pop();
2368
2369         // did we hit a target?
2370         for (unsigned i = 0; i < targets.size(); ++i)
2371         {
2372             if (current.first == targets[i])
2373             {
2374                 distances[i] = current.second;
2375                 break;
2376             }
2377         }
2378
2379         for (adjacent_iterator adj_it(current.first); adj_it; ++adj_it)
2380         {
2381             int idx = adj_it->x + adj_it->y * X_WIDTH;
2382             if (you.see_cell(*adj_it)
2383                 && !feat_is_solid(env.grid(*adj_it))
2384                 && *adj_it != you.pos()
2385                 && exclusion.insert(idx).second)
2386             {
2387                 monster* temp = monster_at(*adj_it);
2388                 if (!temp || (temp->attitude == ATT_HOSTILE
2389                               && !temp->is_stationary()))
2390                 {
2391                     fringe.push(point_distance(*adj_it, current.second+1));
2392                 }
2393             }
2394         }
2395     }
2396 }
2397
2398 // Find the minimum distance from each point of origin to one of the targets
2399 // The distance is stored in 'distances', which is the same size as origins.
2400 static void _point_point_distance(const vector<coord_def>& origins,
2401                                   const vector<coord_def>& targets,
2402                                   vector<int>& distances)
2403 {
2404     distances.clear();
2405     distances.resize(origins.size(), INT_MAX);
2406
2407     // Consider all points of origin as blocked (you can search outward
2408     // from one, but you can't form a path across a different one).
2409     set<int> base_exclusions;
2410     for (coord_def c : origins)
2411     {
2412         int idx = c.x + c.y * X_WIDTH;
2413         base_exclusions.insert(idx);
2414     }
2415
2416     vector<int> current_distances;
2417     for (unsigned i = 0; i < origins.size(); ++i)
2418     {
2419         // Find the distance from the point of origin to each of the targets.
2420         _path_distance(origins[i], targets, base_exclusions,
2421                        current_distances);
2422
2423         // Find the smallest of those distances
2424         int min_dist = current_distances[0];
2425         for (unsigned j = 1; j < current_distances.size(); ++j)
2426             if (current_distances[j] < min_dist)
2427                 min_dist = current_distances[j];
2428
2429         distances[i] = min_dist;
2430     }
2431 }
2432
2433 // So the idea is we want to decide which adjacent tiles are in the most 'danger'
2434 // We claim danger is proportional to the minimum distances from the point to a
2435 // (hostile) monster. This function carries out at most 7 searches to calculate
2436 // the distances in question.
2437 bool prioritise_adjacent(const coord_def &target, vector<coord_def>& candidates)
2438 {
2439     radius_iterator los_it(target, LOS_NO_TRANS, true);
2440
2441     vector<coord_def> mons_positions;
2442     // collect hostile monster positions in LOS
2443     for (; los_it; ++los_it)
2444     {
2445         monster* hostile = monster_at(*los_it);
2446
2447         if (hostile && hostile->attitude == ATT_HOSTILE
2448             && you.can_see(hostile))
2449         {
2450             mons_positions.push_back(hostile->pos());
2451         }
2452     }
2453
2454     if (mons_positions.empty())
2455     {
2456         shuffle_array(candidates);
2457         return true;
2458     }
2459
2460     vector<int> distances;
2461
2462     _point_point_distance(candidates, mons_positions, distances);
2463
2464     vector<point_distance> possible_moves(candidates.size());
2465
2466     for (unsigned i = 0; i < possible_moves.size(); ++i)
2467     {
2468         possible_moves[i].first  = candidates[i];
2469         possible_moves[i].second = distances[i];
2470     }
2471
2472     sort(possible_moves.begin(), possible_moves.end(),
2473               less_second<point_distance>);
2474
2475     for (unsigned i = 0; i < candidates.size(); ++i)
2476         candidates[i] = possible_moves[i].first;
2477
2478     return true;
2479 }
2480
2481 static bool _prompt_amount(int max, int& selected, const string& prompt)
2482 {
2483     selected = max;
2484     while (true)
2485     {
2486         msg::streams(MSGCH_PROMPT) << prompt << " (" << max << " max) " << endl;
2487
2488         const int keyin = get_ch();
2489
2490         // Cancel
2491         if (key_is_escape(keyin) || keyin == ' ' || keyin == '0')
2492         {
2493             canned_msg(MSG_OK);
2494             return false;
2495         }
2496
2497         // Default is max
2498         if (keyin == '\n' || keyin == '\r')
2499         {
2500             selected = max;
2501             return true;
2502         }
2503
2504         // Otherwise they should enter a digit
2505         if (isadigit(keyin))
2506         {
2507             selected = keyin - '0';
2508             if (selected > 0 && selected <= max)
2509                 return true;
2510         }
2511         // else they entered some garbage?
2512     }
2513
2514     return false;
2515 }
2516
2517 static int _collect_fruit(vector<pair<int,int> >& available_fruit)
2518 {
2519     int total = 0;
2520
2521     for (int i = 0; i < ENDOFPACK; i++)
2522     {
2523         if (you.inv[i].defined() && is_fruit(you.inv[i]))
2524         {
2525             total += you.inv[i].quantity;
2526             available_fruit.emplace_back(you.inv[i].quantity, i);
2527         }
2528     }
2529     sort(available_fruit.begin(), available_fruit.end());
2530
2531     return total;
2532 }
2533
2534 static void _decrease_amount(vector<pair<int, int> >& available, int amount)
2535 {
2536     const int total_decrease = amount;
2537     for (const auto &avail : available)
2538     {
2539         const int decrease_amount = min(avail.first, amount);
2540         amount -= decrease_amount;
2541         dec_inv_item_quantity(avail.second, decrease_amount);
2542     }
2543     if (total_decrease > 1)
2544         mprf("%d pieces of fruit are consumed!", total_decrease);
2545     else
2546         mpr("A piece of fruit is consumed!");
2547 }
2548
2549 // Create a ring or partial ring around the caster.  The user is
2550 // prompted to select a stack of fruit, and then plants are placed on open
2551 // squares adjacent to the user.  Of course, one piece of fruit is
2552 // consumed per plant, so a complete ring may not be formed.
2553 bool fedhas_plant_ring_from_fruit()
2554 {
2555     // How much fruit is available?
2556     vector<pair<int, int> > collected_fruit;
2557     int total_fruit = _collect_fruit(collected_fruit);
2558
2559     // How many adjacent open spaces are there?
2560     vector<coord_def> adjacent;
2561     for (adjacent_iterator adj_it(you.pos()); adj_it; ++adj_it)
2562     {
2563         if (monster_habitable_grid(MONS_PLANT, env.grid(*adj_it))
2564             && !actor_at(*adj_it))
2565         {
2566             adjacent.push_back(*adj_it);
2567         }
2568     }
2569
2570     const int max_use = min(total_fruit, static_cast<int>(adjacent.size()));
2571
2572     // Don't prompt if we can't do anything (due to having no fruit or
2573     // no squares to place plants on).
2574     if (max_use == 0)
2575     {
2576         if (adjacent.empty())
2577             mpr("No empty adjacent squares.");
2578         else
2579             mpr("No fruit available.");
2580
2581         return false;
2582     }
2583
2584     prioritise_adjacent(you.pos(), adjacent);
2585
2586     // Screwing around with display code I don't really understand. -cao
2587     targetter_smite range(&you, 1);
2588     range_view_annotator show_range(&range);
2589
2590     for (int i = 0; i < max_use; ++i)
2591     {
2592 #ifndef USE_TILE_LOCAL
2593         coord_def temp = grid2view(adjacent[i]);
2594         cgotoxy(temp.x, temp.y, GOTO_DNGN);
2595         put_colour_ch(GREEN, '1' + i);
2596 #endif
2597 #ifdef USE_TILE
2598         tiles.add_overlay(adjacent[i], TILE_INDICATOR + i);
2599 #endif
2600     }
2601
2602     // And how many plants does the user want to create?
2603     int target_count;
2604     if (!_prompt_amount(max_use, target_count,
2605                         "How many plants will you create?"))
2606     {
2607         // User cancelled at the prompt.
2608         return false;
2609     }
2610
2611     const int hp_adjust = you.skill(SK_INVOCATIONS, 10);
2612
2613     // The user entered a number, remove all number overlays which
2614     // are higher than that number.
2615 #ifndef USE_TILE_LOCAL
2616     unsigned not_used = adjacent.size() - unsigned(target_count);
2617     for (unsigned i = adjacent.size() - not_used; i < adjacent.size(); i++)
2618         view_update_at(adjacent[i]);
2619 #endif
2620 #ifdef USE_TILE
2621     // For tiles we have to clear all overlays and redraw the ones
2622     // we want.
2623     tiles.clear_overlays();
2624     for (int i = 0; i < target_count; ++i)
2625         tiles.add_overlay(adjacent[i], TILE_INDICATOR + i);
2626 #endif
2627
2628     int created_count = 0;
2629     for (int i = 0; i < target_count; ++i)
2630     {
2631         if (_create_plant(adjacent[i], hp_adjust))
2632             created_count++;
2633
2634         // Clear the overlay and draw the plant we just placed.
2635         // This is somewhat more complicated in tiles.
2636         view_update_at(adjacent[i]);
2637 #ifdef USE_TILE
2638         tiles.clear_overlays();
2639         for (int j = i + 1; j < target_count; ++j)
2640             tiles.add_overlay(adjacent[j], TILE_INDICATOR + j);
2641         viewwindow(false);
2642 #endif
2643         scaled_delay(200);
2644     }
2645
2646     if (created_count)
2647         _decrease_amount(collected_fruit, created_count);
2648     else
2649         canned_msg(MSG_NOTHING_HAPPENS);
2650
2651     return created_count;
2652 }
2653
2654 // Create a circle of water around the target, with a radius of
2655 // approximately 2.  This turns normal floor tiles into shallow water
2656 // and turns (unoccupied) shallow water into deep water.  There is a
2657 // chance of spawning plants or fungus on unoccupied dry floor tiles
2658 // outside of the rainfall area.  Return the number of plants/fungi
2659 // created.
2660 int fedhas_rain(const coord_def &target)
2661 {
2662     int spawned_count = 0;
2663     int processed_count = 0;
2664
2665     for (radius_iterator rad(target, LOS_NO_TRANS, true); rad; ++rad)
2666     {
2667         // Adjust the shape of the rainfall slightly to make it look
2668         // nicer.  I want a threshold of 2.5 on the euclidean distance,
2669         // so a threshold of 6 prior to the sqrt is close enough.
2670         int rain_thresh = 6;
2671         coord_def local = *rad - target;
2672
2673         dungeon_feature_type ftype = grd(*rad);
2674
2675         if (local.abs() > rain_thresh)
2676         {
2677             // Maybe spawn a plant on (dry, open) squares that are in
2678             // LOS but outside the rainfall area.  In open space, there
2679             // are 213 squares in LOS, and we are going to drop water on
2680             // (25-4) of those, so if we want x plants to spawn on
2681             // average in open space, the trial probability should be
2682             // x/192.
2683             if (x_chance_in_y(5, 192)
2684                 && !actor_at(*rad)
2685                 && ftype == DNGN_FLOOR)
2686             {
2687                 if (create_monster(mgen_data(
2688                                       coinflip() ? MONS_PLANT : MONS_FUNGUS,
2689                                       BEH_GOOD_NEUTRAL,
2690                                       &you,
2691                                       0,
2692                                       0,
2693                                       *rad,
2694                                       MHITNOT,
2695                                       MG_FORCE_PLACE,
2696                                       GOD_FEDHAS)))
2697                 {
2698                     spawned_count++;
2699                 }
2700
2701                 processed_count++;
2702             }
2703
2704             continue;
2705         }
2706
2707         // Turn regular floor squares only into shallow water.
2708         if (ftype == DNGN_FLOOR)
2709         {
2710             dungeon_terrain_changed(*rad, DNGN_SHALLOW_WATER);
2711
2712             processed_count++;
2713         }
2714         // We can also turn shallow water into deep water, but we're
2715         // just going to skip cases where there is something on the
2716         // shallow water.  Destroying items will probably be annoying,
2717         // and insta-killing monsters is clearly out of the question.
2718         else if (!actor_at(*rad)
2719                  && igrd(*rad) == NON_ITEM
2720                  && ftype == DNGN_SHALLOW_WATER)
2721         {
2722             dungeon_terrain_changed(*rad, DNGN_DEEP_WATER);
2723
2724             processed_count++;
2725         }
2726
2727         if (!feat_is_solid(ftype))
2728         {
2729             // Maybe place a raincloud.
2730             //
2731             // The rainfall area is 20 (5*5 - 4 (corners) - 1 (center));
2732             // the expected number of clouds generated by a fixed chance
2733             // per tile is 20 * p = expected.  Say an Invocations skill
2734             // of 27 gives expected 5 clouds.
2735             int max_expected = 5;
2736             int expected = you.skill_rdiv(SK_INVOCATIONS, max_expected, 27);
2737
2738             if (x_chance_in_y(expected, 20))
2739             {
2740                 place_cloud(CLOUD_RAIN, *rad, 10, &you);
2741
2742                 processed_count++;
2743             }
2744         }
2745     }
2746
2747     if (spawned_count > 0)
2748     {
2749         mprf("%s grow%s in the rain.",
2750              (spawned_count > 1 ? "Some plants" : "A plant"),
2751              (spawned_count > 1 ? "" : "s"));
2752     }
2753
2754     return processed_count;
2755 }
2756
2757 int count_corpses_in_los(vector<stack_iterator> *positions)
2758 {
2759     int count = 0;
2760
2761     for (radius_iterator rad(you.pos(), LOS_NO_TRANS, true); rad;
2762          ++rad)
2763     {
2764         if (actor_at(*rad))
2765             continue;
2766
2767         for (stack_iterator stack_it(*rad); stack_it; ++stack_it)
2768         {
2769             if (stack_it->base_type == OBJ_CORPSES
2770                 && stack_it->sub_type == CORPSE_BODY)
2771             {
2772                 if (positions)
2773                     positions->push_back(stack_it);
2774                 count++;
2775                 break;
2776             }
2777         }
2778     }
2779
2780     return count;
2781 }
2782
2783 int fedhas_check_corpse_spores(bool quiet)
2784 {
2785     vector<stack_iterator> positions;
2786     int count = count_corpses_in_los(&positions);
2787
2788     if (quiet || count == 0)
2789         return count;
2790
2791     viewwindow(false);
2792     for (const stack_iterator &si : positions)
2793     {
2794 #ifndef USE_TILE_LOCAL
2795         coord_def temp = grid2view(si->pos);
2796         cgotoxy(temp.x, temp.y, GOTO_DNGN);
2797
2798         unsigned colour = GREEN | COLFLAG_FRIENDLY_MONSTER;
2799         colour = real_colour(colour);
2800
2801         unsigned character = mons_char(MONS_GIANT_SPORE);
2802         put_colour_ch(colour, character);
2803 #endif
2804 #ifdef USE_TILE
2805         tiles.add_overlay(si->pos, TILE_SPORE_OVERLAY);
2806 #endif
2807     }
2808
2809     if (yesnoquit("Will you create these spores?", true, 'y') <= 0)
2810     {
2811         viewwindow(false);
2812         return -1;
2813     }
2814
2815     return count;
2816 }
2817
2818 // Destroy corpses in the player's LOS (first corpse on a stack only)
2819 // and make 1 giant spore per corpse.  Spores are given the input as
2820 // their starting behavior; the function returns the number of corpses
2821 // processed.
2822 int fedhas_corpse_spores(beh_type attitude)
2823 {
2824     vector<stack_iterator> positions;
2825     int count = count_corpses_in_los(&positions);
2826     ASSERT(attitude != BEH_FRIENDLY || count > 0);
2827
2828     if (count == 0)
2829         return count;
2830
2831     for (const stack_iterator &si : positions)
2832     {
2833         count++;
2834
2835         if (monster *plant = create_monster(mgen_data(MONS_GIANT_SPORE,
2836                                                attitude,
2837                                                &you,
2838                                                0,
2839                                                0,
2840                                                si->pos,
2841                                                MHITNOT,
2842                                                MG_FORCE_PLACE,
2843                                                GOD_FEDHAS)))
2844         {
2845             plant->flags |= MF_NO_REWARD;
2846
2847             if (attitude == BEH_FRIENDLY)
2848             {
2849                 plant->flags |= MF_ATT_CHANGE_ATTEMPT;
2850
2851                 mons_make_god_gift(plant, GOD_FEDHAS);
2852
2853                 plant->behaviour = BEH_WANDER;
2854                 plant->foe = MHITNOT;
2855             }
2856         }
2857
2858         if (mons_skeleton(si->mon_type))
2859             turn_corpse_into_skeleton(*si);
2860         else
2861         {
2862             item_was_destroyed(*si);
2863             destroy_item(si->index());
2864         }
2865     }
2866
2867     viewwindow(false);
2868
2869     return count;
2870 }
2871
2872 struct monster_conversion
2873 {
2874     monster_conversion() :
2875         base_monster(nullptr),
2876         piety_cost(0),
2877         fruit_cost(0)
2878     {
2879     }
2880
2881     monster* base_monster;
2882     int piety_cost;
2883     int fruit_cost;
2884     monster_type new_type;
2885 };
2886
2887 // Given a monster (which should be a plant/fungus), see if
2888 // fedhas_evolve_flora() can upgrade it, and set up a monster_conversion
2889 // structure for it.  Return true (and fill in possible_monster) if the
2890 // monster can be upgraded, and return false otherwise.
2891 static bool _possible_evolution(const monster* input,
2892                                 monster_conversion& possible_monster)
2893 {
2894     switch (input->type)
2895     {
2896     case MONS_PLANT:
2897     case MONS_BUSH:
2898     case MONS_BURNING_BUSH:
2899         possible_monster.new_type = MONS_OKLOB_PLANT;
2900         possible_monster.fruit_cost = 1;
2901         break;
2902
2903     case MONS_OKLOB_SAPLING:
2904         possible_monster.new_type = MONS_OKLOB_PLANT;
2905         possible_monster.piety_cost = 4;
2906         break;
2907
2908     case MONS_FUNGUS:
2909     case MONS_TOADSTOOL:
2910         possible_monster.new_type = MONS_WANDERING_MUSHROOM;
2911         possible_monster.piety_cost = 3;
2912         break;
2913
2914     case MONS_BALLISTOMYCETE:
2915         possible_monster.new_type = MONS_HYPERACTIVE_BALLISTOMYCETE;
2916         possible_monster.piety_cost = 4;
2917         break;
2918
2919     default:
2920         return false;
2921     }
2922
2923     return true;
2924 }
2925
2926 bool mons_is_evolvable(const monster* mon)
2927 {
2928     monster_conversion temp;
2929     return _possible_evolution(mon, temp);
2930 }
2931
2932 static bool _place_ballisto(const coord_def& pos)
2933 {
2934     if (monster *plant = create_monster(mgen_data(MONS_BALLISTOMYCETE,
2935                                                       BEH_FRIENDLY,
2936                                                       &you,
2937                                                       0,
2938                                                       0,
2939                                                       pos,
2940                                                       MHITNOT,
2941                                                       MG_FORCE_PLACE,
2942                                                       GOD_FEDHAS)))
2943     {
2944         plant->flags |= MF_NO_REWARD;
2945         plant->flags |= MF_ATT_CHANGE_ATTEMPT;
2946
2947         mons_make_god_gift(plant, GOD_FEDHAS);
2948
2949         remove_mold(pos);
2950         mpr("The mold grows into a ballistomycete.");
2951         mpr("Your piety has decreased.");
2952         lose_piety(1);
2953         return true;
2954     }
2955
2956     // Monster placement failing should be quite unusual, but it could happen.
2957     // Not entirely sure what to say about it, but a more informative message
2958     // might be good. -cao
2959     canned_msg(MSG_NOTHING_HAPPENS);
2960     return false;
2961 }
2962
2963 #define FEDHAS_EVOLVE_TARGET_KEY "fedhas_evolve_target"
2964
2965 bool fedhas_check_evolve_flora(bool quiet)
2966 {
2967     monster_conversion upgrade;
2968
2969     // This is a little sloppy, but cancel early if nothing useful is in
2970     // range.
2971     bool in_range = false;
2972     for (radius_iterator rad(you.pos(), LOS_NO_TRANS, true); rad; ++rad)
2973     {
2974         const monster* temp = monster_at(*rad);
2975         if (is_moldy(*rad) && mons_class_can_pass(MONS_BALLISTOMYCETE,
2976                                                   env.grid(*rad))
2977             || temp && mons_is_evolvable(temp))
2978         {
2979             in_range = true;
2980             break;
2981         }
2982     }
2983
2984     if (!in_range)
2985     {
2986         if (!quiet)
2987             mpr("No evolvable flora in sight.");
2988         return false;
2989     }
2990
2991     if (quiet) // just checking if there's something we can evolve here
2992         return true;
2993
2994     dist spelld;
2995
2996     direction_chooser_args args;
2997     args.restricts = DIR_TARGET;
2998     args.mode = TARG_EVOLVABLE_PLANTS;
2999     args.range = LOS_RADIUS;
3000     args.needs_path = false;
3001     args.may_target_monster = false;
3002     args.cancel_at_self = true;
3003     args.show_floor_desc = true;
3004     args.top_prompt = "Select plant or fungus to evolve.";
3005
3006     direction(spelld, args);
3007
3008     if (!spelld.isValid)
3009     {
3010         // Check for user cancel.
3011         canned_msg(MSG_OK);
3012         return false;
3013     }
3014
3015     monster* const plant = monster_at(spelld.target);
3016
3017     if (!plant)
3018     {
3019         if (!is_moldy(spelld.target)
3020             || !mons_class_can_pass(MONS_BALLISTOMYCETE,
3021                                     env.grid(spelld.target)))
3022         {
3023             if (feat_is_tree(env.grid(spelld.target)))
3024                 mpr("The tree has already reached the pinnacle of evolution.");
3025             else
3026                 mpr("You must target a plant or fungus.");
3027             return false;
3028         }
3029         you.props[FEDHAS_EVOLVE_TARGET_KEY].get_coord() = spelld.target;
3030         return true;
3031     }
3032
3033     if (!_possible_evolution(plant, upgrade))
3034     {
3035         if (plant->type == MONS_GIANT_SPORE)
3036             mpr("You can evolve only complete plants, not seeds.");
3037         else  if (mons_is_plant(plant))
3038         {
3039             simple_monster_message(plant, " has already reached the pinnacle"
3040                                    " of evolution.");
3041         }
3042         else
3043             mpr("Only plants or fungi may be evolved.");
3044
3045         return false;
3046     }
3047
3048     vector<pair<int, int> > collected_fruit;
3049     if (upgrade.fruit_cost)
3050     {
3051         const int total_fruit = _collect_fruit(collected_fruit);
3052
3053         if (total_fruit < upgrade.fruit_cost)
3054         {
3055             mpr("Not enough fruit available.");
3056             return false;
3057         }
3058     }
3059
3060     if (upgrade.piety_cost && upgrade.piety_cost > you.piety)
3061     {
3062         mpr("Not enough piety available.");
3063         return false;
3064     }
3065
3066     you.props[FEDHAS_EVOLVE_TARGET_KEY].get_coord() = spelld.target;
3067     return true;
3068 }
3069
3070 void fedhas_evolve_flora()
3071 {
3072     monster_conversion upgrade;
3073     const coord_def target = you.props[FEDHAS_EVOLVE_TARGET_KEY].get_coord();
3074     you.props.erase(FEDHAS_EVOLVE_TARGET_KEY);
3075
3076     monster* const plant = monster_at(target);
3077
3078     if (!plant)
3079     {
3080         ASSERT(is_moldy(target));
3081         _place_ballisto(target);
3082         return;
3083     }
3084
3085     ASSERT(_possible_evolution(plant, upgrade));
3086
3087     switch (plant->type)
3088     {
3089     case MONS_PLANT:
3090     case MONS_BUSH:
3091     {
3092         string evolve_desc = " can now spit acid";
3093         int skill = you.skill(SK_INVOCATIONS);
3094         if (skill >= 20)
3095             evolve_desc += " continuously";
3096         else if (skill >= 15)
3097             evolve_desc += " quickly";
3098         else if (skill >= 10)
3099             evolve_desc += " rather quickly";
3100         else if (skill >= 5)
3101             evolve_desc += " somewhat quickly";
3102         evolve_desc += ".";
3103
3104         simple_monster_message(plant, evolve_desc.c_str());
3105         break;
3106     }
3107
3108     case MONS_OKLOB_SAPLING:
3109         simple_monster_message(plant, " appears stronger.");
3110         break;
3111
3112     case MONS_FUNGUS:
3113     case MONS_TOADSTOOL:
3114         simple_monster_message(plant, " can now pick up its mycelia and move.");
3115         break;
3116
3117     case MONS_BALLISTOMYCETE:
3118         simple_monster_message(plant, " appears agitated.");
3119         env.level_state |= LSTATE_GLOW_MOLD;
3120         break;
3121
3122     default:
3123         break;
3124     }
3125
3126     plant->upgrade_type(upgrade.new_type, true, true);
3127
3128     plant->flags |= MF_NO_REWARD;
3129     plant->flags |= MF_ATT_CHANGE_ATTEMPT;
3130
3131     mons_make_god_gift(plant, GOD_FEDHAS);
3132
3133     plant->attitude = ATT_FRIENDLY;
3134
3135     behaviour_event(plant, ME_ALERT);
3136     mons_att_changed(plant);
3137
3138     // Try to remove slowly dying in case we are upgrading a
3139     // toadstool, and spore production in case we are upgrading a
3140     // ballistomycete.
3141     plant->del_ench(ENCH_SLOWLY_DYING);
3142     plant->del_ench(ENCH_SPORE_PRODUCTION);
3143
3144     if (plant->type == MONS_HYPERACTIVE_BALLISTOMYCETE)
3145         plant->add_ench(ENCH_EXPLODING);
3146     else if (plant->type == MONS_OKLOB_PLANT)
3147     {
3148         // frequency will be set by set_hit_dice below
3149         plant->spells = { { SPELL_SPIT_ACID, 0, MON_SPELL_NATURAL } };
3150     }
3151
3152     plant->set_hit_dice(plant->get_experience_level()
3153                         + you.skill_rdiv(SK_INVOCATIONS));
3154
3155     if (upgrade.fruit_cost)
3156     {
3157         vector<pair<int, int> > collected_fruit;
3158         _collect_fruit(collected_fruit);
3159         _decrease_amount(collected_fruit, upgrade.fruit_cost);
3160     }
3161
3162     if (upgrade.piety_cost)
3163     {
3164         lose_piety(upgrade.piety_cost);
3165         mpr("Your piety has decreased.");
3166     }
3167 }
3168
3169 static int _lugonu_warp_monster(monster* mon, int pow)
3170 {
3171     if (mon == nullptr)
3172         return 0;
3173
3174     if (coinflip())
3175         return 0;
3176
3177     if (!mon->friendly())
3178         behaviour_event(mon, ME_ANNOY, &you);
3179
3180     const int damage = 1 + random2(pow / 6);
3181     if (mons_genus(mon->type) == MONS_BLINK_FROG)
3182     {
3183         mprf("%s basks in the distortional energy.",
3184              mon->name(DESC_THE).c_str());
3185         mon->heal(damage, false);
3186     }
3187     else
3188     {
3189         mon->hurt(&you, damage);
3190         if (!mon->alive())
3191             return 1;
3192     }
3193
3194     if (!mon->no_tele(true, false))
3195         mon->blink();
3196
3197     return 1;
3198 }
3199
3200 static void _lugonu_warp_area(int pow)
3201 {
3202     apply_monsters_around_square(_lugonu_warp_monster, you.pos(), pow);
3203 }
3204
3205 void lugonu_bend_space()
3206 {
3207     const int pow = 4 + skill_bump(SK_INVOCATIONS);
3208     const bool area_warp = random2(pow) > 9;
3209
3210     mprf("Space bends %saround you!", area_warp ? "sharply " : "");
3211
3212     if (area_warp)
3213         _lugonu_warp_area(pow);
3214
3215     random_blink(false, true, true);
3216
3217     const int damage = roll_dice(1, 4);
3218     ouch(damage, KILLED_BY_WILD_MAGIC, MID_NOBODY, "a spatial distortion");
3219 }
3220
3221 void cheibriados_time_bend(int pow)
3222 {
3223     mpr("The flow of time bends around you.");
3224
3225     for (adjacent_iterator ai(you.pos()); ai; ++ai)
3226     {
3227         monster* mon = monster_at(*ai);
3228         if (mon && !mon->is_stationary())
3229         {
3230             int res_margin = roll_dice(mon->get_hit_dice(), 3)
3231                              - random2avg(pow, 2);
3232             if (res_margin > 0)
3233             {
3234                 mprf("%s%s",
3235                      mon->name(DESC_THE).c_str(),
3236                      mon->resist_margin_phrase(res_margin).c_str());
3237                 continue;
3238             }
3239
3240             simple_god_message(
3241                 make_stringf(" rebukes %s.",
3242                              mon->name(DESC_THE).c_str()).c_str(),
3243                              GOD_CHEIBRIADOS);
3244             do_slow_monster(mon, &you);
3245         }
3246     }
3247 }
3248
3249 static int _slouchable(coord_def where, int pow, int, actor* agent)
3250 {
3251     monster* mon = monster_at(where);
3252     if (mon == nullptr || mon->is_stationary() || mon->cannot_move()
3253         || mons_is_projectile(mon->type)
3254         || mon->asleep() && !mons_is_confused(mon))
3255     {
3256         return 0;
3257     }
3258
3259     int dmg = (mon->speed - 1000/player_movement_speed()/player_speed());
3260     return (dmg > 0) ? 1 : 0;
3261 }
3262
3263 static bool _act_slouchable(const actor *act)
3264 {
3265     if (act->is_player())
3266         return false;  // too slow-witted
3267     return _slouchable(act->pos(), 0, 0, 0);
3268 }
3269
3270 static int _slouch_monsters(coord_def where, int pow, int dummy, actor* agent)
3271 {
3272     if (!_slouchable(where, pow, dummy, agent))
3273         return 0;
3274
3275     monster* mon = monster_at(where);
3276     ASSERT(mon);
3277
3278     int dmg = (mon->speed - 1000/player_movement_speed()/player_speed());
3279     dmg = (dmg > 0 ? roll_dice(dmg*4, 3)/2 : 0);
3280
3281     mon->hurt(agent, dmg, BEAM_MMISSILE, KILLED_BY_BEAM, "", "", true);
3282     return 1;
3283 }
3284
3285 bool cheibriados_slouch(int pow)
3286 {
3287     int count = apply_area_visible(_slouchable, pow, &you);
3288     if (!count)
3289         if (!yesno("There's no one hasty visible. Invoke Slouch anyway?",
3290                    true, 'n'))
3291         {
3292             return false;
3293         }
3294
3295     targetter_los hitfunc(&you, LOS_DEFAULT);
3296     if (stop_attack_prompt(hitfunc, "harm", _act_slouchable))
3297         return false;
3298
3299     mpr("You can feel time thicken for a moment.");
3300     dprf("your speed is %d", player_movement_speed());
3301
3302     apply_area_visible(_slouch_monsters, pow, &you);
3303     return true;
3304 }
3305
3306 // A low-duration step from time, allowing monsters to get closer
3307 // to the player safely.
3308 void cheibriados_temporal_distortion()
3309 {
3310     const coord_def old_pos = you.pos();
3311
3312     const int time = 3 + random2(3);
3313     you.moveto(coord_def(0, 0));
3314     you.duration[DUR_TIME_STEP] = time;
3315
3316     do
3317     {
3318         run_environment_effects();
3319         handle_monsters();
3320         manage_clouds();
3321     }
3322     while (--you.duration[DUR_TIME_STEP] > 0);
3323
3324     monster* mon;
3325     if (mon = monster_at(old_pos))
3326     {
3327         mon->blink();
3328         if (mon = monster_at(old_pos))
3329             mon->teleport(true);
3330     }
3331
3332     you.moveto(old_pos);
3333     you.duration[DUR_TIME_STEP] = 0;
3334
3335     mpr("You warp the flow of time around you!");
3336 }
3337
3338 void cheibriados_time_step(int pow) // pow is the number of turns to skip
3339 {
3340     const coord_def old_pos = you.pos();
3341
3342     mpr("You step out of the flow of time.");
3343     flash_view(UA_PLAYER, LIGHTBLUE);
3344     you.moveto(coord_def(0, 0));
3345     you.duration[DUR_TIME_STEP] = pow;
3346
3347     you.time_taken = 10;
3348     do
3349     {
3350         run_environment_effects();
3351         handle_monsters();
3352         manage_clouds();
3353     }
3354     while (--you.duration[DUR_TIME_STEP] > 0);
3355     // Update corpses, etc.  This does also shift monsters, but only by
3356     // a tiny bit.
3357     update_level(pow * 10);
3358
3359 #ifndef USE_TILE_LOCAL
3360     scaled_delay(1000);
3361 #endif
3362
3363     monster* mon;
3364     if (mon = monster_at(old_pos))
3365     {
3366         mon->blink();
3367         if (mon = monster_at(old_pos))
3368             mon->teleport(true);
3369     }
3370
3371     you.moveto(old_pos);
3372     you.duration[DUR_TIME_STEP] = 0;
3373
3374     flash_view(UA_PLAYER, 0);
3375     mpr("You return to the normal time flow.");
3376 }
3377
3378 bool ashenzari_transfer_knowledge()
3379 {
3380     if (you.transfer_skill_points > 0 && !ashenzari_end_transfer())
3381         return false;
3382
3383     while (true)
3384     {
3385         skill_menu(SKMF_RESKILL_FROM);
3386         if (is_invalid_skill(you.transfer_from_skill))
3387         {
3388             redraw_screen();
3389             return false;
3390         }
3391
3392         you.transfer_skill_points = skill_transfer_amount(
3393                                                     you.transfer_from_skill);
3394
3395         skill_menu(SKMF_RESKILL_TO);
3396         if (is_invalid_skill(you.transfer_to_skill))
3397         {
3398             you.transfer_from_skill = SK_NONE;
3399             you.transfer_skill_points = 0;
3400             continue;
3401         }
3402
3403         break;
3404     }
3405
3406     // We reset the view to force view transfer next time.
3407     you.skill_menu_view = SKM_NONE;
3408
3409     mprf("As you forget about %s, you feel ready to understand %s.",
3410          skill_name(you.transfer_from_skill),
3411          skill_name(you.transfer_to_skill));
3412
3413     you.transfer_total_skill_points = you.transfer_skill_points;
3414
3415     redraw_screen();
3416     return true;
3417 }
3418
3419 bool ashenzari_end_transfer(bool finished, bool force)
3420 {
3421     if (!force && !finished)
3422     {
3423         mprf("You are currently transferring knowledge from %s to %s.",
3424              skill_name(you.transfer_from_skill),
3425              skill_name(you.transfer_to_skill));
3426         if (!yesno("Are you sure you want to cancel the transfer?", false, 'n'))
3427         {
3428             canned_msg(MSG_OK);
3429             return false;
3430         }
3431     }
3432
3433     mprf("You %s forgetting about %s and learning about %s.",
3434          finished ? "have finished" : "stop",
3435          skill_name(you.transfer_from_skill),
3436          skill_name(you.transfer_to_skill));
3437     you.transfer_from_skill = SK_NONE;
3438     you.transfer_to_skill = SK_NONE;
3439     you.transfer_skill_points = 0;
3440     you.transfer_total_skill_points = 0;
3441     return true;
3442 }
3443
3444 bool can_convert_to_beogh()
3445 {
3446     if (silenced(you.pos()))
3447         return false;
3448
3449     for (radius_iterator ri(you.pos(), LOS_NO_TRANS); ri; ++ri)
3450     {
3451         const monster * const mon = monster_at(*ri);
3452         if (mons_allows_beogh_now(mon))
3453             return true;
3454     }
3455
3456     return false;
3457 }
3458
3459 void spare_beogh_convert()
3460 {
3461     if (you.one_time_ability_used[GOD_BEOGH])
3462     {
3463         // You still get to convert, but orcs will remain hostile.
3464         mprf(MSGCH_TALK, "%s", getSpeakString("orc_priest_apostate").c_str());
3465         return;
3466     }
3467
3468     set<mid_t> witnesses;
3469
3470     you.religion = GOD_NO_GOD;
3471     for (radius_iterator ri(you.pos(), LOS_DEFAULT); ri; ++ri)
3472     {
3473         const monster *mon = monster_at(*ri);
3474         // An invis player converting is ok, for simplicity.
3475         if (!mon || !cell_see_cell(you.pos(), *ri, LOS_DEFAULT))
3476             continue;
3477         if (mon->attitude != ATT_HOSTILE)
3478             continue;
3479         if (mons_genus(mon->type) != MONS_ORC)
3480             continue;
3481         witnesses.insert(mon->mid);
3482
3483         // Anyone who has seen the priest perform the ceremony will spare you
3484         // as well.
3485         if (mons_allows_beogh(mon))
3486         {
3487             for (radius_iterator pi(you.pos(), LOS_DEFAULT); pi; ++pi)
3488             {
3489                 const monster *orc = monster_at(*pi);
3490                 if (!orc || !cell_see_cell(*ri, *pi, LOS_DEFAULT))
3491                     continue;
3492                 if (mons_genus(orc->type) != MONS_ORC)
3493                     continue;
3494                 if (mon->attitude != ATT_HOSTILE)
3495                     continue;
3496                 witnesses.insert(orc->mid);
3497             }
3498         }
3499     }
3500
3501     int witc = 0;
3502     for (auto wit : witnesses)
3503     {
3504         monster *orc = monster_by_mid(wit);
3505         if (!orc || !orc->alive())
3506             continue;
3507
3508         ++witc;
3509         orc->del_ench(ENCH_CHARM);
3510         mons_pacify(orc, ATT_GOOD_NEUTRAL, true);
3511     }
3512
3513     you.religion = GOD_BEOGH;
3514     you.one_time_ability_used.set(GOD_BEOGH);
3515
3516     if (witc == 1)
3517         mpr("The priest welcomes you and lets you live.");
3518     else
3519     {
3520         mpr("With a roar of approval, the orcs welcome you as one of their own,"
3521             " and spare your life.");
3522     }
3523 }
3524
3525 bool dithmenos_shadow_step()
3526 {
3527     // You can shadow-step anywhere within your umbra.
3528     ASSERT(you.umbra_radius2() > -1);
3529     const int range = isqrt_ceil(you.umbra_radius2());
3530
3531     targetter_shadow_step tgt(&you, you.umbra_radius2());
3532     direction_chooser_args args;
3533     args.hitfunc = &tgt;
3534     args.restricts = DIR_SHADOW_STEP;
3535     args.mode = TARG_HOSTILE;
3536     args.range = range;
3537     args.just_looking = false;
3538     args.needs_path = false;
3539     args.top_prompt = "Aiming: <white>Shadow Step</white>";
3540     dist sdirect;
3541     direction(sdirect, args);
3542     if (!sdirect.isValid || tgt.landing_site.origin())
3543         return false;
3544
3545     // Check for hazards.
3546     bool zot_trap_prompted = false,
3547          trap_prompted = false,
3548          exclusion_prompted = false,
3549          cloud_prompted = false,
3550          terrain_prompted = false;
3551
3552     for (auto site : tgt.additional_sites)
3553     {
3554         if (!cloud_prompted
3555             && !check_moveto_cloud(site, "shadow step", &cloud_prompted))
3556         {
3557             return false;
3558         }
3559
3560         if (!zot_trap_prompted)
3561         {
3562             trap_def* trap = find_trap(site);
3563             if (trap && env.grid(site) != DNGN_UNDISCOVERED_TRAP
3564                 && trap->type == TRAP_ZOT)
3565             {
3566                 if (!check_moveto_trap(site, "shadow step",
3567                                        &trap_prompted))
3568                 {
3569                     you.turn_is_over = false;
3570                     return false;
3571                 }
3572                 zot_trap_prompted = true;
3573             }
3574             else if (!trap_prompted
3575                      && !check_moveto_trap(site, "shadow step",
3576                                            &trap_prompted))
3577             {
3578                 you.turn_is_over = false;
3579                 return false;
3580             }
3581         }
3582
3583         if (!exclusion_prompted
3584             && !check_moveto_exclusion(site, "shadow step",
3585                                        &exclusion_prompted))
3586         {
3587             return false;
3588         }
3589
3590         if (!terrain_prompted
3591             && !check_moveto_terrain(site, "shadow step", "",
3592                                      &terrain_prompted))
3593         {
3594             return false;
3595         }
3596     }
3597
3598     // XXX: This only ever fails if something's on the landing site;
3599     // perhaps this should be handled more gracefully.
3600     if (!you.move_to_pos(tgt.landing_site))
3601     {
3602         mpr("Something blocks your shadow step.");
3603         return true;
3604     }
3605
3606     const actor *victim = actor_at(sdirect.target);
3607     mprf("You step into %s shadow.",
3608          apostrophise(victim->name(DESC_THE)).c_str());
3609
3610     return true;
3611 }
3612
3613 static bool _dithmenos_shadow_acts()
3614 {
3615     if (!in_good_standing(GOD_DITHMENOS, 3))
3616         return false;
3617
3618     // 10% chance at 4* piety; 50% chance at 200 piety.
3619     const int range = MAX_PIETY - piety_breakpoint(3);
3620     const int min   = range / 5;
3621     return x_chance_in_y(min + ((range - min)
3622                                 * (you.piety - piety_breakpoint(3))
3623                                 / (MAX_PIETY - piety_breakpoint(3))),
3624                          2 * range);
3625 }
3626
3627 monster* shadow_monster(bool equip)
3628 {
3629     if (monster_at(you.pos()))
3630         return nullptr;
3631
3632     int wpn_index  = NON_ITEM;
3633
3634     // Do a basic clone of the weapon.
3635     item_def* wpn = you.weapon();
3636     if (equip
3637         && wpn
3638         && (wpn->base_type == OBJ_WEAPONS
3639             || wpn->base_type == OBJ_STAVES
3640             || wpn->base_type == OBJ_RODS))
3641     {
3642         wpn_index = get_mitm_slot(10);
3643         if (wpn_index == NON_ITEM)
3644             return nullptr;
3645         item_def& new_item = mitm[wpn_index];
3646         if (wpn->base_type == OBJ_STAVES)
3647         {
3648             new_item.base_type = OBJ_WEAPONS;
3649             new_item.sub_type  = WPN_STAFF;
3650         }
3651         else if (wpn->base_type == OBJ_RODS)
3652         {
3653             new_item.base_type = OBJ_WEAPONS;
3654             new_item.sub_type  = WPN_ROD;
3655         }
3656         else
3657         {
3658             new_item.base_type = wpn->base_type;
3659             new_item.sub_type  = wpn->sub_type;
3660         }
3661         new_item.quantity = 1;
3662         new_item.rnd = 1;
3663         new_item.flags   |= ISFLAG_SUMMONED;
3664     }
3665
3666     monster* mon = get_free_monster();
3667     if (!mon)
3668     {
3669         if (wpn_index)
3670             destroy_item(wpn_index);
3671         return nullptr;
3672     }
3673
3674     mon->type       = MONS_PLAYER_SHADOW;
3675     mon->behaviour  = BEH_SEEK;
3676     mon->attitude   = ATT_FRIENDLY;
3677     mon->flags      = MF_NO_REWARD | MF_JUST_SUMMONED | MF_SEEN
3678                     | MF_WAS_IN_VIEW | MF_HARD_RESET;
3679     mon->hit_points = you.hp;
3680     mon->set_hit_dice(min(27, max(1,
3681                                   you.skill_rdiv(wpn_index != NON_ITEM
3682                                                  ? item_attack_skill(mitm[wpn_index])
3683                                                  : SK_UNARMED_COMBAT, 10, 20)
3684                                   + you.skill_rdiv(SK_FIGHTING, 10, 20))));
3685     mon->set_position(you.pos());
3686     mon->mid        = MID_PLAYER;
3687     mon->inv[MSLOT_WEAPON]  = wpn_index;
3688     mon->inv[MSLOT_MISSILE] = NON_ITEM;
3689
3690     mgrd(you.pos()) = mon->mindex();
3691
3692     return mon;
3693 }
3694
3695 void shadow_monster_reset(monster *mon)
3696 {
3697     if (mon->inv[MSLOT_WEAPON] != NON_ITEM)
3698         destroy_item(mon->inv[MSLOT_WEAPON]);
3699     if (mon->inv[MSLOT_MISSILE] != NON_ITEM)
3700         destroy_item(mon->inv[MSLOT_MISSILE]);
3701
3702     mon->reset();
3703 }
3704
3705 /**
3706  * Check if the player is in melee range of the target.
3707  *
3708  * Certain effects, e.g. distortion blink, can cause monsters to leave melee
3709  * range between the initial hit & the shadow mimic.
3710  *
3711  * XXX: refactor this with attack/fight code!
3712  *
3713  * @param target    The creature to be struck.
3714  * @return          Whether the player is melee range of the target, using
3715  *                  their current weapon.
3716  */
3717 static bool _in_melee_range(actor* target)
3718 {
3719     const int dist = (you.pos() - target->pos()).abs();
3720     return dist < 2 || (dist <= 2 && you.reach_range() != REACH_NONE);
3721 }
3722
3723 void dithmenos_shadow_melee(actor* target)
3724 {
3725     if (!target
3726         || !target->alive()
3727         || !_in_melee_range(target)
3728         || !_dithmenos_shadow_acts())
3729     {
3730         return;
3731     }
3732
3733     monster* mon = shadow_monster();
3734     if (!mon)
3735         return;
3736
3737     mon->target     = target->pos();
3738     mon->foe        = target->mindex();
3739
3740     fight_melee(mon, target);
3741
3742     shadow_monster_reset(mon);
3743 }
3744
3745 void dithmenos_shadow_throw(coord_def target, const item_def &item)
3746 {
3747     if (target.origin()
3748         || !_dithmenos_shadow_acts())
3749     {
3750         return;
3751     }
3752
3753     monster* mon = shadow_monster();
3754     if (!mon)
3755         return;
3756
3757     int ammo_index = get_mitm_slot(10);
3758     if (ammo_index != NON_ITEM)
3759     {
3760         item_def& new_item = mitm[ammo_index];
3761         new_item.base_type = item.base_type;
3762         new_item.sub_type  = item.sub_type;
3763         new_item.quantity  = 1;
3764         new_item.rnd = 1;
3765         new_item.flags    |= ISFLAG_SUMMONED;
3766         mon->inv[MSLOT_MISSILE] = ammo_index;
3767
3768         mon->target = target;
3769
3770         bolt beem;
3771         beem.target = target;
3772         setup_monster_throw_beam(mon, beem);
3773         beem.item = &mitm[mon->inv[MSLOT_MISSILE]];
3774         mons_throw(mon, beem, mon->inv[MSLOT_MISSILE]);
3775     }
3776
3777     shadow_monster_reset(mon);
3778 }
3779
3780 void dithmenos_shadow_spell(bolt* orig_beam, spell_type spell)
3781 {
3782     if (!orig_beam
3783         || orig_beam->target.origin()
3784         || (orig_beam->is_enchantment() && !is_valid_mon_spell(spell))
3785         || !_dithmenos_shadow_acts())
3786     {
3787         return;
3788     }
3789
3790     const coord_def target = orig_beam->target;
3791
3792     monster* mon = shadow_monster();
3793     if (!mon)
3794         return;
3795
3796     // Don't let shadow spells get too powerful.
3797     mon->set_hit_dice(max(1,
3798                           min(3 * spell_difficulty(spell),
3799                               you.experience_level) / 2));
3800
3801     mon->target = target;
3802     if (actor_at(target))
3803         mon->foe = actor_at(target)->mindex();
3804
3805     spell_type shadow_spell = spell;
3806     if (!orig_beam->is_enchantment())
3807     {
3808         shadow_spell = (orig_beam->pierce) ? SPELL_SHADOW_BOLT
3809                                            : SPELL_SHADOW_SHARD;
3810     }
3811
3812     bolt beem;
3813     beem.target = target;
3814     mprf(MSGCH_FRIEND_SPELL, "%s mimicks your spell!",
3815          mon->name(DESC_THE).c_str());
3816     mons_cast(mon, beem, shadow_spell, MON_SPELL_WIZARD, false);
3817
3818     shadow_monster_reset(mon);
3819 }
3820
3821 static potion_type _gozag_potion_list[][4] =
3822 {
3823     { POT_HEAL_WOUNDS, NUM_POTIONS, NUM_POTIONS, NUM_POTIONS },
3824     { POT_HEAL_WOUNDS, POT_CURING, NUM_POTIONS, NUM_POTIONS },
3825     { POT_HEAL_WOUNDS, POT_MAGIC, NUM_POTIONS, NUM_POTIONS, },
3826     { POT_CURING, POT_MAGIC, NUM_POTIONS, NUM_POTIONS },
3827     { POT_HEAL_WOUNDS, POT_BERSERK_RAGE, NUM_POTIONS, NUM_POTIONS },
3828     { POT_HASTE, POT_HEAL_WOUNDS, NUM_POTIONS, NUM_POTIONS },
3829     { POT_HASTE, POT_BRILLIANCE, NUM_POTIONS, NUM_POTIONS },
3830     { POT_HASTE, POT_AGILITY, NUM_POTIONS, NUM_POTIONS },
3831     { POT_MIGHT, POT_AGILITY, NUM_POTIONS, NUM_POTIONS },
3832     { POT_HASTE, POT_FLIGHT, NUM_POTIONS, NUM_POTIONS },
3833     { POT_HASTE, POT_RESISTANCE, NUM_POTIONS, NUM_POTIONS },
3834     { POT_RESISTANCE, POT_AGILITY, NUM_POTIONS, NUM_POTIONS },
3835     { POT_RESISTANCE, POT_FLIGHT, NUM_POTIONS, NUM_POTIONS },
3836     { POT_INVISIBILITY, POT_AGILITY, NUM_POTIONS , NUM_POTIONS },
3837     { POT_HEAL_WOUNDS, POT_CURING, POT_MAGIC, NUM_POTIONS },
3838     { POT_HEAL_WOUNDS, POT_CURING, POT_BERSERK_RAGE, NUM_POTIONS },
3839     { POT_HEAL_WOUNDS, POT_HASTE, POT_AGILITY, NUM_POTIONS },
3840     { POT_MIGHT, POT_AGILITY, POT_BRILLIANCE, NUM_POTIONS },
3841     { POT_HASTE, POT_AGILITY, POT_FLIGHT, NUM_POTIONS },
3842     { POT_FLIGHT, POT_AGILITY, POT_INVISIBILITY, NUM_POTIONS },
3843     { POT_RESISTANCE, POT_MIGHT, POT_AGILITY, NUM_POTIONS },
3844     { POT_RESISTANCE, POT_MIGHT, POT_HASTE, NUM_POTIONS },
3845     { POT_RESISTANCE, POT_INVISIBILITY, POT_AGILITY, NUM_POTIONS },
3846 };
3847
3848 static void _gozag_add_potions(CrawlVector &vec, potion_type *which)
3849 {
3850     for (; *which != NUM_POTIONS; which++)
3851     {
3852         bool dup = false;
3853         for (unsigned int i = 0; i < vec.size(); i++)
3854             if (vec[i].get_int() == *which)
3855             {
3856                 dup = true;
3857                 break;
3858             }
3859         if (!dup)
3860             vec.push_back(*which);
3861     }
3862 }
3863
3864 #define ADD_POTIONS(a,b) _gozag_add_potions(a, b[random2(ARRAYSZ(b))])
3865
3866 static int _gozag_faith_adjusted_price(int price)
3867 {
3868     return price - (you.faith() * price)/3;
3869 }
3870
3871 int gozag_potion_price()
3872 {
3873     int multiplier = GOZAG_POTION_BASE_MULTIPLIER
3874                      + you.attribute[ATTR_GOZAG_POTIONS];
3875     int price = multiplier * 15; // arbitrary
3876     return _gozag_faith_adjusted_price(price);
3877 }
3878
3879 bool gozag_setup_potion_petition(bool quiet)
3880 {
3881     const int gold_min = gozag_potion_price();
3882     if (you.gold < gold_min)
3883     {
3884         if (!quiet)
3885         {
3886             mprf("You need at least %d gold to purchase potions right now!",
3887                  gold_min);
3888         }
3889         return false;
3890     }
3891
3892     return true;
3893 }
3894
3895 bool gozag_potion_petition()
3896 {
3897     CrawlVector *pots[GOZAG_MAX_POTIONS];
3898     int prices[GOZAG_MAX_POTIONS];
3899
3900     item_def dummy;
3901     dummy.base_type = OBJ_POTIONS;
3902     dummy.quantity = 1;
3903
3904     if (!you.props.exists(make_stringf(GOZAG_POTIONS_KEY, 0)))
3905     {
3906         bool affordable_potions = false;
3907         while (!affordable_potions)
3908         {
3909             for (int i = 0; i < GOZAG_MAX_POTIONS; i++)
3910             {
3911                 prices[i] = 0;
3912                 int multiplier = GOZAG_POTION_BASE_MULTIPLIER
3913                                  + you.attribute[ATTR_GOZAG_POTIONS];
3914                 string key = make_stringf(GOZAG_POTIONS_KEY, i);
3915                 you.props.erase(key);
3916                 you.props[key].new_vector(SV_INT, SFLAG_CONST_TYPE);
3917                 pots[i] = &you.props[key].get_vector();
3918
3919                 ADD_POTIONS(*pots[i], _gozag_potion_list);
3920                 if (coinflip())
3921                     ADD_POTIONS(*pots[i], _gozag_potion_list);
3922
3923                 for (int j = 0; j < pots[i]->size(); j++)
3924                 {
3925                     dummy.sub_type = (*pots[i])[j].get_int();
3926                     prices[i] += item_value(dummy, true);
3927                     dprf("%d", item_value(dummy, true));
3928                 }
3929                 dprf("pre: %d", prices[i]);
3930                 prices[i] *= multiplier;
3931                 dprf("mid: %d", prices[i]);
3932                 prices[i] /= 10;
3933                 dprf("post: %d", prices[i]);
3934                 key = make_stringf(GOZAG_PRICE_KEY, i);
3935                 you.props[key].get_int() = prices[i];
3936
3937                 if (prices[i] <= gozag_potion_price())
3938                     affordable_potions = true;
3939             }
3940         }
3941     }
3942     else
3943     {
3944         for (int i = 0; i < GOZAG_MAX_POTIONS; i++)
3945         {
3946             string key = make_stringf(GOZAG_POTIONS_KEY, i);
3947             pots[i] = &you.props[key].get_vector();
3948             key = make_stringf(GOZAG_PRICE_KEY, i);
3949             prices[i] = you.props[key].get_int();
3950         }
3951     }
3952
3953     int keyin = 0;
3954     int faith_price = 0;
3955
3956     while (true)
3957     {
3958         if (crawl_state.seen_hups)
3959             return false;
3960
3961         clear_messages();
3962         for (int i = 0; i < GOZAG_MAX_POTIONS; i++)
3963         {
3964             faith_price = _gozag_faith_adjusted_price(prices[i]);
3965             string line = make_stringf("  [%c] - %d gold - ", i + 'a',
3966                                        faith_price);
3967             vector<string> pot_names;
3968             for (int j = 0; j < pots[i]->size(); j++)
3969                 pot_names.emplace_back(potion_type_name((*pots[i])[j].get_int()));
3970             line += comma_separated_line(pot_names.begin(), pot_names.end());
3971             mpr_nojoin(MSGCH_PLAIN, line.c_str());
3972         }
3973         mprf(MSGCH_PROMPT, "Purchase which effect?");
3974         keyin = toalower(get_ch()) - 'a';
3975         if (keyin < 0 || keyin > GOZAG_MAX_POTIONS - 1)
3976             continue;
3977
3978         faith_price = _gozag_faith_adjusted_price(prices[keyin]);
3979         if (you.gold < faith_price)
3980         {
3981             mpr("You don't have enough gold for that!");
3982             more();
3983             continue;
3984         }
3985
3986         break;
3987     }
3988
3989     ASSERT(you.gold >= faith_price);
3990     you.del_gold(faith_price);
3991     you.attribute[ATTR_GOZAG_GOLD_USED] += faith_price;
3992     for (int j = 0; j < pots[keyin]->size(); j++)
3993     {
3994         potion_effect(static_cast<potion_type>((*pots[keyin])[j].get_int()),
3995                       40);
3996     }
3997
3998     you.attribute[ATTR_GOZAG_POTIONS]++;
3999
4000     for (int i = 0; i < GOZAG_MAX_POTIONS; i++)
4001     {
4002         string key = make_stringf(GOZAG_POTIONS_KEY, i);
4003         you.props.erase(key);
4004         key = make_stringf(GOZAG_PRICE_KEY, i);
4005         you.props.erase(key);
4006     }
4007
4008     return true;
4009 }
4010
4011 /**
4012  * How many shop types are offered with each use of Call Merchant?
4013  */
4014 static int _gozag_max_shops()
4015 {
4016     const int max_non_food_shops = 3;
4017
4018     // add a food shop if you can eat (non-mu/dj)
4019     if (!you_foodless_normally())
4020         return max_non_food_shops + 1;
4021     return max_non_food_shops;
4022 }
4023
4024 /**
4025  * The price to order a merchant from Gozag. Doesn't depend on the shop's
4026  * type or contents. The maximum possible price is used as the minimum amount
4027  * of gold you need to use the ability.
4028  */
4029 int gozag_price_for_shop(bool max)
4030 {
4031     // This value probably needs tweaking.
4032     const int base = max ? 1000 : random_range(500, 1000);
4033     const int price = base
4034                       * (GOZAG_SHOP_BASE_MULTIPLIER
4035                          + GOZAG_SHOP_MOD_MULTIPLIER
4036                            * you.attribute[ATTR_GOZAG_SHOPS])
4037                       / GOZAG_SHOP_BASE_MULTIPLIER;
4038     return max ? _gozag_faith_adjusted_price(price) : price;
4039 }
4040
4041 static vector<level_id> _get_gozag_shop_candidates(int *max_absdepth)
4042 {
4043     vector<level_id> candidates;
4044
4045     branch_type allowed_branches[3] = {BRANCH_DUNGEON, BRANCH_VAULTS, BRANCH_DEPTHS};
4046     for (int ii = 0; ii < 3; ii++)
4047     {
4048         branch_type i = allowed_branches[ii];
4049
4050         level_id lid(i, brdepth[i]);
4051
4052         // Base shop level number on the deepest we can place a shop
4053         // in the given game; this is constant for as long as we can place
4054         // shops and is intended to prevent scummy behaviour.
4055         if (max_absdepth)
4056         {
4057             const int absdepth = branches[i].absdepth + brdepth[i] - 1;
4058             if (absdepth > *max_absdepth)
4059                 *max_absdepth = absdepth;
4060         }
4061
4062         for (int j = 1; j <= brdepth[i] && candidates.size() < 4; j++)
4063         {
4064             // Don't try to place shops on Vaults:$, since they'll be totally
4065             // insignificant next to the regular loot/shops
4066             if (i == BRANCH_VAULTS && j == brdepth[i])
4067                 continue;
4068             lid.depth = j;
4069             if (!is_existing_level(lid)
4070                 && !you.props.exists(make_stringf(GOZAG_SHOP_KEY,
4071                                                   lid.describe().c_str())))
4072             {
4073                 candidates.push_back(lid);
4074             }
4075         }
4076     }
4077
4078     return candidates;
4079 }
4080
4081 bool gozag_setup_call_merchant(bool quiet)
4082 {
4083     const int gold_min = gozag_price_for_shop(true);
4084     if (you.gold < gold_min)