Use cell_is_solid where appropriate.
[crawl:crawl.git] / crawl-ref / source / mon-cast.cc
1 /**
2  * @file
3  * @brief Monster spell casting.
4 **/
5
6 #include "AppHdr.h"
7 #include "mon-cast.h"
8
9 #include <math.h>
10
11 #include "act-iter.h"
12 #include "beam.h"
13 #include "cloud.h"
14 #include "colour.h"
15 #include "coordit.h"
16 #include "delay.h"
17 #include "database.h"
18 #include "effects.h"
19 #include "env.h"
20 #include "evoke.h"
21 #include "fight.h"
22 #include "fprop.h"
23 #include "ghost.h"
24 #include "itemprop.h"
25 #include "items.h"
26 #include "libutil.h"
27 #include "losglobal.h"
28 #include "mapmark.h"
29 #include "misc.h"
30 #include "message.h"
31 #include "mon-behv.h"
32 #include "mon-clone.h"
33 #include "mon-death.h"
34 #include "mon-place.h"
35 #include "mon-project.h"
36 #include "terrain.h"
37 #include "mislead.h"
38 #include "mgen_data.h"
39 #include "mon-gear.h"
40 #include "mon-speak.h"
41 #include "mon-stuff.h"
42 #include "ouch.h"
43 #include "random.h"
44 #include "religion.h"
45 #include "shout.h"
46 #include "spl-util.h"
47 #include "spl-cast.h"
48 #include "spl-clouds.h"
49 #include "spl-damage.h"
50 #include "spl-monench.h"
51 #include "spl-summoning.h"
52 #include "state.h"
53 #include "stuff.h"
54 #include "areas.h"
55 #include "teleport.h"
56 #include "traps.h"
57 #include "view.h"
58 #include "viewchar.h"
59
60 #include <algorithm>
61
62 // kraken stuff
63 const int MAX_ACTIVE_KRAKEN_TENTACLES = 4;
64 const int MAX_ACTIVE_STARSPAWN_TENTACLES = 2;
65
66 static bool _valid_mon_spells[NUM_SPELLS];
67
68 static int  _mons_mesmerise(monster* mons, bool actual = true);
69 static int  _mons_cause_fear(monster* mons, bool actual = true);
70 static int  _mons_mass_confuse(monster* mons, bool actual = true);
71 static int _mons_available_tentacles(monster* head);
72 static coord_def _mons_fragment_target(monster *mons);
73
74 void init_mons_spells()
75 {
76     monster fake_mon;
77     fake_mon.type       = MONS_BLACK_DRACONIAN;
78     fake_mon.hit_points = 1;
79
80     bolt pbolt;
81
82     for (int i = 0; i < NUM_SPELLS; i++)
83     {
84         spell_type spell = (spell_type) i;
85
86         _valid_mon_spells[i] = false;
87
88         if (!is_valid_spell(spell))
89             continue;
90
91         if (setup_mons_cast(&fake_mon, pbolt, spell, true))
92             _valid_mon_spells[i] = true;
93     }
94 }
95
96 bool is_valid_mon_spell(spell_type spell)
97 {
98     if (spell < 0 || spell >= NUM_SPELLS)
99         return false;
100
101     return _valid_mon_spells[spell];
102 }
103
104 static void _scale_draconian_breath(bolt& beam, int drac_type)
105 {
106     int scaling = 100;
107     switch (drac_type)
108     {
109     case MONS_RED_DRACONIAN:
110         beam.name       = "searing blast";
111         beam.aux_source = "blast of searing breath";
112         scaling         = 65;
113         break;
114
115     case MONS_WHITE_DRACONIAN:
116         beam.name       = "chilling blast";
117         beam.aux_source = "blast of chilling breath";
118         beam.short_name = "frost";
119         scaling         = 65;
120         beam.ac_rule    = AC_NONE;
121         break;
122
123     case MONS_PLAYER_GHOST: // draconians only
124         beam.name       = "blast of negative energy";
125         beam.aux_source = "blast of draining breath";
126         beam.flavour    = BEAM_NEG;
127         beam.colour     = DARKGREY;
128         scaling         = 65;
129         break;
130     }
131     beam.damage.size = scaling * beam.damage.size / 100;
132 }
133
134 static spell_type _draco_type_to_breath(int drac_type)
135 {
136     switch (drac_type)
137     {
138     case MONS_BLACK_DRACONIAN:   return SPELL_LIGHTNING_BOLT;
139     case MONS_MOTTLED_DRACONIAN: return SPELL_STICKY_FLAME_SPLASH;
140     case MONS_YELLOW_DRACONIAN:  return SPELL_SPIT_ACID;
141     case MONS_GREEN_DRACONIAN:   return SPELL_POISONOUS_CLOUD;
142     case MONS_PURPLE_DRACONIAN:  return SPELL_QUICKSILVER_BOLT;
143     case MONS_RED_DRACONIAN:     return SPELL_FIRE_BREATH;
144     case MONS_WHITE_DRACONIAN:   return SPELL_COLD_BREATH;
145     case MONS_GREY_DRACONIAN:    return SPELL_NO_SPELL;
146     case MONS_PALE_DRACONIAN:    return SPELL_STEAM_BALL;
147
148     // Handled later.
149     case MONS_PLAYER_GHOST:      return SPELL_DRACONIAN_BREATH;
150
151     default:
152         die("Invalid monster using draconian breath spell");
153         break;
154     }
155
156     return SPELL_DRACONIAN_BREATH;
157 }
158
159 static bool _flavour_benefits_monster(beam_type flavour, monster& monster)
160 {
161     switch (flavour)
162     {
163     case BEAM_HASTE:
164         return !monster.has_ench(ENCH_HASTE);
165
166     case BEAM_MIGHT:
167         return !monster.has_ench(ENCH_MIGHT);
168
169     case BEAM_INVISIBILITY:
170         return !monster.has_ench(ENCH_INVIS);
171
172     case BEAM_HEALING:
173         return (monster.hit_points != monster.max_hit_points);
174
175     default:
176         return false;
177     }
178 }
179
180 // Find an allied monster to cast a beneficial beam spell at.
181 static bool _set_allied_target(monster* caster, bolt& pbolt, bool ignore_genus)
182 {
183     monster* selected_target = NULL;
184     int min_distance = INT_MAX;
185
186     const monster_type caster_genus = mons_genus(caster->type);
187
188     for (monster_near_iterator targ(caster, LOS_NO_TRANS); targ; ++targ)
189     {
190         if (*targ == caster)
191             continue;
192
193         const int targ_distance = grid_distance(targ->pos(), caster->pos());
194
195         bool got_target = false;
196
197         // Shedu only heal each other.
198         if (mons_is_shedu(caster))
199         {
200             if (mons_is_shedu(*targ) && caster->mid == targ->number
201                 && caster->number == targ->mid
202                 && _flavour_benefits_monster(pbolt.flavour, **targ))
203             {
204                 got_target = true;
205             }
206             else
207                 continue;
208         }
209         else if ((mons_genus(targ->type) == caster_genus
210                  || mons_genus(targ->base_monster) == caster_genus
211                  || targ->is_holy() && caster->is_holy()
212                  || mons_enslaved_soul(caster)
213                  || ignore_genus)
214             && mons_aligned(*targ, caster)
215             && !targ->has_ench(ENCH_CHARM)
216             && _flavour_benefits_monster(pbolt.flavour, **targ))
217         {
218             got_target = true;
219         }
220
221         if (got_target && targ_distance < min_distance
222             && targ_distance < pbolt.range)
223         {
224             // Make sure we won't hit an invalid target with this aim.
225             pbolt.target = targ->pos();
226             fire_tracer(caster, pbolt);
227             if (!mons_should_fire(pbolt)
228                 || pbolt.path_taken.back() != pbolt.target)
229             {
230                 continue;
231             }
232
233             min_distance = targ_distance;
234             selected_target = *targ;
235         }
236     }
237
238     if (selected_target)
239     {
240         pbolt.target = selected_target->pos();
241         return true;
242     }
243
244     // Didn't find a target.
245     return false;
246 }
247
248 bolt mons_spell_beam(monster* mons, spell_type spell_cast, int power,
249                      bool check_validity)
250 {
251     ASSERT(power > 0);
252
253     bolt beam;
254
255     // Initialise to some bogus values so we can catch problems.
256     beam.name         = "****";
257     beam.colour       = 1000;
258     beam.hit          = -1;
259     beam.damage       = dice_def(1, 0);
260     beam.ench_power   = -1;
261     beam.glyph        = 0;
262     beam.flavour      = BEAM_NONE;
263     beam.thrower      = KILL_MISC;
264     beam.is_beam      = false;
265     beam.is_explosion = false;
266
267     switch (spell_cast)
268     { // add touch or range-setting spells here
269         case SPELL_SANDBLAST:
270             break;
271         case SPELL_FLAME_TONGUE:
272             // HD:1 monsters would get range 2, HD:2 -- 3, other 4, let's
273             // use the mighty Throw Flame for big ranges.
274             // Here, we have HD:1 -- 1, HD:2+ -- 2.
275             beam.range = (power >= 20) ? 2 : 1;
276             break;
277         default:
278         beam.range = spell_range(spell_cast, power, false);
279     }
280
281     const int drac_type = (mons_genus(mons->type) == MONS_DRACONIAN)
282                             ? draco_subspecies(mons) : mons->type;
283
284     spell_type real_spell = spell_cast;
285
286     if (spell_cast == SPELL_DRACONIAN_BREATH)
287         real_spell = _draco_type_to_breath(drac_type);
288
289     beam.glyph = dchar_glyph(DCHAR_FIRED_ZAP); // default
290     beam.thrower = KILL_MON_MISSILE;
291     beam.origin_spell = real_spell;
292
293     // FIXME: this should use the zap_data[] struct from beam.cc!
294     switch (real_spell)
295     {
296     case SPELL_MAGIC_DART:
297         beam.colour   = LIGHTMAGENTA;
298         beam.name     = "magic dart";
299         beam.damage   = dice_def(3, 4 + (power / 100));
300         beam.hit      = AUTOMATIC_HIT;
301         beam.flavour  = BEAM_MMISSILE;
302         break;
303
304     case SPELL_THROW_FLAME:
305         beam.colour   = RED;
306         beam.name     = "puff of flame";
307         beam.damage   = dice_def(3, 5 + (power / 40));
308         beam.hit      = 25 + power / 40;
309         beam.flavour  = BEAM_FIRE;
310         break;
311
312     case SPELL_THROW_FROST:
313         beam.colour   = WHITE;
314         beam.name     = "puff of frost";
315         beam.damage   = dice_def(3, 5 + (power / 40));
316         beam.hit      = 25 + power / 40;
317         beam.flavour  = BEAM_COLD;
318         break;
319
320     case SPELL_SANDBLAST:
321         beam.colour   = BROWN;
322         beam.name     = "rocky blast";
323         beam.damage   = dice_def(3, 5 + (power / 40));
324         beam.hit      = 20 + power / 40;
325         beam.flavour  = BEAM_FRAG;
326         beam.range    = 2;      // spell_range() is wrong here
327         break;
328
329     case SPELL_DISPEL_UNDEAD:
330         beam.flavour  = BEAM_DISPEL_UNDEAD;
331         beam.damage   = dice_def(3, min(6 + power / 10, 40));
332         beam.is_beam  = true;
333         break;
334
335     case SPELL_PARALYSE:
336         beam.flavour  = BEAM_PARALYSIS;
337         beam.is_beam  = true;
338         break;
339
340     case SPELL_PETRIFY:
341         beam.flavour  = BEAM_PETRIFY;
342         beam.is_beam  = true;
343         break;
344
345     case SPELL_SLOW:
346         beam.flavour  = BEAM_SLOW;
347         beam.is_beam  = true;
348         break;
349
350     case SPELL_HASTE_OTHER:
351     case SPELL_HASTE:
352         beam.flavour  = BEAM_HASTE;
353         break;
354
355     case SPELL_MIGHT_OTHER:
356     case SPELL_MIGHT:
357         beam.flavour  = BEAM_MIGHT;
358         break;
359
360     case SPELL_CORONA:
361         beam.flavour  = BEAM_CORONA;
362         beam.is_beam  = true;
363         break;
364
365     case SPELL_CONFUSE:
366         beam.flavour  = BEAM_CONFUSION;
367         beam.is_beam  = true;
368         break;
369
370     case SPELL_HIBERNATION:
371         beam.flavour  = BEAM_HIBERNATION;
372         beam.is_beam  = true;
373         break;
374
375     case SPELL_SLEEP:
376         beam.flavour  = BEAM_SLEEP;
377         beam.is_beam  = true;
378         break;
379
380     case SPELL_POLYMORPH:
381         beam.flavour  = BEAM_POLYMORPH;
382         beam.is_beam  = true;
383         break;
384
385     case SPELL_MALMUTATE:
386         beam.flavour  = BEAM_MALMUTATE;
387         beam.is_beam  = true;
388         /*
389           // Be careful with this one.
390           // Having allies mutate you is infuriating.
391           beam.foe_ratio = 1000;
392         What's the point of this?  Enchantments always hit...
393         */
394         break;
395
396     case SPELL_FLAME_TONGUE:
397         beam.name     = "flame";
398         beam.damage   = dice_def(3, 3 + power / 12);
399         beam.colour   = RED;
400         beam.flavour  = BEAM_FIRE;
401         beam.hit      = 7 + power / 6;
402         beam.is_beam  = true;
403         break;
404
405     case SPELL_VENOM_BOLT:
406         beam.name     = "bolt of poison";
407         beam.damage   = dice_def(3, 6 + power / 13);
408         beam.colour   = LIGHTGREEN;
409         beam.flavour  = BEAM_POISON;
410         beam.hit      = 19 + power / 20;
411         beam.is_beam  = true;
412         break;
413
414     case SPELL_POISON_ARROW:
415         beam.name     = "poison arrow";
416         beam.damage   = dice_def(3, 7 + power / 12);
417         beam.colour   = LIGHTGREEN;
418         beam.glyph    = dchar_glyph(DCHAR_FIRED_MISSILE);
419         beam.flavour  = BEAM_POISON_ARROW;
420         beam.hit      = 20 + power / 25;
421         break;
422
423     case SPELL_BOLT_OF_MAGMA:
424         beam.name     = "bolt of magma";
425         beam.damage   = dice_def(3, 8 + power / 11);
426         beam.colour   = RED;
427         beam.flavour  = BEAM_LAVA;
428         beam.hit      = 17 + power / 25;
429         beam.is_beam  = true;
430         break;
431
432     case SPELL_BOLT_OF_FIRE:
433         beam.name     = "bolt of fire";
434         beam.damage   = dice_def(3, 8 + power / 11);
435         beam.colour   = RED;
436         beam.flavour  = BEAM_FIRE;
437         beam.hit      = 17 + power / 25;
438         beam.is_beam  = true;
439         break;
440
441     case SPELL_THROW_ICICLE:
442         beam.name     = "shard of ice";
443         beam.damage   = dice_def(3, 8 + power / 11);
444         beam.colour   = WHITE;
445         beam.flavour  = BEAM_ICE;
446         beam.hit      = 17 + power / 25;
447         break;
448
449     case SPELL_BOLT_OF_COLD:
450         beam.name     = "bolt of cold";
451         beam.damage   = dice_def(3, 8 + power / 11);
452         beam.colour   = WHITE;
453         beam.flavour  = BEAM_COLD;
454         beam.hit      = 17 + power / 25;
455         beam.is_beam  = true;
456         break;
457
458     case SPELL_BOLT_OF_INACCURACY:
459         beam.name     = "narrow beam of energy";
460         beam.damage   = calc_dice(12, 40 + 3 * power / 2);
461         beam.colour   = YELLOW;
462         beam.flavour  = BEAM_ENERGY;
463         beam.hit      = 1;
464         beam.is_beam  = true;
465         break;
466
467     case SPELL_PRIMAL_WAVE:
468         beam.name     = "great wave of water";
469         // Water attack is weaker than the pure elemental damage
470         // attacks, but also less resistible.
471         beam.damage   = dice_def(3, 6 + power / 12);
472         beam.colour   = LIGHTBLUE;
473         beam.flavour  = BEAM_WATER;
474         // Huge wave of water is hard to dodge.
475         beam.hit      = 20 + power / 20;
476         beam.is_beam  = false;
477         beam.glyph    = dchar_glyph(DCHAR_WAVY);
478         break;
479
480     case SPELL_FREEZING_CLOUD:
481         beam.name     = "freezing blast";
482         beam.damage   = dice_def(2, 9 + power / 11);
483         beam.colour   = WHITE;
484         beam.flavour  = BEAM_COLD;
485         beam.hit      = 17 + power / 25;
486         beam.is_beam  = true;
487         beam.is_big_cloud = true;
488         break;
489
490     case SPELL_SHOCK:
491         beam.name     = "zap";
492         beam.damage   = dice_def(1, 8 + (power / 20));
493         beam.colour   = LIGHTCYAN;
494         beam.flavour  = BEAM_ELECTRICITY;
495         beam.hit      = 17 + power / 20;
496         beam.is_beam  = true;
497         break;
498
499     case SPELL_LIGHTNING_BOLT:
500         beam.name     = "bolt of lightning";
501         beam.damage   = dice_def(3, 10 + power / 17);
502         beam.colour   = LIGHTCYAN;
503         beam.flavour  = BEAM_ELECTRICITY;
504         beam.hit      = 16 + power / 40;
505         beam.is_beam  = true;
506         break;
507
508     case SPELL_INVISIBILITY:
509         beam.flavour  = BEAM_INVISIBILITY;
510         break;
511
512     case SPELL_FIREBALL:
513         beam.colour   = RED;
514         beam.name     = "fireball";
515         beam.damage   = dice_def(3, 7 + power / 10);
516         beam.hit      = 40;
517         beam.flavour  = BEAM_FIRE;
518         beam.foe_ratio = 80;
519         beam.is_explosion = true;
520         break;
521
522     case SPELL_FIRE_STORM:
523         setup_fire_storm(mons, power / 2, beam);
524         beam.foe_ratio = random_range(40, 55);
525         break;
526
527     case SPELL_ICE_STORM:
528         beam.name           = "great blast of cold";
529         beam.colour         = BLUE;
530         beam.damage         = calc_dice(10, 18 + power / 2);
531         beam.hit            = 20 + power / 10;    // 50: 25   100: 30
532         beam.ench_power     = power;              // used for radius
533         beam.flavour        = BEAM_ICE;           // half resisted
534         beam.is_explosion   = true;
535         beam.foe_ratio      = random_range(40, 55);
536         break;
537
538     case SPELL_HELLFIRE_BURST:
539         beam.aux_source   = "burst of hellfire";
540         beam.name         = "burst of hellfire";
541         beam.ex_size      = 1;
542         beam.flavour      = BEAM_HELLFIRE;
543         beam.is_explosion = true;
544         beam.colour       = RED;
545         beam.aux_source.clear();
546         beam.is_tracer    = false;
547         beam.hit          = 20;
548         beam.damage       = mons_foe_is_mons(mons) ? dice_def(5, 7)
549                                                    : dice_def(3, 15);
550         break;
551
552     case SPELL_HEAL_OTHER:
553     case SPELL_MINOR_HEALING:
554         beam.damage   = dice_def(2, mons->hit_dice / 2);
555         beam.flavour  = BEAM_HEALING;
556         beam.hit      = 25 + (power / 5);
557         break;
558
559     case SPELL_TELEPORT_SELF:
560         beam.flavour  = BEAM_TELEPORT;
561         break;
562
563     case SPELL_TELEPORT_OTHER:
564         beam.flavour  = BEAM_TELEPORT;
565         beam.is_beam  = true;
566         break;
567
568     case SPELL_LEHUDIBS_CRYSTAL_SPEAR:      // was splinters
569         beam.name     = "crystal spear";
570         beam.damage   = dice_def(3, 16 + power / 10);
571         beam.colour   = WHITE;
572         beam.glyph    = dchar_glyph(DCHAR_FIRED_MISSILE);
573         beam.flavour  = BEAM_MMISSILE;
574         beam.hit      = 22 + power / 20;
575         break;
576
577     case SPELL_DIG:
578         beam.flavour  = BEAM_DIGGING;
579         beam.is_beam  = true;
580         break;
581
582     case SPELL_BOLT_OF_DRAINING:      // negative energy
583         beam.name     = "bolt of negative energy";
584         beam.damage   = dice_def(3, 9 + power / 13);
585         beam.colour   = DARKGREY;
586         beam.flavour  = BEAM_NEG;
587         beam.hit      = 16 + power / 35;
588         beam.is_beam  = true;
589         break;
590
591     case SPELL_ISKENDERUNS_MYSTIC_BLAST: // mystic blast
592         beam.colour     = LIGHTMAGENTA;
593         beam.name       = "orb of energy";
594         beam.short_name = "energy";
595         beam.damage     = dice_def(3, 7 + (power / 14));
596         beam.hit        = 20 + (power / 20);
597         beam.flavour    = BEAM_MMISSILE;
598         break;
599
600     case SPELL_STEAM_BALL:
601         beam.colour   = LIGHTGREY;
602         beam.name     = "ball of steam";
603         beam.damage   = dice_def(3, 7 + (power / 15));
604         beam.hit      = 20 + power / 20;
605         beam.flavour  = BEAM_STEAM;
606         break;
607
608     case SPELL_PAIN:
609         beam.flavour    = BEAM_PAIN;
610         beam.damage     = dice_def(1, 7 + (power / 20));
611         beam.ench_power = max(50, 8 * mons->hit_dice);
612         beam.is_beam    = true;
613         break;
614
615     case SPELL_AGONY:
616         beam.flavour    = BEAM_PAIN;
617         beam.ench_power = mons->hit_dice * 6;
618         beam.is_beam    = true;
619         break;
620
621     case SPELL_STICKY_FLAME:
622         beam.hit = AUTOMATIC_HIT;
623     case SPELL_STICKY_FLAME_SPLASH:
624     case SPELL_STICKY_FLAME_RANGE:
625         if (real_spell != SPELL_STICKY_FLAME)
626             beam.hit      = 18 + power / 15;
627         beam.colour   = RED;
628         beam.name     = "sticky flame";
629         // FIXME: splash needs to be "splash of liquid fire"
630         beam.damage   = dice_def(3, 3 + power / 50);
631         beam.flavour  = BEAM_FIRE;
632         break;
633
634     case SPELL_NOXIOUS_CLOUD:
635         beam.name     = "noxious blast";
636         beam.damage   = dice_def(1, 0);
637         beam.colour   = GREEN;
638         beam.flavour  = BEAM_MEPHITIC;
639         beam.hit      = 18 + power / 25;
640         beam.is_beam  = true;
641         beam.is_big_cloud = true;
642         break;
643
644     case SPELL_POISONOUS_CLOUD:
645         beam.name     = "blast of poison";
646         beam.damage   = dice_def(3, 3 + power / 25);
647         beam.colour   = LIGHTGREEN;
648         beam.flavour  = BEAM_POISON;
649         beam.hit      = 18 + power / 25;
650         beam.is_beam  = true;
651         beam.is_big_cloud = true;
652         break;
653
654     case SPELL_ENERGY_BOLT:        // eye of devastation
655         beam.colour     = YELLOW;
656         beam.name       = "bolt of energy";
657         beam.short_name = "energy";
658         beam.damage     = dice_def(3, 20);
659         beam.hit        = 15 + power / 30;
660         beam.flavour    = BEAM_NUKE; // a magical missile which destroys walls
661         beam.is_beam    = true;
662         break;
663
664     case SPELL_STING:              // sting
665         beam.colour   = GREEN;
666         beam.name     = "sting";
667         beam.damage   = dice_def(1, 6 + power / 25);
668         beam.hit      = 60;
669         beam.flavour  = BEAM_POISON;
670         break;
671
672     case SPELL_IRON_SHOT:
673         beam.colour   = LIGHTCYAN;
674         beam.name     = "iron shot";
675         beam.damage   = dice_def(3, 8 + (power / 9));
676         beam.hit      = 20 + (power / 25);
677         beam.glyph    = dchar_glyph(DCHAR_FIRED_MISSILE);
678         beam.flavour  = BEAM_MMISSILE;   // similarly unresisted thing
679         break;
680
681     case SPELL_STONE_ARROW:
682         beam.colour   = LIGHTGREY;
683         beam.name     = "stone arrow";
684         beam.damage   = dice_def(3, 5 + (power / 10));
685         beam.hit      = 14 + power / 35;
686         beam.glyph    = dchar_glyph(DCHAR_FIRED_MISSILE);
687         beam.flavour  = BEAM_MMISSILE;   // similarly unresisted thing
688         break;
689
690     case SPELL_SPIT_POISON:
691         beam.colour   = GREEN;
692         beam.name     = "splash of poison";
693         beam.damage   = dice_def(1, 4 + power / 10);
694         beam.hit      = 16 + power / 20;
695         beam.flavour  = BEAM_POISON;
696         break;
697
698     case SPELL_SPIT_ACID:
699         beam.colour   = YELLOW;
700         beam.name     = "splash of acid";
701         beam.damage   = dice_def(3, 7);
702
703         // Zotdef change: make acid splash dmg dependent on power
704         // Oklob saplings pwr=48, oklobs pwr=120, acid blobs pwr=216
705         //  =>             3d3        3d6            3d9
706         if (crawl_state.game_is_zotdef())
707             beam.damage   = dice_def(3, 2 + (power / 30));
708
709         beam.hit      = 20 + (3 * mons->hit_dice);
710         beam.flavour  = BEAM_ACID;
711         break;
712
713     case SPELL_DISINTEGRATE:
714         beam.flavour    = BEAM_DISINTEGRATION;
715         beam.ench_power = 50;
716         beam.damage     = dice_def(1, 30 + (power / 10));
717         beam.is_beam    = true;
718         break;
719
720     case SPELL_MEPHITIC_CLOUD:
721         beam.name     = "foul vapour";
722         beam.damage   = dice_def(1, 0);
723         beam.colour   = GREEN;
724         beam.flavour  = BEAM_MEPHITIC;
725         beam.hit      = 14 + power / 30;
726         beam.ench_power = power; // probably meaningless
727         beam.is_explosion = true;
728         beam.is_big_cloud = true;
729         break;
730
731     case SPELL_MIASMA_BREATH:      // death drake
732         beam.name     = "foul vapour";
733         beam.damage   = dice_def(3, 5 + power / 24);
734         beam.colour   = DARKGREY;
735         beam.flavour  = BEAM_MIASMA;
736         beam.hit      = 17 + power / 20;
737         beam.is_beam  = true;
738         beam.is_big_cloud = true;
739         break;
740
741     case SPELL_QUICKSILVER_BOLT:   // Quicksilver dragon and purple draconian
742         beam.colour     = random_colour();
743         beam.name       = "bolt of dispelling energy";
744         beam.short_name = "energy";
745         beam.damage     = dice_def(3, 20);
746         beam.hit        = 16 + power / 25;
747         beam.flavour    = BEAM_MMISSILE;
748         break;
749
750     case SPELL_HELLFIRE:           // fiend's hellfire
751         beam.name         = "blast of hellfire";
752         beam.aux_source   = "blast of hellfire";
753         beam.colour       = RED;
754         beam.damage       = dice_def(3, 20);
755         beam.hit          = 24;
756         beam.flavour      = BEAM_HELLFIRE;
757         beam.is_beam      = true;
758         beam.is_explosion = true;
759         break;
760
761     case SPELL_METAL_SPLINTERS:
762         beam.name       = "spray of metal splinters";
763         beam.short_name = "metal splinters";
764         beam.damage     = dice_def(3, 20 + power / 20);
765         beam.colour     = CYAN;
766         beam.flavour    = BEAM_FRAG;
767         beam.hit        = 19 + power / 30;
768         beam.is_beam    = true;
769         break;
770
771     case SPELL_BANISHMENT:
772         beam.flavour  = BEAM_BANISH;
773         beam.is_beam  = true;
774         break;
775
776     case SPELL_BLINK_OTHER:
777         beam.flavour    = BEAM_BLINK;
778         beam.is_beam    = true;
779         break;
780
781     case SPELL_BLINK_OTHER_CLOSE:
782         beam.flavour    = BEAM_BLINK_CLOSE;
783         beam.is_beam    = true;
784         break;
785
786     case SPELL_FIRE_BREATH:
787         beam.name       = "blast of flame";
788         beam.aux_source = "blast of fiery breath";
789         beam.damage     = dice_def(3, (mons->hit_dice * 2));
790         beam.colour     = RED;
791         beam.hit        = 30;
792         beam.flavour    = BEAM_FIRE;
793         beam.is_beam    = true;
794         break;
795
796     case SPELL_CHAOS_BREATH:
797         beam.name       = "blast of chaos";
798         beam.aux_source = "blast of chaotic breath";
799         beam.damage     = dice_def(3, (mons->hit_dice * 2));
800         beam.colour     = ETC_RANDOM;
801         beam.hit        = 30;
802         beam.flavour    = BEAM_CHAOS;
803         beam.is_beam    = true;
804         break;
805
806     case SPELL_COLD_BREATH:
807         beam.name       = "blast of cold";
808         beam.aux_source = "blast of icy breath";
809         beam.short_name = "frost";
810         beam.damage     = dice_def(3, (mons->hit_dice * 2));
811         beam.colour     = WHITE;
812         beam.hit        = 30;
813         beam.flavour    = BEAM_COLD;
814         beam.is_beam    = true;
815         break;
816
817     case SPELL_HOLY_BREATH:
818         beam.name     = "blast of cleansing flame";
819         beam.damage   = dice_def(3, (mons->hit_dice * 2));
820         beam.colour   = ETC_HOLY;
821         beam.flavour  = BEAM_HOLY;
822         beam.hit      = 18 + power / 25;
823         beam.is_beam  = true;
824         beam.is_big_cloud = true;
825         break;
826
827     case SPELL_DRACONIAN_BREATH:
828         beam.damage      = dice_def(3, (mons->hit_dice * 2));
829         beam.hit         = 30;
830         beam.is_beam     = true;
831         break;
832
833     case SPELL_PORKALATOR:
834         beam.name     = "porkalator";
835         beam.glyph    = 0;
836         beam.flavour  = BEAM_PORKALATOR;
837         beam.thrower  = KILL_MON_MISSILE;
838         beam.is_beam  = true;
839         break;
840
841     case SPELL_IOOD: // tracer only
842         beam.flavour  = BEAM_NUKE;
843         beam.is_beam  = true;
844         // Doesn't take distance into account, but this is just a tracer so
845         // we'll ignore that.  We need some damage on the tracer so the monster
846         // doesn't think the spell is useless against other monsters.
847         beam.damage   = 42;
848         break;
849
850     case SPELL_SUNRAY:
851         beam.colour   = ETC_HOLY;
852         beam.name     = "ray of light";
853         beam.damage   = dice_def(3, 7 + (power / 12));
854         beam.hit      = 10 + power / 25; // lousy accuracy, but ignores RMsl
855         beam.flavour  = BEAM_LIGHT;
856         break;
857
858     case SPELL_PETRIFYING_CLOUD:
859         beam.name     = "blast of calcifying dust";
860         beam.colour   = WHITE;
861         beam.damage   = dice_def(2, 6);
862         beam.hit      = AUTOMATIC_HIT;
863         beam.flavour  = BEAM_PETRIFYING_CLOUD;
864         beam.foe_ratio = 30;
865         beam.is_beam  = true;
866         break;
867
868     case SPELL_HOLY_LIGHT:
869         beam.name     = "beam of golden light";
870         beam.damage   = dice_def(3, 8 + power / 11);
871         beam.colour   = ETC_HOLY;
872         beam.flavour  = BEAM_HOLY;
873         beam.hit      = 17 + power / 25;
874         beam.is_beam  = true;
875         break;
876
877     case SPELL_SILVER_BLAST:
878         beam.colour   = LIGHTGRAY;
879         beam.name     = "silver bolt";
880         beam.damage   = dice_def(3, 7 + power / 10);
881         beam.hit      = 40;
882         beam.flavour  = BEAM_BOLT_OF_ZIN;
883         beam.foe_ratio = 80;
884         beam.is_explosion = true;
885         break;
886
887     case SPELL_ENSNARE:
888         beam.name     = "ensnaring beam";
889         beam.colour   = WHITE;
890         beam.glyph    = dchar_glyph(DCHAR_FIRED_MISSILE);
891         beam.flavour  = BEAM_ENSNARE;
892         beam.hit      = 22 + power / 20;
893         break;
894
895     case SPELL_FORCE_LANCE:
896         beam.colour   = LIGHTGREY;
897         beam.name     = "lance of force";
898         beam.damage   = dice_def(3, 6 + (power / 15));
899         beam.hit      = 20 + power / 20;
900         beam.flavour  = BEAM_MMISSILE;
901         break;
902
903     case SPELL_SENTINEL_MARK:
904         beam.ench_power = 125; //Difficult to resist
905         beam.flavour    = BEAM_SENTINEL_MARK;
906         beam.is_beam    = true;
907         break;
908
909     case SPELL_GHOSTLY_FLAMES:
910         beam.name     = "ghostly flame";
911         beam.damage   = dice_def(0, 1);
912         beam.colour   = CYAN;
913         beam.flavour  = BEAM_GHOSTLY_FLAME;
914         beam.hit      = AUTOMATIC_HIT;
915         beam.is_beam  = true;
916         beam.is_big_cloud = true;
917         break;
918
919     case SPELL_GHOSTLY_FIREBALL:
920         beam.colour   = CYAN;
921         beam.name     = "ghostly fireball";
922         beam.damage   = dice_def(3, 7 + power / 13);
923         beam.hit      = 40;
924         beam.flavour  = BEAM_GHOSTLY_FLAME;
925         beam.is_explosion = true;
926         break;
927
928     case SPELL_DIMENSION_ANCHOR:
929         beam.ench_power = power / 2;
930         beam.flavour    = BEAM_DIMENSION_ANCHOR;
931         beam.is_beam    = true;
932         break;
933
934     case SPELL_THORN_VOLLEY:
935         beam.colour   = BROWN;
936         beam.name     = "volley of thorns";
937         beam.damage   = dice_def(3, 5 + (power / 11));
938         beam.hit      = 20 + power / 13;
939         beam.flavour  = BEAM_MMISSILE;
940         break;
941
942     case SPELL_STRIP_RESISTANCE:
943         beam.ench_power = mons->hit_dice * 6;
944         beam.flavour    = BEAM_VULNERABILITY;
945         beam.is_beam    = true;
946         break;
947
948     // XXX: This seems needed to give proper spellcasting messages, even though
949     //      damage is done via another means
950     case SPELL_FREEZE:
951         beam.flavour    = BEAM_COLD;
952         break;
953
954     case SPELL_MALIGN_OFFERING:
955         beam.flavour    = BEAM_MALIGN_OFFERING;
956         beam.damage     = dice_def(2, 7 + (power / 13));
957         beam.is_beam    = true;
958         break;
959
960     default:
961         if (check_validity)
962         {
963             beam.flavour = NUM_BEAMS;
964             return beam;
965         }
966
967         if (!is_valid_spell(real_spell))
968         {
969             die("Invalid spell #%d cast by %s", (int) real_spell,
970                      mons->name(DESC_PLAIN, true).c_str());
971         }
972
973         die("Unknown monster spell '%s' cast by %s",
974                  spell_title(real_spell),
975                  mons->name(DESC_PLAIN, true).c_str());
976
977         return beam;
978     }
979
980     if (beam.is_enchantment())
981     {
982         beam.glyph = 0;
983         beam.name = "";
984     }
985
986     if (spell_cast == SPELL_AGONY)
987         beam.name = "agony";
988
989     if (spell_cast == SPELL_DRACONIAN_BREATH)
990         _scale_draconian_breath(beam, drac_type);
991
992     return beam;
993 }
994
995 static bool _los_free_spell(spell_type spell_cast)
996 {
997     return (spell_cast == SPELL_HELLFIRE_BURST
998         || spell_cast == SPELL_BRAIN_FEED
999         || spell_cast == SPELL_SMITING
1000         || spell_cast == SPELL_HAUNT
1001         || spell_cast == SPELL_FIRE_STORM
1002         || spell_cast == SPELL_AIRSTRIKE
1003         || spell_cast == SPELL_WATERSTRIKE
1004         || spell_cast == SPELL_MISLEAD
1005         || spell_cast == SPELL_HOLY_FLAMES
1006         || spell_cast == SPELL_SUMMON_SPECTRAL_ORCS);
1007 }
1008
1009 // Set up bolt structure for monster spell casting.
1010 bool setup_mons_cast(monster* mons, bolt &pbolt, spell_type spell_cast,
1011                      bool check_validity)
1012 {
1013     // always set these -- used by things other than fire_beam()
1014
1015     // [ds] Used to be 12 * MHD and later buggily forced to -1 downstairs.
1016     // Setting this to a more realistic number now that that bug is
1017     // squashed.
1018     pbolt.ench_power = 4 * mons->hit_dice;
1019
1020     if (spell_cast == SPELL_TELEPORT_SELF)
1021         pbolt.ench_power = 2000;
1022     else if (spell_cast == SPELL_SLEEP)
1023         pbolt.ench_power = 6 * mons->hit_dice;
1024
1025     pbolt.beam_source = mons->mindex();
1026
1027     // Convenience for the hapless innocent who assumes that this
1028     // damn function does all possible setup. [ds]
1029     if (pbolt.target.origin())
1030         pbolt.target = mons->target;
1031
1032     // Set bolt type and range.
1033     if (_los_free_spell(spell_cast))
1034     {
1035         pbolt.range = 0;
1036         pbolt.glyph = 0;
1037         switch (spell_cast)
1038         {
1039         case SPELL_BRAIN_FEED:
1040         case SPELL_MISLEAD:
1041         case SPELL_SMITING:
1042         case SPELL_AIRSTRIKE:
1043         case SPELL_WATERSTRIKE:
1044         case SPELL_HOLY_FLAMES:
1045             return true;
1046         default:
1047             // Other spells get normal setup:
1048             break;
1049         }
1050     }
1051
1052     // The below are no-ops since they don't involve direct_effect,
1053     // fire_tracer, or beam.
1054     switch (spell_cast)
1055     {
1056     case SPELL_STICKS_TO_SNAKES:
1057     case SPELL_SUMMON_SMALL_MAMMAL:
1058     case SPELL_VAMPIRIC_DRAINING:
1059     case SPELL_INJURY_MIRROR:
1060     case SPELL_MAJOR_HEALING:
1061 #if TAG_MAJOR_VERSION == 34
1062     case SPELL_VAMPIRE_SUMMON:
1063 #endif
1064     case SPELL_SHADOW_CREATURES:       // summon anything appropriate for level
1065     case SPELL_FAKE_RAKSHASA_SUMMON:
1066     case SPELL_FAKE_MARA_SUMMON:
1067     case SPELL_SUMMON_ILLUSION:
1068     case SPELL_SUMMON_DEMON:
1069     case SPELL_SUMMON_UGLY_THING:
1070     case SPELL_ANIMATE_DEAD:
1071     case SPELL_TWISTED_RESURRECTION:
1072     case SPELL_SIMULACRUM:
1073     case SPELL_CALL_IMP:
1074     case SPELL_SUMMON_MINOR_DEMON:
1075     case SPELL_SUMMON_SCORPIONS:
1076     case SPELL_SUMMON_SWARM:
1077     case SPELL_SUMMON_UFETUBUS:
1078     case SPELL_SUMMON_HELL_BEAST:  // Geryon
1079     case SPELL_SUMMON_UNDEAD:      // summon undead around player
1080     case SPELL_SUMMON_ICE_BEAST:
1081     case SPELL_SUMMON_MUSHROOMS:
1082     case SPELL_CONJURE_BALL_LIGHTNING:
1083     case SPELL_SUMMON_DRAKES:
1084     case SPELL_SUMMON_HORRIBLE_THINGS:
1085     case SPELL_MALIGN_GATEWAY:
1086     case SPELL_HAUNT:
1087     case SPELL_SYMBOL_OF_TORMENT:
1088     case SPELL_CAUSE_FEAR:
1089     case SPELL_MESMERISE:
1090     case SPELL_DRAIN_LIFE:
1091     case SPELL_SUMMON_GREATER_DEMON:
1092     case SPELL_CANTRIP:
1093     case SPELL_BROTHERS_IN_ARMS:
1094     case SPELL_BERSERKER_RAGE:
1095     case SPELL_TROGS_HAND:
1096     case SPELL_SWIFTNESS:
1097     case SPELL_STONESKIN:
1098     case SPELL_WATER_ELEMENTALS:
1099     case SPELL_FIRE_ELEMENTALS:
1100     case SPELL_AIR_ELEMENTALS:
1101     case SPELL_EARTH_ELEMENTALS:
1102     case SPELL_IRON_ELEMENTALS:
1103     case SPELL_SUMMON_ELEMENTAL:
1104     case SPELL_CREATE_TENTACLES:
1105     case SPELL_BLINK:
1106     case SPELL_CONTROLLED_BLINK:
1107     case SPELL_BLINK_RANGE:
1108     case SPELL_BLINK_AWAY:
1109     case SPELL_BLINK_CLOSE:
1110     case SPELL_TOMB_OF_DOROKLOHE:
1111     case SPELL_CHAIN_LIGHTNING:    // the only user is reckless
1112     case SPELL_SUMMON_EYEBALLS:
1113     case SPELL_SUMMON_BUTTERFLIES:
1114     case SPELL_MISLEAD:
1115     case SPELL_CALL_TIDE:
1116     case SPELL_INK_CLOUD:
1117     case SPELL_SILENCE:
1118     case SPELL_AWAKEN_FOREST:
1119     case SPELL_DRUIDS_CALL:
1120     case SPELL_SUMMON_SPECTRAL_ORCS:
1121     case SPELL_REGENERATION:
1122     case SPELL_CORPSE_ROT:
1123     case SPELL_LEDAS_LIQUEFACTION:
1124     case SPELL_SUMMON_DRAGON:
1125     case SPELL_SUMMON_HYDRA:
1126     case SPELL_FIRE_SUMMON:
1127     case SPELL_DEATHS_DOOR:
1128     case SPELL_OZOCUBUS_ARMOUR:
1129     case SPELL_OZOCUBUS_REFRIGERATION:
1130     case SPELL_LRD:
1131     case SPELL_OLGREBS_TOXIC_RADIANCE:
1132     case SPELL_SHATTER:
1133 #if TAG_MAJOR_VERSION == 34
1134     case SPELL_FRENZY:
1135     case SPELL_SUMMON_TWISTER:
1136 #endif
1137     case SPELL_BATTLESPHERE:
1138     case SPELL_SPECTRAL_WEAPON:
1139     case SPELL_WORD_OF_RECALL:
1140     case SPELL_INJURY_BOND:
1141     case SPELL_CALL_LOST_SOUL:
1142     case SPELL_BLINK_ALLIES_ENCIRCLE:
1143     case SPELL_MASS_CONFUSION:
1144     case SPELL_ENGLACIATION:
1145     case SPELL_AWAKEN_VINES:
1146     case SPELL_CONTROL_WINDS:
1147     case SPELL_WALL_OF_BRAMBLES:
1148     case SPELL_HASTE_PLANTS:
1149     case SPELL_WIND_BLAST:
1150     case SPELL_SUMMON_VERMIN:
1151     case SPELL_TORNADO:
1152         return true;
1153     default:
1154         if (check_validity)
1155         {
1156             bolt beam = mons_spell_beam(mons, spell_cast, 1, true);
1157             return (beam.flavour != NUM_BEAMS);
1158         }
1159         break;
1160     }
1161
1162     // Need to correct this for power of spellcaster
1163     int power = 12 * mons->hit_dice;
1164
1165     bolt theBeam         = mons_spell_beam(mons, spell_cast, power);
1166
1167     // [ds] remind me again why we're doing this piecemeal copying?
1168     pbolt.origin_spell   = theBeam.origin_spell;
1169     pbolt.colour         = theBeam.colour;
1170     pbolt.range          = theBeam.range;
1171     pbolt.hit            = theBeam.hit;
1172     pbolt.damage         = theBeam.damage;
1173
1174     if (theBeam.ench_power != -1)
1175         pbolt.ench_power = theBeam.ench_power;
1176
1177     pbolt.glyph          = theBeam.glyph;
1178     pbolt.flavour        = theBeam.flavour;
1179     pbolt.thrower        = theBeam.thrower;
1180     pbolt.name           = theBeam.name;
1181     pbolt.short_name     = theBeam.short_name;
1182     pbolt.is_beam        = theBeam.is_beam;
1183     pbolt.source         = mons->pos();
1184     pbolt.is_tracer      = false;
1185     pbolt.is_explosion   = theBeam.is_explosion;
1186     pbolt.ex_size        = theBeam.ex_size;
1187
1188     pbolt.foe_ratio      = theBeam.foe_ratio;
1189
1190     if (!pbolt.is_enchantment())
1191         pbolt.aux_source = pbolt.name;
1192     else
1193         pbolt.aux_source.clear();
1194
1195     if (spell_cast == SPELL_HASTE
1196         || spell_cast == SPELL_MIGHT
1197         || spell_cast == SPELL_INVISIBILITY
1198         || spell_cast == SPELL_MINOR_HEALING
1199         || spell_cast == SPELL_TELEPORT_SELF
1200         || spell_cast == SPELL_SILENCE)
1201     {
1202         pbolt.target = mons->pos();
1203     }
1204
1205     return true;
1206 }
1207
1208 // Returns a suitable breath weapon for the draconian; does not handle all
1209 // draconians, does fire a tracer.
1210 static spell_type _get_draconian_breath_spell(monster* mons)
1211 {
1212     spell_type draco_breath = SPELL_NO_SPELL;
1213
1214     if (mons_genus(mons->type) == MONS_DRACONIAN)
1215     {
1216         switch (draco_subspecies(mons))
1217         {
1218         case MONS_DRACONIAN:
1219         case MONS_YELLOW_DRACONIAN:     // already handled as ability
1220             break;
1221         case MONS_GREY_DRACONIAN:       // no breath
1222             break;
1223         default:
1224             draco_breath = SPELL_DRACONIAN_BREATH;
1225             break;
1226         }
1227     }
1228
1229
1230     if (draco_breath != SPELL_NO_SPELL)
1231     {
1232         // [ds] Check line-of-fire here. It won't happen elsewhere.
1233         bolt beem;
1234         setup_mons_cast(mons, beem, draco_breath);
1235
1236         fire_tracer(mons, beem);
1237
1238         if (!mons_should_fire(beem))
1239             draco_breath = SPELL_NO_SPELL;
1240     }
1241
1242     return draco_breath;
1243 }
1244
1245 static bool _is_emergency_spell(const monster_spells &msp, int spell)
1246 {
1247     // If the emergency spell appears early, it's probably not a dedicated
1248     // escape spell.
1249     for (int i = 0; i < 5; ++i)
1250         if (msp[i] == spell)
1251             return false;
1252
1253     return (msp[5] == spell);
1254 }
1255
1256 // Function should return false if friendlies shouldn't animate any dead.
1257 // Currently, this only happens if the player is in the middle of butchering
1258 // a corpse (infuriating), or if they are less than satiated.  Only applies
1259 // to friendly corpse animators. {due}
1260 static bool _animate_dead_okay(spell_type spell)
1261 {
1262     // It's always okay in the arena.
1263     if (crawl_state.game_is_arena())
1264         return true;
1265
1266     if (is_butchering() || is_vampire_feeding())
1267         return false;
1268
1269     if (you.hunger_state < HS_SATIATED && you.mutation[MUT_HERBIVOROUS] < 3)
1270         return false;
1271
1272     if (god_hates_spell(spell, you.religion))
1273         return false;
1274
1275     return true;
1276 }
1277
1278 // Spells that work even if magic is off.  Be careful to not add ones which
1279 // appear both ways (SPELL_LIGHTNING_BOLT is also storm dragon breath, etc).
1280 static bool _is_physiological_spell(spell_type spell)
1281 {
1282     return spell == SPELL_QUICKSILVER_BOLT
1283         || spell == SPELL_METAL_SPLINTERS
1284         || spell == SPELL_STICKY_FLAME_SPLASH
1285         || spell == SPELL_SPIT_POISON
1286         || spell == SPELL_HOLY_BREATH
1287         || spell == SPELL_FIRE_BREATH;
1288 }
1289
1290 // Returns true if the spell is something you wouldn't want done if
1291 // you had a friendly target...  only returns a meaningful value for
1292 // non-beam spells.
1293 static bool _ms_direct_nasty(spell_type monspell)
1294 {
1295     return (spell_needs_foe(monspell)
1296             && !spell_typematch(monspell, SPTYP_SUMMONING));
1297 }
1298
1299 // Can be affected by the 'Haste Plants' spell
1300 static bool _is_hastable_plant(const monster* mons)
1301 {
1302     return (mons->holiness() == MH_PLANT
1303             && !mons_is_firewood(mons)
1304             && mons->type != MONS_SNAPLASHER_VINE
1305             && mons->type != MONS_SNAPLASHER_VINE_SEGMENT);
1306 }
1307
1308 // Checks if the foe *appears* to be immune to negative energy.  We
1309 // can't just use foe->res_negative_energy(), because that'll mean
1310 // monsters will just "know" whether a player is fully life-protected.
1311 static bool _foe_should_res_negative_energy(const actor* foe)
1312 {
1313     if (foe->is_player())
1314     {
1315         switch (you.is_undead)
1316         {
1317         case US_ALIVE:
1318             // Demonspawn are not demons, and statue form grants only
1319             // partial resistance.
1320             return false;
1321         case US_SEMI_UNDEAD:
1322             // Non-bloodless vampires do not appear immune.
1323             return you.hunger_state == HS_STARVING;
1324         default:
1325             return true;
1326         }
1327     }
1328
1329     return (foe->holiness() != MH_NATURAL);
1330 }
1331
1332 static bool _valid_encircle_ally(const monster* caster, const monster* target,
1333                                  const coord_def foepos)
1334 {
1335     return (mons_aligned(caster, target) && caster != target
1336             && !target->no_tele(true, false, true)
1337             && target->pos().distance_from(foepos) > 1);
1338 }
1339
1340 static bool _valid_druids_call_target(const monster* caller, const monster* callee)
1341 {
1342     return (mons_aligned(caller, callee) && mons_is_beast(callee->type)
1343             && !callee->is_shapeshifter()
1344             && !caller->see_cell(callee->pos())
1345             && mons_habitat(callee) != HT_WATER
1346             && mons_habitat(callee) != HT_LAVA);
1347 }
1348
1349 // Checks to see if a particular spell is worth casting in the first place.
1350 static bool _ms_waste_of_time(const monster* mon, spell_type monspell)
1351 {
1352     bool ret = false;
1353     actor *foe = mon->get_foe();
1354
1355     // Keep friendly summoners from spamming summons constantly.
1356     if (mon->friendly()
1357         && (!foe || foe->is_player())
1358         && spell_typematch(monspell, SPTYP_SUMMONING))
1359     {
1360         return true;
1361     }
1362
1363     if (!mon->wont_attack())
1364     {
1365         if (spell_harms_area(monspell) && env.sanctuary_time > 0)
1366             return true;
1367
1368         if (spell_harms_target(monspell) && is_sanctuary(mon->target))
1369             return true;
1370     }
1371
1372     if (mons_genus(mon->type) == MONS_DRAGON
1373         && mon->has_ench(ENCH_BREATH_WEAPON))
1374     {
1375         return true;
1376     }
1377
1378     // Eventually, we'll probably want to be able to have monsters
1379     // learn which of their elemental bolts were resisted and have those
1380     // handled here as well. - bwr
1381     switch (monspell)
1382     {
1383     case SPELL_CALL_TIDE:
1384         return (!player_in_branch(BRANCH_SHOALS)
1385                 || mon->has_ench(ENCH_TIDE)
1386                 || !foe
1387                 || (grd(mon->pos()) == DNGN_DEEP_WATER
1388                     && grd(foe->pos()) == DNGN_DEEP_WATER));
1389
1390     case SPELL_BRAIN_FEED:
1391         ret = (!foe || !foe->is_player());
1392         break;
1393
1394     case SPELL_VAMPIRIC_DRAINING:
1395         if (!foe
1396             || mon->hit_points + 1 >= mon->max_hit_points
1397             || !adjacent(mon->pos(), foe->pos()))
1398         {
1399             ret = true;
1400         }
1401     // fall through
1402     case SPELL_BOLT_OF_DRAINING:
1403     case SPELL_AGONY:
1404     case SPELL_SYMBOL_OF_TORMENT:
1405     case SPELL_MALIGN_OFFERING:
1406         if (!foe || _foe_should_res_negative_energy(foe))
1407             ret = true;
1408         break;
1409     case SPELL_MIASMA_BREATH:
1410         ret = (!foe || foe->res_rotting());
1411         break;
1412
1413     case SPELL_DISPEL_UNDEAD:
1414         // [ds] How is dispel undead intended to interact with vampires?
1415         ret = (!foe || foe->holiness() != MH_UNDEAD);
1416         break;
1417
1418     case SPELL_CORONA:
1419         ret = (!foe || foe->backlit() || foe->glows_naturally());
1420         break;
1421
1422     case SPELL_BERSERKER_RAGE:
1423         if (!mon->needs_berserk(false))
1424             ret = true;
1425         break;
1426
1427     case SPELL_HASTE:
1428         if (mon->has_ench(ENCH_HASTE))
1429             ret = true;
1430         break;
1431
1432     case SPELL_MIGHT:
1433         if (mon->has_ench(ENCH_MIGHT))
1434             ret = true;
1435         break;
1436
1437     case SPELL_SWIFTNESS:
1438         if (mon->has_ench(ENCH_SWIFT))
1439             ret = true;
1440         break;
1441
1442     case SPELL_REGENERATION:
1443         if (mon->has_ench(ENCH_REGENERATION) || mon->has_ench(ENCH_DEATHS_DOOR)
1444             || mon->holiness() == MH_UNDEAD)
1445         {
1446             ret = true;
1447         }
1448         break;
1449
1450     case SPELL_INJURY_MIRROR:
1451         if (mon->has_ench(ENCH_MIRROR_DAMAGE)
1452             || (mon->props.exists("mirror_recast_time")
1453                 && you.elapsed_time < mon->props["mirror_recast_time"].get_int()))
1454         {
1455             ret = true;
1456         }
1457         break;
1458
1459     case SPELL_TROGS_HAND:
1460         if (mon->has_ench(ENCH_RAISED_MR) || mon->has_ench(ENCH_REGENERATION))
1461             ret = true;
1462         break;
1463
1464     case SPELL_STONESKIN:
1465         if (mon->has_ench(ENCH_STONESKIN))
1466             ret = true;
1467         break;
1468
1469     case SPELL_INVISIBILITY:
1470         if (mon->has_ench(ENCH_INVIS)
1471             || mon->glows_naturally()
1472             || mon->friendly() && !you.can_see_invisible(false))
1473         {
1474             ret = true;
1475         }
1476         break;
1477
1478     case SPELL_MINOR_HEALING:
1479     case SPELL_MAJOR_HEALING:
1480         if (mon->hit_points > mon->max_hit_points / 2)
1481             ret = true;
1482         break;
1483
1484     case SPELL_TELEPORT_SELF:
1485         // Monsters aren't smart enough to know when to cancel teleport.
1486         if (mon->has_ench(ENCH_TP) || mon->no_tele(true, false))
1487             ret = true;
1488         break;
1489
1490     case SPELL_BLINK_CLOSE:
1491         if (!foe || adjacent(mon->pos(), foe->pos()))
1492             ret = true;
1493     case SPELL_BLINK:
1494     case SPELL_CONTROLLED_BLINK:
1495     case SPELL_BLINK_RANGE:
1496     case SPELL_BLINK_AWAY:
1497         // Prefer to keep a tornado going rather than blink.
1498         if (mon->no_tele(true, false) || mon->has_ench(ENCH_TORNADO))
1499             ret = true;
1500         break;
1501
1502     case SPELL_BLINK_OTHER:
1503     case SPELL_BLINK_OTHER_CLOSE:
1504         if (!foe)
1505             ret = true;
1506         else if (foe->is_monster()
1507             && foe->as_monster()->has_ench(ENCH_DIMENSION_ANCHOR))
1508             ret = true;
1509         else if (foe->is_player() && you.duration[DUR_DIMENSION_ANCHOR])
1510             ret = true;
1511         break;
1512
1513     case SPELL_TELEPORT_OTHER:
1514         // Monsters aren't smart enough to know when to cancel teleport.
1515         if (mon->foe == MHITYOU)
1516         {
1517             ret = you.duration[DUR_TELEPORT];
1518             break;
1519         }
1520         else if (mon->foe != MHITNOT)
1521         {
1522             ret = (menv[mon->foe].has_ench(ENCH_TP));
1523             break;
1524         }
1525         // intentional fall-through
1526
1527     case SPELL_SLOW:
1528     case SPELL_CONFUSE:
1529     case SPELL_PAIN:
1530     case SPELL_BANISHMENT:
1531     case SPELL_DISINTEGRATE:
1532     case SPELL_PARALYSE:
1533     case SPELL_SLEEP:
1534     case SPELL_HIBERNATION:
1535     case SPELL_DIMENSION_ANCHOR:
1536     {
1537         if ((monspell == SPELL_HIBERNATION || monspell == SPELL_SLEEP)
1538             && (!foe || foe->asleep() || !foe->can_sleep()))
1539         {
1540             ret = true;
1541             break;
1542         }
1543
1544         // Occasionally we don't estimate... just fire and see.
1545         if (one_chance_in(5))
1546         {
1547             ret = false;
1548             break;
1549         }
1550
1551         // Only intelligent monsters estimate.
1552         int intel = mons_intel(mon);
1553         if (intel < I_NORMAL)
1554         {
1555             ret = false;
1556             break;
1557         }
1558
1559         // We'll estimate the target's resistance to magic, by first getting
1560         // the actual value and then randomising it.
1561         int est_magic_resist = (mon->foe == MHITNOT) ? 10000 : 0;
1562
1563         if (mon->foe != MHITNOT)
1564         {
1565             if (mon->foe == MHITYOU)
1566                 est_magic_resist = you.res_magic();
1567             else
1568                 est_magic_resist = menv[mon->foe].res_magic();
1569
1570             // now randomise (normal intels less accurate than high):
1571             if (intel == I_NORMAL)
1572                 est_magic_resist += random2(80) - 40;
1573             else
1574                 est_magic_resist += random2(30) - 15;
1575         }
1576
1577         int power = 12 * mon->hit_dice * (monspell == SPELL_PAIN ? 2 : 1);
1578         power = stepdown_value(power, 30, 40, 100, 120);
1579
1580         // Determine the amount of chance allowed by the benefit from
1581         // the spell.  The estimated difficulty is the probability
1582         // of rolling over 100 + diff on 2d100. -- bwr
1583         int diff = (monspell == SPELL_PAIN
1584                     || monspell == SPELL_SLOW
1585                     || monspell == SPELL_CONFUSE) ? 0 : 50;
1586
1587         if (est_magic_resist - power > diff)
1588             ret = true;
1589         break;
1590     }
1591
1592     case SPELL_MISLEAD:
1593         if (you.duration[DUR_MISLED] > 10 && one_chance_in(3))
1594             ret = true;
1595
1596         break;
1597
1598     case SPELL_SUMMON_ILLUSION:
1599         if (!foe || !actor_is_illusion_cloneable(foe))
1600             ret = true;
1601         break;
1602
1603     case SPELL_FAKE_MARA_SUMMON:
1604         if (count_mara_fakes() == 2)
1605             ret = true;
1606
1607         break;
1608
1609     case SPELL_AWAKEN_FOREST:
1610         if (mon->has_ench(ENCH_AWAKEN_FOREST)
1611             || env.forest_awoken_until > you.elapsed_time
1612             || !forest_near_enemy(mon)
1613             || you_worship(GOD_FEDHAS))
1614         {
1615             ret = true;
1616         }
1617         break;
1618
1619     case SPELL_DEATHS_DOOR:
1620         // The caster may be an (undead) enslaved soul.
1621         if (mon->holiness() == MH_UNDEAD || mon->has_ench(ENCH_DEATHS_DOOR))
1622             ret = true;
1623         break;
1624
1625     case SPELL_OZOCUBUS_ARMOUR:
1626         if (mon->has_ench(ENCH_OZOCUBUS_ARMOUR))
1627             ret = true;
1628         break;
1629
1630     case SPELL_BATTLESPHERE:
1631         if (find_battlesphere(mon))
1632             ret = true;
1633         break;
1634
1635     case SPELL_SPECTRAL_WEAPON:
1636         if (find_spectral_weapon(mon))
1637             ret = true;
1638         break;
1639
1640     case SPELL_INJURY_BOND:
1641         for (monster_iterator mi; mi; ++mi)
1642         {
1643             if (mons_aligned(mon, *mi) && !mi->has_ench(ENCH_CHARM)
1644                 && *mi != mon && mon->see_cell_no_trans(mi->pos())
1645                 && !mi->has_ench(ENCH_INJURY_BOND))
1646                     return false; // We found at least one target; that's enough.
1647         }
1648         ret = true;
1649         break;
1650
1651     case SPELL_GHOSTLY_FIREBALL:
1652         ret = (!foe || foe->holiness() == MH_UNDEAD);
1653         break;
1654
1655     case SPELL_BLINK_ALLIES_ENCIRCLE:
1656     {
1657         if (!mon->get_foe() || mon->get_foe() && !mon->can_see(mon->get_foe()))
1658             return true;
1659
1660         const coord_def foepos = mon->get_foe()->pos();
1661
1662         for (monster_near_iterator mi(mon, LOS_NO_TRANS); mi; ++mi)
1663         {
1664             if (_valid_encircle_ally(mon, *mi, foepos))
1665                 return false; // We found at least one valid ally; that's enough.
1666         }
1667         return true;
1668     }
1669
1670     case SPELL_AWAKEN_VINES:
1671     if (!mon->get_foe() || (mon->has_ench(ENCH_AWAKEN_VINES)
1672                             && mon->props["vines_awakened"].get_int() >= 3))
1673     {
1674         return true;
1675     }
1676     else // To account for multiple dryads in range of each other
1677     {
1678         int count = 0;
1679         for (monster_near_iterator mi(mon, LOS_NO_TRANS); mi; ++mi)
1680         {
1681             if (mi->type == MONS_SNAPLASHER_VINE)
1682                 ++count;
1683         }
1684         if (count > 2)
1685             return true;
1686     }
1687     break;
1688
1689     case SPELL_CONTROL_WINDS:
1690         return mon->has_ench(ENCH_CONTROL_WINDS);
1691
1692     case SPELL_WATERSTRIKE:
1693         return !foe || !feat_is_water(grd(foe->pos()));
1694
1695     case SPELL_HASTE_PLANTS:
1696         for (monster_near_iterator mi(mon, LOS_NO_TRANS); mi; ++mi)
1697         {
1698             // Isn't useless if there's a single viable target for it
1699             if (mons_aligned(*mi, mon)
1700                 && _is_hastable_plant(*mi)
1701                 && !mi->has_ench(ENCH_HASTE))
1702             {
1703                 return false;
1704             }
1705         }
1706         return true;
1707
1708     // Don't use unless our foe is close to us and there are no allies already
1709     // between the two of us
1710     case SPELL_WIND_BLAST:
1711         if (foe && foe->pos().distance_from(mon->pos()) < 4)
1712         {
1713             bolt tracer;
1714             tracer.target = foe->pos();
1715             tracer.range  = LOS_RADIUS;
1716             tracer.hit    = AUTOMATIC_HIT;
1717             fire_tracer(mon, tracer);
1718
1719             actor* act = actor_at(tracer.path_taken.back());
1720             if (act && mons_aligned(mon, act))
1721                 return true;
1722             else
1723                 return false;
1724         }
1725         else
1726             return true;
1727
1728     case SPELL_STRIP_RESISTANCE:
1729         if (foe)
1730         {
1731             if (foe->is_monster() && foe->as_monster()->has_ench(ENCH_LOWERED_MR))
1732                 return true;
1733             else if (foe->is_player() && you.duration[DUR_LOWERED_MR])
1734                 return true;
1735             else
1736                 return false;
1737         }
1738         return true;
1739
1740     case SPELL_BROTHERS_IN_ARMS:
1741         return (mon->props.exists("brothers_count")
1742                 && mon->props["brothers_count"].get_int() >= 2);
1743
1744     case SPELL_SUMMON_MUSHROOMS:
1745         return (mon->get_foe() == NULL);
1746
1747     case SPELL_FREEZE:
1748         return (!foe || !adjacent(mon->pos(), foe->pos()));
1749
1750     case SPELL_DRUIDS_CALL:
1751         // Don't cast unless there's at least one valid target
1752         for (monster_iterator mi; mi; ++mi)
1753         {
1754             if (_valid_druids_call_target(mon, *mi))
1755                 return false;
1756         }
1757         return true;
1758
1759      // No need to spam cantrips if we're just travelling around
1760     case SPELL_CANTRIP:
1761         if (mon->friendly() && mon->foe == MHITYOU)
1762             ret = true;
1763         break;
1764
1765 #if TAG_MAJOR_VERSION == 34
1766     case SPELL_FRENZY:
1767     case SPELL_SUMMON_TWISTER:
1768 #endif
1769     case SPELL_NO_SPELL:
1770         ret = true;
1771         break;
1772
1773     default:
1774         break;
1775     }
1776
1777     return ret;
1778 }
1779
1780 // Spells a monster may want to cast if fleeing from the player, and
1781 // the player is not in sight.
1782 static bool _ms_useful_fleeing_out_of_sight(const monster* mon,
1783                                             spell_type monspell)
1784 {
1785     if (monspell == SPELL_NO_SPELL || _ms_waste_of_time(mon, monspell))
1786         return false;
1787
1788     switch (monspell)
1789     {
1790     case SPELL_HASTE:
1791     case SPELL_SWIFTNESS:
1792     case SPELL_INVISIBILITY:
1793     case SPELL_MINOR_HEALING:
1794     case SPELL_MAJOR_HEALING:
1795     case SPELL_ANIMATE_DEAD:
1796     case SPELL_TWISTED_RESURRECTION:
1797         return true;
1798
1799     default:
1800         if (spell_typematch(monspell, SPTYP_SUMMONING) && one_chance_in(4))
1801             return true;
1802         break;
1803     }
1804
1805     return false;
1806 }
1807
1808 static bool _ms_low_hitpoint_cast(const monster* mon, spell_type monspell)
1809 {
1810     if (_ms_waste_of_time(mon, monspell))
1811         return false;
1812
1813     bool targ_adj      = false;
1814     bool targ_sanct    = false;
1815     bool targ_friendly = false;
1816     bool targ_undead   = false;
1817
1818     if (mon->foe == MHITYOU || mon->foe == MHITNOT)
1819     {
1820         if (adjacent(you.pos(), mon->pos()))
1821             targ_adj = true;
1822         if (is_sanctuary(you.pos()))
1823             targ_sanct = true;
1824         if (you.undead_or_demonic())
1825             targ_undead = true;
1826     }
1827     else
1828     {
1829         if (adjacent(menv[mon->foe].pos(), mon->pos()))
1830             targ_adj = true;
1831         if (is_sanctuary(menv[mon->foe].pos()))
1832             targ_sanct = true;
1833         if (menv[mon->foe].undead_or_demonic())
1834             targ_undead = true;
1835     }
1836
1837     targ_friendly = (mon->foe == MHITYOU
1838                      ? mon->wont_attack()
1839                      : mons_aligned(mon, mon->get_foe()));
1840
1841     switch (monspell)
1842     {
1843     case SPELL_HEAL_OTHER:
1844         return targ_friendly && mon->foe != MHITYOU;
1845     case SPELL_TELEPORT_OTHER:
1846         return !targ_sanct && !targ_friendly;
1847     case SPELL_MINOR_HEALING:
1848     case SPELL_MAJOR_HEALING:
1849     case SPELL_INVISIBILITY:
1850     case SPELL_TELEPORT_SELF:
1851     case SPELL_HASTE:
1852     case SPELL_DEATHS_DOOR:
1853     case SPELL_BERSERKER_RAGE:
1854     case SPELL_MIGHT:
1855     case SPELL_WIND_BLAST:
1856         return true;
1857     case SPELL_VAMPIRIC_DRAINING:
1858         return !targ_sanct && targ_adj && !targ_friendly && !targ_undead;
1859     case SPELL_BLINK_AWAY:
1860     case SPELL_BLINK_RANGE:
1861     case SPELL_INJURY_MIRROR:
1862         return !targ_friendly;
1863     case SPELL_BLINK_OTHER:
1864         return !targ_sanct && targ_adj && !targ_friendly;
1865     case SPELL_CONFUSE:
1866     case SPELL_DRAIN_LIFE:
1867     case SPELL_BANISHMENT:
1868     case SPELL_HELLFIRE_BURST:
1869     case SPELL_FIREBALL:
1870     case SPELL_AIRSTRIKE:
1871     case SPELL_IOOD:
1872     case SPELL_ENSNARE:
1873     case SPELL_THROW_FLAME:
1874     case SPELL_SILVER_BLAST:
1875         return !targ_friendly && !targ_sanct;
1876     case SPELL_BLINK:
1877     case SPELL_CONTROLLED_BLINK:
1878         return targ_adj;
1879     case SPELL_TOMB_OF_DOROKLOHE:
1880         return true;
1881     case SPELL_NO_SPELL:
1882         return false;
1883     case SPELL_INK_CLOUD:
1884         if (mon->type == MONS_KRAKEN)
1885             return true;
1886     default:
1887         return !targ_adj && spell_typematch(monspell, SPTYP_SUMMONING);
1888     }
1889 }
1890
1891 // Spells for a quick get-away.
1892 // Currently only used to get out of a net.
1893 static bool _ms_quick_get_away(const monster* mon, spell_type monspell)
1894 {
1895     switch (monspell)
1896     {
1897     case SPELL_TELEPORT_SELF:
1898         // Don't cast again if already about to teleport.
1899         if (mon->has_ench(ENCH_TP))
1900             return false;
1901         // intentional fall-through
1902     case SPELL_BLINK:
1903         return true;
1904     default:
1905         return false;
1906     }
1907 }
1908
1909 static void _mons_set_priest_wizard_god(monster* mons, bool& priest,
1910                                         bool& wizard, god_type& god)
1911 {
1912     priest = mons->is_priest();
1913     wizard = mons->is_actual_spellcaster();
1914
1915     // If the monster's a priest, assume summons come from priestly
1916     // abilities, in which case they'll have the same god. If the
1917     // monster is neither a priest nor a wizard, assume summons come
1918     // from intrinsic abilities, in which case they'll also have the
1919     // same god.
1920     god = (priest || !(priest || wizard)) ? mons->god : GOD_NO_GOD;
1921
1922     // Permanent wizard summons of Yred should have the same god even
1923     // though they aren't priests. This is so that e.g. the zombies of
1924     // Yred's enslaved souls will properly turn on you if you abandon
1925     // Yred.
1926     if (mons->god == GOD_YREDELEMNUL)
1927         god = mons->god;
1928 }
1929
1930 // Is it worth bothering to invoke recall? (Currently defined by there being at
1931 // least 3 things we could actually recall, and then with a probability inversely
1932 // proportional to how many HD of allies are current nearby)
1933 static bool _should_recall(monster* caller)
1934 {
1935     int num = 0;
1936     for (monster_iterator mi; mi; ++mi)
1937     {
1938         if (mons_is_recallable(caller, *mi) && !caller->can_see(*mi))
1939             ++num;
1940     }
1941
1942     // Since there are reinforcements we could recall, do we think we need them?
1943     if (num > 2)
1944     {
1945         int ally_hd = 0;
1946         for (monster_iterator mi; mi; ++mi)
1947         {
1948             if (*mi != caller && caller->can_see(*mi) && mons_aligned(caller, *mi))
1949                 ally_hd += mi->hit_dice;
1950         }
1951         return (25 + roll_dice(2, 22) > ally_hd);
1952     }
1953     else
1954         return false;
1955 }
1956
1957 unsigned short mons_word_of_recall(monster* mons, unsigned short recall_target)
1958 {
1959     unsigned short num_recalled = 0;
1960     vector<monster* > mon_list;
1961
1962     // Build the list of recallable monsters and randomize
1963     for (monster_iterator mi; mi; ++mi)
1964     {
1965         // Don't recall ourselves
1966         if (*mi == mons)
1967             continue;
1968
1969         if (!mons_is_recallable(mons, *mi))
1970             continue;
1971
1972         // Don't recall things that are already close to us
1973         if ((mons && mons->can_see(*mi))
1974             || (!mons && you.can_see(*mi)))
1975         {
1976             continue;
1977         }
1978
1979         mon_list.push_back(*mi);
1980     }
1981     shuffle_array(mon_list);
1982
1983     coord_def target   = (mons) ? mons->pos() : you.pos();
1984     unsigned short foe = (mons) ? mons->foe   : MHITYOU;
1985
1986     // Now actually recall things
1987     for (unsigned int i = 0; i < mon_list.size(); ++i)
1988     {
1989         coord_def empty;
1990         if (find_habitable_spot_near(target, mons_base_type(mon_list[i]),
1991                                      3, false, empty)
1992             && mon_list[i]->move_to_pos(empty))
1993         {
1994             mon_list[i]->behaviour = BEH_SEEK;
1995             mon_list[i]->foe = foe;
1996             ++num_recalled;
1997             simple_monster_message(mon_list[i], " is recalled.");
1998         }
1999         // Can only recall a couple things at once
2000         if (num_recalled == recall_target)
2001             break;
2002     }
2003     return num_recalled;
2004 }
2005
2006 static bool _valid_vine_spot(coord_def p)
2007 {
2008     if (actor_at(p) || !monster_habitable_grid(MONS_PLANT, grd(p)))
2009         return false;
2010
2011     int num_trees = 0;
2012     bool valid_trees = false;
2013     for (adjacent_iterator ai(p); ai; ++ai)
2014     {
2015         if (feat_is_tree(grd(*ai)))
2016         {
2017             // Make sure this spot is not on a diagonal to its only adjacent
2018             // tree (so that the vines can pull back against the tree properly)
2019             if (num_trees || !((*ai-p).sgn().x != 0 && (*ai-p).sgn().y != 0))
2020             {
2021                 valid_trees = true;
2022                 break;
2023             }
2024             else
2025                 ++num_trees;
2026         }
2027     }
2028
2029     if (!valid_trees)
2030         return false;
2031
2032     // Now the connectivity check
2033     return (!plant_forbidden_at(p, true));
2034 }
2035
2036 static bool _awaken_vines(monster* mon, bool test_only = false)
2037 {
2038     vector<coord_def> spots;
2039     for (radius_iterator ri(mon->get_los_no_trans()); ri; ++ri)
2040     {
2041         if (_valid_vine_spot(*ri))
2042             spots.push_back(*ri);
2043     }
2044
2045     shuffle_array(spots);
2046
2047     actor* foe = mon->get_foe();
2048
2049     int num_vines = 1 + random2(3);
2050     if (mon->props.exists("vines_awakened"))
2051         num_vines = min(num_vines, 3 - mon->props["vines_awakened"].get_int());
2052     bool seen = false;
2053
2054     for (unsigned int i = 0; i < spots.size(); ++i)
2055     {
2056         // Don't place vines where they can't see our target
2057         if (!cell_see_cell(spots[i], foe->pos(), LOS_NO_TRANS))
2058             continue;
2059
2060         // Don't place a vine too near to another existing one
2061         bool too_close = false;
2062         for (distance_iterator di(spots[i], false, true, 3); di; ++di)
2063         {
2064             monster* m = monster_at(*di);
2065             if (m && m->type == MONS_SNAPLASHER_VINE)
2066             {
2067                 too_close = true;
2068                 break;
2069             }
2070         }
2071         if (too_close)
2072             continue;
2073
2074         // We've found at least one valid spot, so the spell should be castable
2075         if (test_only)
2076             return true;
2077
2078         // Actually place the vine and update properties
2079         if (monster* vine = create_monster(
2080             mgen_data(MONS_SNAPLASHER_VINE, SAME_ATTITUDE(mon), mon,
2081                         0, SPELL_AWAKEN_VINES, spots[i], mon->foe,
2082                         MG_FORCE_PLACE, mon->god, MONS_NO_MONSTER)))
2083         {
2084             vine->props["vine_awakener"].get_int() = mon->mid;
2085             mon->props["vines_awakened"].get_int()++;
2086             mon->add_ench(mon_enchant(ENCH_AWAKEN_VINES, 1, NULL, 200));
2087             --num_vines;
2088             if (you.can_see(vine))
2089                 seen = true;
2090         }
2091
2092         // We've finished placing all our vines
2093         if (num_vines == 0)
2094             break;
2095     }
2096
2097     if (test_only)
2098         return false;
2099     else
2100     {
2101         if (seen)
2102             mpr("Vines fly forth from the trees!");
2103         return true;
2104     }
2105 }
2106
2107 static void _cast_druids_call(const monster* mon)
2108 {
2109     vector<monster*> mon_list;
2110     for (monster_iterator mi; mi; ++mi)
2111     {
2112         if (_valid_druids_call_target(mon, *mi))
2113             mon_list.push_back(*mi);
2114     }
2115
2116     shuffle_array(mon_list);
2117
2118     // Can call a second low-HD monster if (and only if) the first called was
2119     // also low-HD (otherwise this summons a single creature)
2120     bool second = false;
2121     for (unsigned int i = 0; i < mon_list.size(); ++i)
2122     {
2123         if (second && mon_list[i]->hit_dice > 10)
2124             continue;
2125
2126         coord_def empty;
2127         if (find_habitable_spot_near(mon->pos(), mons_base_type(mon_list[i]),
2128                                      3, false, empty)
2129             && mon_list[i]->move_to_pos(empty))
2130         {
2131             mon_list[i]->behaviour = BEH_SEEK;
2132             mon_list[i]->foe = mon->foe;
2133             mon_list[i]->add_ench(ENCH_MIGHT);
2134             mon_list[i]->flags |= MF_WAS_IN_VIEW;
2135             simple_monster_message(mon_list[i], " answers the druid's call!");
2136
2137             // If this is a low-HD monster, try to summon a second. Otherwise,
2138             // we're done. (Only normal druids can ever summon two monsters)
2139             if (!second && mon_list[i]->hit_dice <= 10 && mon->hit_dice > 10)
2140                 second = true;
2141             else
2142                 return;
2143         }
2144     }
2145 }
2146
2147 static double _angle_between(coord_def origin, coord_def p1, coord_def p2)
2148 {
2149     double ang0 = atan2(p1.x - origin.x, p1.y - origin.y);
2150     double ang  = atan2(p2.x - origin.x, p2.y - origin.y);
2151     return min(fabs(ang - ang0), fabs(ang - ang0 + 2 * PI));
2152 }
2153
2154 // Does there already appear to be a bramble wall in this direction?
2155 // We approximate this by seeing if there are at least two briar patches in
2156 // a ray between us and our target, which turns out to be a pretty decent
2157 // metric in practice.
2158 static bool _already_bramble_wall(const monster* mons, coord_def targ)
2159 {
2160     bolt tracer;
2161     tracer.source = mons->pos();
2162     tracer.target = targ;
2163     tracer.range = 12;
2164     tracer.is_tracer = true;
2165     tracer.is_beam = true;
2166     tracer.fire();
2167
2168     int briar_count = 0;
2169     bool targ_reached = false;
2170     for (unsigned int i = 0; i < tracer.path_taken.size(); ++i)
2171     {
2172         coord_def p = tracer.path_taken[i];
2173
2174         if (!targ_reached && p == targ)
2175             targ_reached = true;
2176         else if (!targ_reached)
2177             continue;
2178
2179         if (monster_at(p) && monster_at(p)->type == MONS_BRIAR_PATCH)
2180             ++briar_count;
2181     }
2182
2183     return (briar_count > 1);
2184 }
2185
2186 static bool _wall_of_brambles(monster* mons)
2187 {
2188     mgen_data briar_mg = mgen_data(MONS_BRIAR_PATCH, SAME_ATTITUDE(mons),
2189                                    mons, 0, 0, coord_def(-1, -1), MHITNOT,
2190                                    MG_FORCE_PLACE);
2191
2192     // We want to raise a defensive wall if we think our foe is moving to attack
2193     // us, and otherwise raise a wall further away to block off their escape.
2194     // (Each wall type uses different parameters)
2195     bool defensive = mons->props["foe_approaching"].get_bool();
2196
2197     coord_def aim_pos = you.pos();
2198     coord_def targ_pos = mons->pos();
2199
2200     // A defensive wall cannot provide any cover if our target is already
2201     // adjacent, so don't bother creating one.
2202     if (defensive && mons->pos().distance_from(aim_pos) == 1)
2203         return false;
2204
2205     // Don't raise a non-defensive wall if it looks like there's an existing one
2206     // in the same direction already (this looks rather silly to see walls
2207     // springing up in the distance behind already-closed paths, and probably
2208     // is more likely to aid the player than the monster)
2209     if (!defensive)
2210     {
2211         if (_already_bramble_wall(mons, aim_pos))
2212             return false;
2213     }
2214
2215     // Select a random radius for the circle used draw an arc from (affects
2216     // both shape and distance of the resulting wall)
2217     int rad = (defensive ? random_range(3, 5)
2218                          : min(11, mons->pos().distance_from(you.pos()) + 6));
2219
2220     // Adjust the center of the circle used to draw the arc of the wall if
2221     // we're raising one defensively, based on both its radius and foe distance.
2222     // (The idea is the ensure that our foe will end up on the other side of it
2223     // without always raising the wall in exactly the same shape and position)
2224     if (defensive)
2225     {
2226         coord_def adjust = (targ_pos - aim_pos).sgn();
2227
2228         targ_pos += adjust;
2229         if (rad == 5)
2230             targ_pos += adjust;
2231         if (mons->pos().distance_from(aim_pos) == 2)
2232             targ_pos += adjust;
2233     }
2234
2235     // XXX: There is almost certainly a better way to calculate the points
2236     //      along the desired arcs, though this code produces the proper look.
2237     vector<coord_def> points;
2238     for (distance_iterator di(targ_pos, false, false, rad); di; ++di)
2239     {
2240         if (di.radius() == rad || di.radius() == rad - 1)
2241         {
2242             if (!actor_at(*di) && !cell_is_solid(*di))
2243             {
2244                 if (defensive && _angle_between(targ_pos, aim_pos, *di) <= PI/4.0
2245                     || (!defensive
2246                         && _angle_between(targ_pos, aim_pos, *di) <= PI/(4.2 + rad/6.0)))
2247                 {
2248                     points.push_back(*di);
2249                 }
2250             }
2251         }
2252     }
2253
2254     bool seen = false;
2255     for (unsigned int i = 0; i < points.size(); ++i)
2256     {
2257         briar_mg.pos = points[i];
2258         monster* briar = create_monster(briar_mg, false);
2259         if (briar)
2260         {
2261             briar->add_ench(mon_enchant(ENCH_SHORT_LIVED, 1, NULL, 80 + random2(100)));
2262             if (you.can_see(briar))
2263                 seen = true;
2264         }
2265     }
2266
2267     if (seen)
2268         mpr("Thorny briars emerge from the ground!");
2269
2270     return true;
2271 }
2272
2273 static bool _should_tornado(monster* agent)
2274 {
2275     if (agent->has_ench(ENCH_TORNADO) || agent->has_ench(ENCH_TORNADO_COOLDOWN))
2276         return false;
2277
2278     bolt tracer;
2279     tracer.foe_ratio = 80;
2280     for (actor_near_iterator ai(agent, LOS_NO_TRANS); ai; ++ai)
2281     {
2282         if (agent == *ai || ai->res_wind() || !ai->visible_to(agent))
2283             continue;
2284
2285         if (mons_aligned(agent, *ai))
2286         {
2287             tracer.friend_info.count++;
2288             tracer.friend_info.power +=
2289                     ai->is_player() ? you.experience_level
2290                                     : ai->as_monster()->hit_dice;
2291         }
2292         else
2293         {
2294             tracer.foe_info.count++;
2295             tracer.foe_info.power +=
2296                     ai->is_player() ? you.experience_level
2297                                     : ai->as_monster()->hit_dice;
2298         }
2299     }
2300     return mons_should_fire(tracer);
2301 }
2302
2303 //---------------------------------------------------------------
2304 //
2305 // handle_mon_spell
2306 //
2307 // Give the monster a chance to cast a spell. Returns true if
2308 // a spell was cast.
2309 //
2310 //---------------------------------------------------------------
2311 bool handle_mon_spell(monster* mons, bolt &beem)
2312 {
2313     bool monsterNearby = mons_near(mons);
2314     bool finalAnswer   = false;   // as in: "Is that your...?" {dlb}
2315     const spell_type draco_breath = _get_draconian_breath_spell(mons);
2316     actor *foe = mons->get_foe();
2317
2318     // A polymorphed unique will retain his or her spells even in another
2319     // form. If the new form has the SPELLCASTER flag, casting happens as
2320     // normally, otherwise we need to enforce it, but it only happens with
2321     // a 50% chance.
2322     const bool spellcasting_poly(
2323         !mons->can_use_spells()
2324         && mons_class_flag(mons->type, M_SPEAKS)
2325         && mons->has_spells());
2326
2327     if (is_sanctuary(mons->pos()) && !mons->wont_attack())
2328         return false;
2329
2330     // Yes, there is a logic to this ordering {dlb}:
2331     // .. berserk check is necessary for out-of-sequence actions like emergency
2332     // slot spells {blue}
2333     if (mons->asleep()
2334         || mons->submerged()
2335         || mons->berserk_or_insane()
2336         || (!mons->can_use_spells()
2337             && !spellcasting_poly
2338             && draco_breath == SPELL_NO_SPELL))
2339     {
2340         return false;
2341     }
2342
2343     bool priest;
2344     bool wizard;
2345     god_type god;
2346
2347     _mons_set_priest_wizard_god(mons, priest, wizard, god);
2348
2349     if ((silenced(mons->pos()) || mons->has_ench(ENCH_MUTE)
2350          || (mons->has_ench(ENCH_WATER_HOLD) && !mons->res_water_drowning()))
2351         && (priest || wizard || spellcasting_poly
2352             || mons_class_flag(mons->type, M_SPELL_NO_SILENT)))
2353     {
2354         return false;
2355     }
2356
2357     // Shapeshifters don't get spells.
2358     if (mons->is_shapeshifter() && (priest || wizard))
2359         return false;
2360     else if (mons_is_confused(mons, false))
2361         return false;
2362     else if (mons_is_ghost_demon(mons->type)
2363              && !mons->ghost->spellcaster)
2364     {
2365         return false;
2366     }
2367     else if (random2(200) > mons->hit_dice + 50
2368                             + ((mons_class_flag(mons->type, M_STABBER)
2369                                 && mons->pos() == mons->firing_pos) ? 75 : 0))
2370     {
2371         return false;
2372     }
2373     else if (spellcasting_poly && coinflip()) // 50% chance of not casting
2374         return false;
2375     else
2376     {
2377         spell_type spell_cast = SPELL_NO_SPELL;
2378         monster_spells hspell_pass(mons->spells);
2379
2380         if (!mon_enemies_around(mons))
2381         {
2382             // Force the casting of dig when the player is not visible -
2383             // this is EVIL!
2384             // only do this for monsters that are actually seeking out a
2385             // hostile target -doy
2386             if (mons->has_spell(SPELL_DIG)
2387                 && mons_is_seeking(mons)
2388                 && !(mons->wont_attack() && mons->foe == MHITYOU))
2389             {
2390                 spell_cast = SPELL_DIG;
2391                 finalAnswer = true;
2392             }
2393             else if ((mons->has_spell(SPELL_MINOR_HEALING)
2394                          || mons->has_spell(SPELL_MAJOR_HEALING))
2395                      && mons->hit_points < mons->max_hit_points)
2396             {
2397                 // The player's out of sight!
2398                 // Quick, let's take a turn to heal ourselves. -- bwr
2399                 spell_cast = mons->has_spell(SPELL_MAJOR_HEALING) ?
2400                                  SPELL_MAJOR_HEALING : SPELL_MINOR_HEALING;
2401                 finalAnswer = true;
2402             }
2403             else if (mons_is_fleeing(mons) || mons->pacified())
2404             {
2405                 // Since the player isn't around, we'll extend the monster's
2406                 // normal choices to include the self-enchant slot.
2407                 int foundcount = 0;
2408                 for (int i = NUM_MONSTER_SPELL_SLOTS - 1; i >= 0; --i)
2409                 {
2410                     if (_ms_useful_fleeing_out_of_sight(mons, hspell_pass[i])
2411                         && one_chance_in(++foundcount))
2412                     {
2413                         spell_cast = hspell_pass[i];
2414                         finalAnswer = true;
2415                     }
2416                 }
2417             }
2418             else if (mons->foe == MHITYOU && !monsterNearby)
2419                 return false;
2420         }
2421
2422         // Monsters caught in a net try to get away.
2423         // This is only urgent if enemies are around.
2424         if (!finalAnswer && mon_enemies_around(mons)
2425             && mons->caught() && one_chance_in(4))
2426         {
2427             for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
2428             {
2429                 if (_ms_quick_get_away(mons, hspell_pass[i]))
2430                 {
2431                     spell_cast = hspell_pass[i];
2432                     finalAnswer = true;
2433                     break;
2434                 }
2435             }
2436         }
2437
2438         // Promote the casting of useful spells for low-HP monsters.
2439         // (kraken should always cast their escape spell of inky).
2440         if (!finalAnswer
2441             && mons->hit_points < mons->max_hit_points / 3
2442             && (coinflip() || mons->type == MONS_KRAKEN))
2443         {
2444             // Note: There should always be at least some chance we don't
2445             // get here... even if the monster is on its last HP.  That
2446             // way we don't have to worry about monsters infinitely casting
2447             // Healing on themselves (e.g. orc high priests).
2448             if ((mons_is_fleeing(mons) || mons->pacified())
2449                 && _ms_low_hitpoint_cast(mons, hspell_pass[5]))
2450             {
2451                 spell_cast = hspell_pass[5];
2452                 finalAnswer = true;
2453             }
2454
2455             if (!finalAnswer)
2456             {
2457                 int found_spell = 0;
2458                 for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
2459                 {
2460                     if (_ms_low_hitpoint_cast(mons, hspell_pass[i])
2461                         && one_chance_in(++found_spell))
2462                     {
2463                         spell_cast  = hspell_pass[i];
2464                         finalAnswer = true;
2465                     }
2466                 }
2467             }
2468         }
2469
2470         if (!finalAnswer)
2471         {
2472             // If nothing found by now, safe friendlies and good
2473             // neutrals will rarely cast.
2474             if (mons->wont_attack() && !mon_enemies_around(mons)
2475                 && !one_chance_in(10))
2476             {
2477                 return false;
2478             }
2479
2480             // Remove healing/invis/haste if we don't need them.
2481             int num_no_spell = 0;
2482
2483             for (int i = 0; i < NUM_MONSTER_SPELL_SLOTS; ++i)
2484             {
2485                 if (hspell_pass[i] == SPELL_NO_SPELL)
2486                     num_no_spell++;
2487                 else if (_ms_waste_of_time(mons, hspell_pass[i])
2488                          || hspell_pass[i] == SPELL_DIG)
2489                 {
2490                     // Instead of making a new one,
2491                     // make the weapon attack
2492                     if (hspell_pass[i] == SPELL_SPECTRAL_WEAPON)
2493                         hspell_pass[i] = SPELL_MELEE;
2494
2495                     // Should monster not have selected dig by now,
2496                     // it never will.
2497                     hspell_pass[i] = SPELL_NO_SPELL;
2498                     num_no_spell++;
2499                 }
2500             }
2501
2502             // If no useful spells... cast no spell.
2503             if (num_no_spell == NUM_MONSTER_SPELL_SLOTS
2504                 && draco_breath == SPELL_NO_SPELL)
2505             {
2506                 return false;
2507             }
2508
2509             const bolt orig_beem = beem;
2510             // Up to five tries to pick a spell,
2511             // with the last try being a self-enchantment.
2512             for (int loopy = 0; loopy < 5; ++loopy)
2513             {
2514                 beem = orig_beem;
2515
2516                 bool spellOK = false;
2517
2518                 // Setup spell.
2519                 // If we're in the last attempt, try the self-enchantment.
2520                 if (loopy == 4 && coinflip())
2521                     spell_cast = hspell_pass[2];
2522                 // Monsters that are fleeing or pacified and leaving the
2523                 // level will always try to choose their emergency spell.
2524                 else if (mons_is_fleeing(mons) || mons->pacified())
2525                 {
2526                     spell_cast = (one_chance_in(5) ? SPELL_NO_SPELL
2527                                                    : hspell_pass[5]);
2528
2529                     if (crawl_state.game_is_zotdef()
2530                         && mons->type == MONS_ICE_STATUE)
2531                     {
2532                         // Don't spam ice beasts when wounded.
2533                         spell_cast = SPELL_NO_SPELL;
2534                     }
2535
2536                     // Pacified monsters leaving the level will only
2537                     // try and cast escape spells.
2538                     if (spell_cast != SPELL_NO_SPELL
2539                         && mons->pacified()
2540                         && !testbits(get_spell_flags(spell_cast), SPFLAG_ESCAPE))
2541                     {
2542                         spell_cast = SPELL_NO_SPELL;
2543                     }
2544                 }
2545                 else
2546                 {
2547                     // Randomly picking one of the non-emergency spells:
2548                     spell_cast = hspell_pass[random2(5)];
2549                 }
2550
2551                 if (spell_cast == SPELL_NO_SPELL)
2552                     continue;
2553
2554                 // Setup the spell.
2555                 if (spell_cast != SPELL_MELEE)
2556                     setup_mons_cast(mons, beem, spell_cast);
2557
2558                 // Try to find a nearby ally to haste, heal or might.
2559                 if ((spell_cast == SPELL_HASTE_OTHER
2560                      || spell_cast == SPELL_HEAL_OTHER
2561                      || spell_cast == SPELL_MIGHT_OTHER)
2562                         && !_set_allied_target(mons, beem,
2563                                mons->type == MONS_IRONBRAND_CONVOKER))
2564                 {
2565                     spell_cast = SPELL_NO_SPELL;
2566                     continue;
2567                 }
2568
2569                 // Alligators shouldn't spam swiftness.
2570                 if (spell_cast == SPELL_SWIFTNESS
2571                     && mons->type == MONS_ALLIGATOR
2572                     && ((int) mons->number + random2avg(170, 5) >=
2573                         you.num_turns))
2574                 {
2575                     spell_cast = SPELL_NO_SPELL;
2576                     continue;
2577                 }
2578
2579                 // And Mara shouldn't cast player ghost if he can't
2580                 // see the player
2581                 if (spell_cast == SPELL_SUMMON_ILLUSION
2582                     && mons->type == MONS_MARA
2583                     && (!foe
2584                         || !mons->can_see(foe)
2585                         || !actor_is_illusion_cloneable(foe)))
2586                 {
2587                     spell_cast = SPELL_NO_SPELL;
2588                     continue;
2589                 }
2590
2591                 // Monsters are limited casting it, too.
2592                 if (spell_cast == SPELL_MALIGN_GATEWAY
2593                     && !can_cast_malign_gateway())
2594                 {
2595                     spell_cast = SPELL_NO_SPELL;
2596                     continue;
2597                 }
2598
2599                 // Same limitations as player.
2600                 if (spell_cast == SPELL_LEDAS_LIQUEFACTION
2601                     && (!mons->stand_on_solid_ground()
2602                         || liquefied(mons->pos())))
2603                 {
2604                     spell_cast = SPELL_NO_SPELL;
2605                     continue;
2606                 }
2607
2608                 // Don't torment your allies. Maybe we want to add other
2609                 // spells here? Mass confusion, tornado, etc.?
2610                 if (you.visible_to(mons) && mons_aligned(mons, &you))
2611                 {
2612                     if ((spell_cast == SPELL_SYMBOL_OF_TORMENT
2613                              && !player_res_torment(false)
2614                              && !player_kiku_res_torment())
2615                          || (spell_cast == SPELL_OZOCUBUS_REFRIGERATION
2616                              && !player_res_cold(false)))
2617                     {
2618                         spell_cast = SPELL_NO_SPELL;
2619                         continue;
2620                     }
2621                 }
2622
2623                 // beam-type spells requiring tracers
2624                 if (spell_needs_tracer(spell_cast))
2625                 {
2626                     const bool explode =
2627                         spell_is_direct_explosion(spell_cast);
2628                     fire_tracer(mons, beem, explode);
2629                     // Good idea?
2630                     if (mons_should_fire(beem))
2631                         spellOK = true;
2632                 }
2633                 else
2634                 {
2635                     // All direct-effect/summoning/self-enchantments/etc.
2636                     spellOK = true;
2637
2638                     if (_ms_direct_nasty(spell_cast)
2639                         && mons_aligned(mons, (mons->foe == MHITYOU) ?
2640                            &you : foe)) // foe=get_foe() is NULL for friendlies
2641                     {                   // targetting you, which is bad here.
2642                         spellOK = false;
2643                     }
2644                     else if (mons->foe == MHITYOU || mons->foe == MHITNOT)
2645                     {
2646                         // XXX: Note the crude hack so that monsters can
2647                         // use ME_ALERT to target (we should really have
2648                         // a measure of time instead of peeking to see
2649                         // if the player is still there). -- bwr
2650                         if (!you.visible_to(mons)
2651                             && (mons->target != you.pos() || coinflip()))
2652                         {
2653                             spellOK = false;
2654                         }
2655                     }
2656                     else if (!mons->can_see(&menv[mons->foe]))
2657                         spellOK = false;
2658                     else if (mons->type == MONS_DAEVA
2659                              && mons->god == GOD_SHINING_ONE)
2660                     {
2661                         const monster* mon = &menv[mons->foe];
2662
2663                         // Don't allow TSO-worshipping daevas to make
2664                         // unchivalric magic attacks, except against
2665                         // appropriate monsters.
2666                         if (is_unchivalric_attack(mons, mon)
2667                             && !tso_unchivalric_attack_safe_monster(mon))
2668                         {
2669                             spellOK = false;
2670                         }
2671                     }
2672                 }
2673
2674                 if (!spellOK)
2675                     spell_cast = SPELL_NO_SPELL;
2676
2677                 if (spell_cast != SPELL_NO_SPELL)
2678                     break;
2679             }
2680         }
2681
2682         bool was_drac_breath = false;
2683
2684         // If there's otherwise no ranged attack use the breath weapon.
2685         // The breath weapon is also occasionally used.
2686         if (draco_breath != SPELL_NO_SPELL
2687             && (spell_cast == SPELL_NO_SPELL
2688                  || !_is_emergency_spell(hspell_pass, spell_cast)
2689                     && one_chance_in(4))
2690             && !player_or_mon_in_sanct(mons)
2691             && !mons->has_ench(ENCH_BREATH_WEAPON))
2692         {
2693             spell_cast = draco_breath;
2694             setup_mons_cast(mons, beem, spell_cast);
2695             finalAnswer = true;
2696             was_drac_breath = true;
2697         }
2698
2699         // Should the monster *still* not have a spell, well, too bad {dlb}:
2700         if (spell_cast == SPELL_NO_SPELL || spell_cast == SPELL_MELEE)
2701             return false;
2702
2703         // Friendly monsters don't use polymorph, as it's likely to cause
2704         // runaway growth of an enemy.
2705         if (spell_cast == SPELL_POLYMORPH && mons->friendly())
2706             return false;
2707
2708         // Past this point, we're actually casting, instead of just pondering.
2709
2710         // Check for antimagic.
2711         if (mons->has_ench(ENCH_ANTIMAGIC)
2712             && !x_chance_in_y(4 * BASELINE_DELAY,
2713                               4 * BASELINE_DELAY
2714                               + mons->get_ench(ENCH_ANTIMAGIC).duration)
2715             && !_is_physiological_spell(spell_cast)
2716             && spell_cast != draco_breath)
2717         {
2718             // This may be a bad idea -- if we decide monsters shouldn't
2719             // lose a turn like players do not, please make this just return.
2720             simple_monster_message(mons, " falters for a moment.");
2721             mons->lose_energy(EUT_SPELL);
2722             return true;
2723         }
2724         // Try to animate dead: if nothing rises, pretend we didn't cast it.
2725         else if (spell_cast == SPELL_ANIMATE_DEAD)
2726         {
2727             if (mons->friendly() && !_animate_dead_okay(spell_cast))
2728                 return false;
2729
2730             if (mons->is_summoned())
2731                 return false;
2732
2733             if (!animate_dead(mons, 100, SAME_ATTITUDE(mons),
2734                               mons->foe, mons, "", god, false))
2735             {
2736                 return false;
2737             }
2738         }
2739         // Ditto for crawling corpses.
2740         else if (spell_cast == SPELL_TWISTED_RESURRECTION)
2741         {
2742             if (mons->friendly() && !_animate_dead_okay(spell_cast))
2743                 return false;
2744
2745             if (mons->is_summoned())
2746                 return false;
2747
2748             if (!twisted_resurrection(mons, 500, SAME_ATTITUDE(mons),
2749                                       mons->foe, god, false))
2750             {
2751                 return false;
2752             }
2753         }
2754         // Ditto for simulacra.
2755         else if (spell_cast == SPELL_SIMULACRUM)
2756         {
2757             if (mons->friendly() && !_animate_dead_okay(spell_cast))
2758                 return false;
2759
2760             if (!monster_simulacrum(mons, false))
2761                 return false;
2762         }
2763         // Ditto for vines
2764         else if (spell_cast == SPELL_AWAKEN_VINES)
2765         {
2766             if (!_awaken_vines(mons, true))
2767                 return false;
2768         }
2769         // Try to cause fear: if nothing is scared, pretend we didn't cast it.
2770         else if (spell_cast == SPELL_CAUSE_FEAR)
2771         {
2772             if (_mons_cause_fear(mons, false) < 0)
2773                 return false;
2774         }
2775         // Check use of LOS attack spells.
2776         else if (spell_cast == SPELL_DRAIN_LIFE
2777                  || spell_cast == SPELL_OZOCUBUS_REFRIGERATION)
2778         {
2779             if (cast_los_attack_spell(spell_cast, mons->hit_dice, mons,
2780                                       false) != SPRET_SUCCESS)
2781                 return false;
2782         }
2783         else if (spell_cast == SPELL_OLGREBS_TOXIC_RADIANCE)
2784         {
2785             if (cast_toxic_radiance(mons, 100, false, true) != SPRET_SUCCESS)
2786                 return false;
2787         }
2788         // See if we have a good spot to cast LRD at.
2789         else if (spell_cast == SPELL_LRD)
2790         {
2791             if (!in_bounds(_mons_fragment_target(mons)))
2792                 return false;
2793         }
2794         // Try to cast Shatter; if nothing happened, pretend we didn't cast it.
2795         else if (spell_cast == SPELL_SHATTER)
2796         {
2797             if (!mons_shatter(mons, false))
2798                 return false;
2799         }
2800         // Check if it's possible to spawn more tentacles. If not, don't bother trying.
2801         else if (spell_cast == SPELL_CREATE_TENTACLES)
2802         {
2803             if (!_mons_available_tentacles(mons))
2804                 return false;
2805         }
2806         // Only cast word of recall if there's enough things to bother recalling
2807         else if (spell_cast == SPELL_WORD_OF_RECALL)
2808         {
2809             if (!_should_recall(mons))
2810                 return false;
2811         }
2812         // Try to mass confuse; if we can't, pretend nothing happened.
2813         else if (spell_cast == SPELL_MASS_CONFUSION)
2814         {
2815             if (_mons_mass_confuse(mons, false) < 0)
2816                 return false;
2817         }
2818         // Check if our enemy can be slowed for Metabolic Englaciation.
2819         else if (spell_cast == SPELL_ENGLACIATION)
2820         {
2821             if (!foe
2822                 || !mons->see_cell_no_trans(mons->target)
2823                 || foe->res_cold() > 0
2824                 || (foe->is_monster()
2825                     && (mons_is_firewood(foe->as_monster())
2826                         || foe->as_monster()->has_ench(ENCH_SLOW)))
2827                 || (!foe->is_monster()
2828                     && you.duration[DUR_SLOW] > 0))
2829             {
2830                 return false;
2831             }
2832         }
2833         else if (spell_cast == SPELL_TORNADO)
2834         {
2835             if (!_should_tornado(mons))
2836                 return false;
2837         }
2838
2839         if (mons->type == MONS_BALL_LIGHTNING)
2840             mons->suicide();
2841
2842         // Dragons now have a time-out on their breath weapons, draconians too!
2843         if (mons_genus(mons->type) == MONS_DRAGON
2844             || (mons_genus(mons->type) == MONS_DRACONIAN && was_drac_breath))
2845         {
2846             setup_breath_timeout(mons);
2847         }
2848
2849         // FINALLY! determine primary spell effects {dlb}:
2850         if (spell_cast == SPELL_BLINK || spell_cast == SPELL_CONTROLLED_BLINK)
2851         {
2852             // Why only cast blink if nearby? {dlb}
2853             if (monsterNearby)
2854             {
2855                 mons_cast_noise(mons, beem, spell_cast);
2856                 monster_blink(mons);
2857
2858                 mons->lose_energy(EUT_SPELL);
2859             }
2860             else
2861                 return false;
2862         }
2863         else if (spell_cast == SPELL_BLINK_RANGE)
2864         {
2865             blink_range(mons);
2866             mons->lose_energy(EUT_SPELL);
2867         }
2868         else if (spell_cast == SPELL_BLINK_AWAY)
2869         {
2870             blink_away(mons, true);
2871             mons->lose_energy(EUT_SPELL);
2872         }
2873         else if (spell_cast == SPELL_BLINK_CLOSE)
2874         {
2875             blink_close(mons);
2876             mons->lose_energy(EUT_SPELL);
2877         }
2878         else
2879         {
2880             const bool battlesphere = mons->props.exists("battlesphere");
2881             if (spell_needs_foe(spell_cast))
2882                 make_mons_stop_fleeing(mons);