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