Revert "Revert Abyss/Thrashing horror changes"
[crawl:crawl.git] / crawl-ref / source / mon-place.cc
1 /**
2  * @file
3  * @brief Functions used when placing monsters in the dungeon.
4 **/
5
6 #include "AppHdr.h"
7
8 #include <algorithm>
9
10 #include "mon-place.h"
11 #include "mgen_data.h"
12
13 #include "abyss.h"
14 #include "act-iter.h"
15 #include "areas.h"
16 #include "arena.h"
17 #include "branch.h"
18 #include "cloud.h"
19 #include "colour.h"
20 #include "coordit.h"
21 #include "directn.h"
22 #include "dungeon.h"
23 #include "fprop.h"
24 #include "godabil.h"
25 #include "externs.h"
26 #include "options.h"
27 #include "ghost.h"
28 #include "lev-pand.h"
29 #include "libutil.h"
30 #include "losglobal.h"
31 #include "message.h"
32 #include "mislead.h"
33 #include "mon-behv.h"
34 #include "mon-chimera.h"
35 #include "mon-death.h"
36 #include "mon-gear.h"
37 #include "mon-pick.h"
38 #include "mon-stuff.h"
39 #include "place.h"
40 #include "random.h"
41 #include "religion.h"
42 #include "shopping.h"
43 #include "spl-clouds.h"
44 #include "spl-damage.h"
45 #include "sprint.h"
46 #include "stairs.h"
47 #include "state.h"
48 #include "env.h"
49 #include "terrain.h"
50 #include "tilepick.h"
51 #include "traps.h"
52 #include "travel.h"
53 #include "unwind.h"
54 #include "view.h"
55 #include "viewchar.h"
56 #ifdef USE_TILE
57  #include "tiledef-player.h"
58 #endif
59
60 band_type active_monster_band = BAND_NO_BAND;
61
62 static vector<int> vault_mon_types;
63 static vector<int> vault_mon_bases;
64 static vector<int> vault_mon_weights;
65 static vector<bool> vault_mon_bands;
66
67 #define VAULT_MON_TYPES_KEY   "vault_mon_types"
68 #define VAULT_MON_BASES_KEY   "vault_mon_bases"
69 #define VAULT_MON_WEIGHTS_KEY "vault_mon_weights"
70 #define VAULT_MON_BANDS_KEY   "vault_mon_bands"
71
72 // proximity is the same as for mons_place:
73 // 0 is no restrictions
74 // 1 attempts to place near player
75 // 2 attempts to avoid player LOS
76
77 #define BIG_BAND        20
78
79 static monster_type _resolve_monster_type(monster_type mon_type,
80                                           proximity_type proximity,
81                                           monster_type &base_type,
82                                           coord_def &pos,
83                                           unsigned mmask,
84                                           dungeon_char_type *stair_type,
85                                           level_id *place,
86                                           bool *want_band);
87
88 static monster_type _band_member(band_type band, int which);
89 static band_type _choose_band(monster_type mon_type, int &band_size,
90                               bool& natural_leader);
91
92 static monster* _place_monster_aux(const mgen_data &mg, const monster *leader,
93                                    level_id place,
94                                    bool force_pos = false,
95                                    bool dont_place = false);
96
97 // Returns whether actual_feat is compatible with feat_wanted for monster
98 // movement and generation.
99 bool feat_compatible(dungeon_feature_type feat_wanted,
100                      dungeon_feature_type actual_feat)
101 {
102     if (feat_wanted == DNGN_FLOOR)
103         return feat_has_solid_floor(actual_feat);
104
105     if (feat_wanted >= DNGN_ROCK_WALL
106         && feat_wanted <= DNGN_CLEAR_PERMAROCK_WALL)
107     {
108         // A monster can only move through or inhabit permanent rock if that's
109         // exactly what it's asking for.
110         if (actual_feat == DNGN_PERMAROCK_WALL
111             || actual_feat == DNGN_CLEAR_PERMAROCK_WALL)
112         {
113             return (feat_wanted == DNGN_PERMAROCK_WALL
114                     || feat_wanted == DNGN_CLEAR_PERMAROCK_WALL);
115         }
116
117         return (actual_feat >= DNGN_ROCK_WALL
118                 && actual_feat <= DNGN_CLEAR_PERMAROCK_WALL);
119     }
120
121     return (feat_wanted == actual_feat
122             || (feat_wanted == DNGN_DEEP_WATER
123                 && (actual_feat == DNGN_SHALLOW_WATER
124                     || actual_feat == DNGN_FOUNTAIN_BLUE)));
125 }
126
127 // Can this monster survive on actual_grid?
128 //
129 // If you have an actual monster, use this instead of the overloaded function
130 // that uses only the monster class to make decisions.
131 bool monster_habitable_grid(const monster* mon,
132                             dungeon_feature_type actual_grid)
133 {
134     // Zombified monsters enjoy the same habitat as their original.
135     const monster_type mt = mons_base_type(mon);
136
137     return (monster_habitable_grid(mt,
138                                    actual_grid,
139                                    DNGN_UNSEEN,
140                                    mons_flies(mon),
141                                    mon->cannot_move()));
142 }
143
144 bool mons_airborne(monster_type mcls, int flies, bool paralysed)
145 {
146     if (flies == -1)
147         flies = mons_class_flies(mcls);
148
149     return (paralysed ? flies == FL_LEVITATE : flies != FL_NONE);
150 }
151
152 // Can monsters of class monster_class live happily on actual_grid?
153 // Use flies == true to pretend the monster can fly.
154 //
155 // [dshaligram] We're trying to harmonise the checks from various places into
156 // one check, so we no longer care if a water elemental springs into existence
157 // on dry land, because they're supposed to be able to move onto dry land
158 // anyway.
159 bool monster_habitable_grid(monster_type mt,
160                             dungeon_feature_type actual_grid,
161                             dungeon_feature_type wanted_grid_feature,
162                             int flies, bool paralysed)
163 {
164     // No monster may be placed on open sea.
165     if (actual_grid == DNGN_OPEN_SEA || actual_grid == DNGN_LAVA_SEA)
166         return false;
167
168     // Monsters can't use teleporters, and standing there would look just wrong.
169     if (actual_grid == DNGN_TELEPORTER)
170         return false;
171
172     const dungeon_feature_type feat_preferred =
173         habitat2grid(mons_class_primary_habitat(mt));
174     const dungeon_feature_type feat_nonpreferred =
175         habitat2grid(mons_class_secondary_habitat(mt));
176
177     const bool monster_is_airborne = mons_airborne(mt, flies, paralysed);
178
179     // If the caller insists on a specific feature type, try to honour
180     // the request. This allows the builder to place amphibious
181     // creatures only on land, or flying creatures only on lava, etc.
182     if (wanted_grid_feature != DNGN_UNSEEN
183         && (feat_compatible(feat_preferred, wanted_grid_feature)
184             || feat_compatible(feat_nonpreferred, wanted_grid_feature)
185             || (monster_is_airborne && !feat_is_solid(wanted_grid_feature))))
186     {
187         return feat_compatible(wanted_grid_feature, actual_grid);
188     }
189
190     // Special check for fire elementals since their habitat is floor which
191     // is generally considered compatible with shallow water.
192     if (mt == MONS_FIRE_ELEMENTAL && feat_is_watery(actual_grid))
193         return false;
194
195     if (actual_grid == DNGN_MALIGN_GATEWAY)
196     {
197         if (mt == MONS_ELDRITCH_TENTACLE
198             || mt == MONS_ELDRITCH_TENTACLE_SEGMENT)
199         {
200             return true;
201         }
202         else
203             return false;
204     }
205
206     if (feat_compatible(feat_preferred, actual_grid)
207         || (feat_nonpreferred != feat_preferred
208             && feat_compatible(feat_nonpreferred, actual_grid)))
209     {
210         return true;
211     }
212
213     // [dshaligram] Flying creatures are all DNGN_FLOOR, so we
214     // only have to check for the additional valid grids of deep
215     // water and lava.
216     if (monster_is_airborne
217         && (actual_grid == DNGN_LAVA || actual_grid == DNGN_DEEP_WATER))
218     {
219         return true;
220     }
221
222     return false;
223 }
224
225 // Returns true if the monster can submerge in the given grid.
226 bool monster_can_submerge(const monster* mon, dungeon_feature_type feat)
227 {
228     if (testbits(env.pgrid(mon->pos()), FPROP_NO_SUBMERGE))
229         return false;
230     if (!mon->is_habitable_feat(feat))
231         return false;
232     if (mons_class_flag(mon->type, M_SUBMERGES))
233         switch (mons_habitat(mon))
234         {
235         case HT_WATER:
236         case HT_AMPHIBIOUS:
237             return feat_is_watery(feat);
238         case HT_LAVA:
239             return (feat == DNGN_LAVA);
240         case HT_LAND:
241             // Currently, trapdoor spider and air elemental only.
242             return (feat == DNGN_FLOOR);
243         default:
244             return false;
245         }
246     else
247         return false;
248 }
249
250 static bool _is_spawn_scaled_area(const level_id &here)
251 {
252     return (is_connected_branch(here.branch)
253             && !is_hell_subbranch(here.branch)
254             && here.branch != BRANCH_VESTIBULE_OF_HELL
255             && here.branch != BRANCH_HALL_OF_ZOT);
256 }
257
258 // Scale monster generation parameter with time spent on level. Note:
259 // (target_value - base_value) * dropoff_ramp_turns must be < INT_MAX!
260 static int _scale_spawn_parameter(int base_value,
261                                   int target_value,
262                                   int final_value,
263                                   int dropoff_start_turns = 3000,
264                                   int dropoff_ramp_turns  = 12000)
265 {
266     if (!_is_spawn_scaled_area(level_id::current()))
267         return base_value;
268
269     const int turns_on_level = env.turns_on_level;
270     return (turns_on_level <= dropoff_start_turns ? base_value :
271             turns_on_level > dropoff_start_turns + dropoff_ramp_turns ?
272             final_value :
273
274             // Actual scaling, strictly linear at the moment:
275             (base_value +
276              (target_value - base_value)
277              * (turns_on_level - dropoff_start_turns)
278              / dropoff_ramp_turns));
279 }
280
281 static void _apply_ood(level_id &place)
282 {
283     // OODs do not apply to any portal vaults, any 1-level branches, Zot and
284     // hells.  What with newnewabyss?
285     if (!is_connected_branch(place)
286         || startdepth[place.branch] >= 27
287         || brdepth[place.branch] <= 1)
288     {
289         return;
290     }
291
292     // The OOD fuzz roll is not applied at level generation time on
293     // D:1, and is applied slightly less often (0.75*0.14) on D:2. All
294     // other levels have a straight 14% chance of moderate OOD fuzz
295     // for each monster at level generation, and the chances of
296     // moderate OODs go up to 100% after a ramp-up period.
297
298     if (place.branch == BRANCH_MAIN_DUNGEON
299         && (place.depth == 1 && env.turns_on_level < 701
300          || place.depth == 2 && (env.turns_on_level < 584 || one_chance_in(4))))
301     {
302         return;
303     }
304
305 #ifdef DEBUG_DIAGNOSTICS
306     level_id old_place = place;
307 #endif
308
309     if (x_chance_in_y(_scale_spawn_parameter(140, 1000, 1000, 3000, 4800),
310                       1000))
311     {
312         const int fuzzspan = 5;
313         const int fuzz = max(0, random_range(-fuzzspan, fuzzspan, 2));
314
315         // Quite bizarre logic: why should we fail in >50% cases here?
316         if (fuzz)
317         {
318             place.depth += fuzz;
319             dprf("Monster level fuzz: %d (old: %s, new: %s)",
320                  fuzz, old_place.describe().c_str(), place.describe().c_str());
321         }
322     }
323
324     // On D:13 and deeper, and for those who tarry, something extreme:
325     if (env.turns_on_level > 1400 - place.absdepth() * 117
326         && x_chance_in_y(_scale_spawn_parameter(2, 10000, 10000, 3000, 9000),
327                          10000))
328     {
329         // this maxes depth most of the time
330         place.depth += random2avg(27, 2);
331         dprf("Super OOD roll: Old: %s, New: %s",
332              old_place.describe().c_str(), place.describe().c_str());
333     }
334 }
335
336 static int _vestibule_spawn_rate()
337 {
338     // Monster generation in the Vestibule drops off quickly.
339     const int taper_off_turn = 500;
340     int genodds = 240;
341     // genodds increases once you've spent more than 500 turns in Hell.
342     if (env.turns_on_level > taper_off_turn)
343     {
344         genodds += (env.turns_on_level - taper_off_turn);
345         genodds  = (genodds < 0 ? 20000 : min(genodds, 20000));
346     }
347
348     return genodds;
349 }
350
351 //#define DEBUG_MON_CREATION
352
353 // This function is now only called about once every 5 turns. (Used to be
354 // every turn independent of how much time an action took, which was not ideal.)
355 // To arrive at spawning rates close to how they used to be, replace the
356 // one_chance_in(value) checks with the new x_chance_in_y(5, value). (jpeg)
357 void spawn_random_monsters()
358 {
359     if (crawl_state.disables[DIS_SPAWNS])
360         return;
361
362     if (crawl_state.game_is_arena()
363         || (crawl_state.game_is_sprint()
364             && player_in_connected_branch()
365             && you.char_direction == GDT_DESCENDING))
366     {
367         return;
368     }
369
370 #ifdef DEBUG_MON_CREATION
371     mpr("in spawn_random_monsters()", MSGCH_DIAGNOSTICS);
372 #endif
373     int rate = env.spawn_random_rate;
374     if (!rate)
375     {
376 #ifdef DEBUG_MON_CREATION
377         mpr("random monster gen turned off", MSGCH_DIAGNOSTICS);
378 #endif
379         return;
380     }
381
382     if (player_in_branch(BRANCH_VESTIBULE_OF_HELL))
383         rate = _vestibule_spawn_rate();
384
385     rate = (you.char_direction == GDT_DESCENDING) ?
386             _scale_spawn_parameter(rate, 6 * rate, 0)
387             : (you_worship(GOD_CHEIBRIADOS)) ? 16 : 8;
388
389     if (rate == 0)
390     {
391         dprf("random monster gen scaled off, %d turns on level",
392              env.turns_on_level);
393         return;
394     }
395
396     if (player_in_branch(BRANCH_ABYSS))
397     {
398         if (you.char_direction != GDT_GAME_START)
399             rate = 5;
400         if (you_worship(GOD_CHEIBRIADOS))
401             rate *= 2;
402     }
403
404     if (!x_chance_in_y(5, rate))
405         return;
406
407     // Place normal dungeon monsters, but not in player LOS.
408     if (player_in_connected_branch())
409     {
410         dprf("Placing monster, rate: %d, turns here: %d",
411              rate, env.turns_on_level);
412         proximity_type prox = (one_chance_in(10) ? PROX_NEAR_STAIRS
413                                                  : PROX_AWAY_FROM_PLAYER);
414
415         // The rules change once the player has picked up the Orb...
416         if (you.char_direction == GDT_ASCENDING)
417             prox = (one_chance_in(3) ? PROX_CLOSE_TO_PLAYER : PROX_ANYWHERE);
418
419         mgen_data mg(WANDERING_MONSTER);
420         mg.proximity = prox;
421         mg.foe = (you.char_direction == GDT_ASCENDING) ? MHITYOU : MHITNOT;
422         mons_place(mg);
423         viewwindow();
424         return;
425     }
426
427     // Pandemonium doesn't yet use the standard way.
428     if (player_in_branch(BRANCH_PANDEMONIUM))
429     {
430         pandemonium_mons();
431         viewwindow();
432         return;
433     }
434
435     mgen_data mg(WANDERING_MONSTER);
436     if (player_in_branch(BRANCH_ABYSS) && one_chance_in(3))
437         mg.place = abyssal_state.level;
438
439     mons_place(mg);
440     viewwindow();
441 }
442
443 static bool _is_random_monster(monster_type mt)
444 {
445     return (mt == RANDOM_MONSTER || mt == RANDOM_MOBILE_MONSTER
446             || mt == RANDOM_COMPATIBLE_MONSTER
447             || mt == WANDERING_MONSTER);
448 }
449
450 static bool _is_not_zombifiable(monster_type mt)
451 {
452     return !mons_zombie_size(mt);
453 }
454
455 static bool _has_big_aura(monster_type mt)
456 {
457     return mt == MONS_MOTH_OF_SUPPRESSION || mt == MONS_SILENT_SPECTRE;
458 }
459
460 static bool _is_incompatible_monster(monster_type mt)
461 {
462     return mons_class_is_stationary(mt)
463         || player_will_anger_monster(mt);
464 }
465
466 // Caller must use !invalid_monster_type to check if the return value
467 // is a real monster.
468 monster_type pick_random_monster(level_id place,
469                                  monster_type kind,
470                                  level_id *final_place)
471 {
472     if (crawl_state.game_is_arena())
473     {
474         monster_type type = arena_pick_random_monster(place);
475         if (!_is_random_monster(type))
476             return type;
477     }
478
479     _apply_ood(place);
480
481     place.depth = min(place.depth, branch_ood_cap(place.branch));
482
483     if (final_place)
484         *final_place = place;
485
486     if (crawl_state.game_is_arena())
487         return pick_monster(place, arena_veto_random_monster);
488     else if (kind == RANDOM_MOBILE_MONSTER)
489         return pick_monster(place, mons_class_is_stationary);
490     else if (kind == RANDOM_COMPATIBLE_MONSTER)
491         return pick_monster(place, _is_incompatible_monster);
492     else if (mons_class_is_zombified(kind))
493         return pick_monster(place, _is_not_zombifiable);
494     else if (crawl_state.game_is_sprint())
495         return pick_monster(place, _has_big_aura);
496     else
497         return pick_monster(place);
498 }
499
500 bool can_place_on_trap(monster_type mon_type, trap_type trap)
501 {
502     if (mons_is_tentacle_segment(mon_type))
503         return true;
504
505     if (trap == TRAP_TELEPORT)
506         return false;
507
508     if (trap == TRAP_SHAFT)
509     {
510         if (_is_random_monster(mon_type))
511             return false;
512
513         return (mons_class_flies(mon_type)
514                 || get_monster_data(mon_type)->size == SIZE_TINY);
515     }
516
517     return true;
518 }
519
520 bool drac_colour_incompatible(int drac, int colour)
521 {
522     return (drac == MONS_DRACONIAN_SCORCHER && colour == MONS_WHITE_DRACONIAN);
523 }
524
525 // Finds a random square as close to a staircase as possible
526 static bool _find_mon_place_near_stairs(coord_def& pos,
527                                         dungeon_char_type *stair_type,
528                                         level_id &place)
529 {
530     pos = get_random_stair();
531     const dungeon_feature_type feat = grd(pos);
532     *stair_type = get_feature_dchar(feat);
533
534     // First, assume a regular stair.
535     switch (feat_stair_direction(feat))
536     {
537     case CMD_GO_UPSTAIRS:
538         if (place.depth > 1)
539             place.depth--;
540         break;
541     case CMD_GO_DOWNSTAIRS:
542         if (place.depth < brdepth[place.branch])
543             place.depth++;
544         break;
545     default: ;
546     }
547
548     // Is it a branch stair?
549     for (int i = 0; i < NUM_BRANCHES; ++i)
550     {
551         if (branches[i].entry_stairs == feat)
552         {
553             place = static_cast<branch_type>(i);
554             break;
555         }
556         else if (branches[i].exit_stairs == feat)
557         {
558             place = level_id(parent_branch((branch_type)i), startdepth[i]);
559             // This can happen in wizmode with random spawns on the
560             // first floor of a branch that didn't generate naturally
561             if (!place.is_valid())
562                 return false;
563             break;
564         }
565     }
566     const monster_type habitat_target = MONS_BAT;
567     int distance = 3;
568     if (crawl_state.game_is_zotdef())
569         distance = 9999;
570     pos = find_newmons_square_contiguous(habitat_target, pos, distance);
571     return in_bounds(pos);
572 }
573
574 static monster_type _resolve_monster_type(monster_type mon_type,
575                                           proximity_type proximity,
576                                           monster_type &base_type,
577                                           coord_def &pos,
578                                           unsigned mmask,
579                                           dungeon_char_type *stair_type,
580                                           level_id *place,
581                                           bool *want_band)
582 {
583     if (want_band)
584         *want_band = false;
585
586     if (mon_type == RANDOM_DRACONIAN)
587     {
588         // Pick any random drac, constrained by colour if requested.
589         do
590         {
591             mon_type =
592                 static_cast<monster_type>(
593                     random_range(MONS_BLACK_DRACONIAN,
594                                  MONS_DRACONIAN_SCORCHER));
595         }
596         while (base_type != MONS_PROGRAM_BUG
597                && mon_type != base_type
598                && (mons_species(mon_type) == mon_type
599                    || drac_colour_incompatible(mon_type, base_type)));
600     }
601     else if (mon_type == RANDOM_BASE_DRACONIAN)
602         mon_type = random_draconian_monster_species();
603     else if (mon_type == RANDOM_NONBASE_DRACONIAN)
604     {
605         mon_type =
606             static_cast<monster_type>(
607                 random_range(MONS_DRACONIAN_CALLER, MONS_DRACONIAN_SCORCHER));
608     }
609     else if (mon_type >= RANDOM_DEMON_LESSER && mon_type <= RANDOM_DEMON)
610         mon_type = summon_any_demon(mon_type);
611
612     // (2) Take care of non-draconian random monsters.
613     else if (_is_random_monster(mon_type))
614     {
615         // Respect destination level for staircases.
616         if (proximity == PROX_NEAR_STAIRS)
617         {
618             const level_id orig_place = *place;
619
620             if (_find_mon_place_near_stairs(pos, stair_type, *place))
621             {
622                 // No monsters spawned in the Temple.
623                 if (branches[place->branch].id == BRANCH_ECUMENICAL_TEMPLE)
624                     proximity = PROX_AWAY_FROM_PLAYER;
625             }
626             else
627                 proximity = PROX_AWAY_FROM_PLAYER;
628             if (proximity == PROX_NEAR_STAIRS)
629                 dprf("foreign monster from %s", place->describe().c_str());
630             else // we dunt cotton to no ferrniers in these here parts
631                 *place = orig_place;
632
633         } // end proximity check
634
635         if (!vault_mon_types.empty())
636         {
637             // XXX: not respecting RANDOM_MOBILE_MONSTER currently.
638             int i = choose_random_weighted(vault_mon_weights.begin(),
639                                            vault_mon_weights.end());
640             int type = vault_mon_types[i];
641             int base = vault_mon_bases[i];
642             bool banded = vault_mon_bands[i];
643
644             if (type == -1)
645                 *place = level_id::from_packed_place(base);
646             else
647             {
648                 base_type = (monster_type) base;
649                 mon_type  = (monster_type) type;
650                 if (want_band)
651                     *want_band = banded;
652                 if (mon_type == RANDOM_DRACONIAN
653                     || mon_type == RANDOM_BASE_DRACONIAN
654                     || mon_type == RANDOM_NONBASE_DRACONIAN)
655                 {
656                     mon_type =
657                         _resolve_monster_type(mon_type, proximity,
658                                               base_type, pos, mmask,
659                                               stair_type,
660                                               place,
661                                               want_band);
662                 }
663                 return mon_type;
664             }
665         }
666
667         int tries = 0;
668         while (tries++ < 300)
669         {
670             level_id orig_place = *place;
671
672             // Now pick a monster of the given branch and level.
673             mon_type = pick_random_monster(*place, mon_type, place);
674
675             // Don't allow monsters too stupid to use stairs (e.g.
676             // non-spectral zombified undead) to be placed near
677             // stairs.
678             if (proximity != PROX_NEAR_STAIRS
679                 || mons_class_can_use_stairs(mon_type))
680             {
681                 break;
682             }
683
684             *place = orig_place;
685         }
686
687         if (proximity == PROX_NEAR_STAIRS && tries >= 300)
688             mon_type = pick_random_monster(*place, mon_type, place);
689     }
690     return mon_type;
691 }
692
693 // A short function to check the results of near_stairs().
694 // Returns 0 if the point is not near stairs.
695 // Returns 1 if the point is near unoccupied stairs.
696 // Returns 2 if the point is near player-occupied stairs.
697 static int _is_near_stairs(coord_def &p)
698 {
699     int result = 0;
700
701     for (int i = -1; i <= 1; ++i)
702         for (int j = -1; j <= 1; ++j)
703         {
704             if (!in_bounds(p))
705                 continue;
706
707             const dungeon_feature_type feat = grd(p);
708             if (feat_is_stair(feat))
709             {
710                 // Shouldn't matter for escape hatches.
711                 if (feat_is_escape_hatch(feat))
712                     continue;
713
714                 // Should there be several stairs, don't overwrite the
715                 // player on stairs info.
716                 if (result < 2)
717                     result = (p == you.pos()) ? 2 : 1;
718             }
719         }
720
721     return result;
722 }
723
724 // Checks if the monster is ok to place at mg_pos. If force_location
725 // is true, then we'll be less rigorous in our checks, in particular
726 // allowing land monsters to be placed in shallow water and water
727 // creatures in fountains.
728 static bool _valid_monster_generation_location(const mgen_data &mg,
729                                                 const coord_def &mg_pos)
730 {
731     if (!in_bounds(mg_pos)
732         || monster_at(mg_pos)
733         || you.pos() == mg_pos && !fedhas_passthrough_class(mg.cls))
734     {
735         return false;
736     }
737
738     const monster_type montype = (mons_class_is_zombified(mg.cls) ? mg.base_type
739                                                                   : mg.cls);
740     if (!monster_habitable_grid(montype, grd(mg_pos), mg.preferred_grid_feature,
741                                 mons_class_flies(montype), false)
742         || (mg.behaviour != BEH_FRIENDLY && !mons_is_mimic(montype)
743             && is_sanctuary(mg_pos)
744             && !mons_is_tentacle_segment(montype)))
745     {
746         return false;
747     }
748
749     // Check player proximity to avoid band members being placed
750     // close to the player erroneously.
751     // XXX: This is a little redundant with proximity checks in
752     // place_monster.
753     if (mg.proximity == PROX_AWAY_FROM_PLAYER
754         && distance2(you.pos(), mg_pos) <= LOS_RADIUS_SQ)
755     {
756         return false;
757     }
758
759     // Don't generate monsters on top of teleport traps.
760     // (How did they get there?)
761     const trap_def* ptrap = find_trap(mg_pos);
762     if (ptrap && !can_place_on_trap(mg.cls, ptrap->type))
763         return false;
764
765     return true;
766 }
767
768 static bool _valid_monster_generation_location(mgen_data &mg)
769 {
770     return _valid_monster_generation_location(mg, mg.pos);
771 }
772
773 // Returns true if the player is on a level that should be sheltered from
774 // OOD packs, based on depth and time spent on-level.
775 static bool _in_ood_pack_protected_place()
776 {
777     return (env.turns_on_level < 1400 - env.absdepth0 * 117);
778 }
779
780 static void _abyss_monster_creation_message(const monster* mon)
781 {
782     if (mon->type == MONS_DEATH_COB)
783     {
784         mprf(coinflip() ? "%s appears in a burst of microwaves!"
785                         : "%s pops from nullspace!",
786              mon->name(DESC_A).c_str()); // always "a death cob"
787         return;
788     }
789
790     mprf(random_choose_weighted(
791          17, "%s appears in a shower of translocational energy.",
792          34, "%s appears in a shower of sparks.",
793          45, "%s materialises.",
794          13, "%s emerges from chaos.",
795          26, "%s emerges from the beyond.",
796          33, "%s assembles %s!",
797           9, "%s erupts from nowhere!",
798          18, "%s bursts from nowhere!",
799           7, "%s is cast out of space!",
800          14, "%s is cast out of reality!",
801           5, "%s coalesces out of pure chaos.",
802          10, "%s coalesces out of seething chaos.",
803           2, "%s punctures the fabric of time!",
804           7, "%s punctures the fabric of the universe.",
805           3, "%s manifests%3$s!",
806           0),
807          mon->name(DESC_A).c_str(), mon->pronoun(PRONOUN_REFLEXIVE).c_str(),
808          silenced(you.pos()) ? "" : " with a bang");
809 }
810
811 monster* place_monster(mgen_data mg, bool force_pos, bool dont_place)
812 {
813 #ifdef DEBUG_MON_CREATION
814     mpr("in place_monster()", MSGCH_DIAGNOSTICS);
815 #endif
816
817     int tries = 0;
818     dungeon_char_type stair_type = NUM_DCHAR_TYPES;
819
820     // (1) Early out (summoned to occupied grid).
821     if (mg.use_position() && monster_at(mg.pos))
822         return 0;
823
824     if (!mg.place.is_valid())
825         mg.place = level_id::current();
826
827     bool want_band = false;
828     level_id place = mg.place;
829     mg.cls = _resolve_monster_type(mg.cls, mg.proximity, mg.base_type,
830                                    mg.pos, mg.map_mask,
831                                    &stair_type,
832                                    &place,
833                                    &want_band);
834     bool chose_ood_monster = place.absdepth() > mg.place.absdepth() + 5;
835     if (want_band)
836         mg.flags |= MG_PERMIT_BANDS;
837
838     if (mg.cls == MONS_NO_MONSTER || mg.cls == MONS_PROGRAM_BUG)
839         return 0;
840
841     bool create_band = mg.permit_bands();
842     // If we drew an OOD monster and there hasn't been much time spent
843     // on level, disable band generation. This applies only to
844     // randomly picked monsters -- chose_ood_monster will never be set
845     // true for explicitly specified monsters in vaults and other
846     // places.
847     if (chose_ood_monster && _in_ood_pack_protected_place())
848     {
849         dprf("Chose monster with OOD roll: %s, disabling band generation",
850              get_monster_data(mg.cls)->name);
851         create_band = false;
852     }
853
854     // Re-check for PROX_NEAR_STAIRS here - if original monster
855     // type wasn't RANDOM_MONSTER then the position won't
856     // have been set.
857     if (mg.proximity == PROX_NEAR_STAIRS && mg.pos.origin())
858     {
859         level_id lev;
860         if (!_find_mon_place_near_stairs(mg.pos, &stair_type, lev))
861             mg.proximity = PROX_AWAY_FROM_PLAYER;
862     } // end proximity check
863
864     if (mg.cls == MONS_PROGRAM_BUG)
865         return 0;
866
867     // (3) Decide on banding (good lord!)
868     int band_size = 1;
869     bool leader = false;
870     monster_type band_monsters[BIG_BAND];        // band monster types
871     band_type band = BAND_NO_BAND;
872     band_monsters[0] = mg.cls;
873
874     // The (very) ugly thing band colour.
875     static colour_t ugly_colour = BLACK;
876
877     if (create_band)
878     {
879 #ifdef DEBUG_MON_CREATION
880         mpr("Choose band members...", MSGCH_DIAGNOSTICS);
881 #endif
882         band = _choose_band(mg.cls, band_size, leader);
883         band_size++;
884         for (int i = 1; i < band_size; ++i)
885         {
886             band_monsters[i] = _band_member(band, i);
887
888             // Get the (very) ugly thing band colour, so that all (very)
889             // ugly things in a band will start with it.
890             if ((band_monsters[i] == MONS_UGLY_THING
891                 || band_monsters[i] == MONS_VERY_UGLY_THING)
892                     && ugly_colour == BLACK)
893             {
894                 ugly_colour = ugly_thing_random_colour();
895             }
896         }
897     }
898
899     // Set the (very) ugly thing band colour.
900     if (ugly_colour != BLACK)
901         mg.colour = ugly_colour;
902
903     // Returns 2 if the monster is placed near player-occupied stairs.
904     int pval = _is_near_stairs(mg.pos);
905     if (mg.proximity == PROX_NEAR_STAIRS)
906     {
907         // For some cases disallow monsters on stairs.
908         if (mons_class_is_stationary(mg.cls)
909             || (pval == 2 // Stairs occupied by player.
910                 && (mons_class_base_speed(mg.cls) == 0
911                     || grd(mg.pos) == DNGN_LAVA
912                     || grd(mg.pos) == DNGN_DEEP_WATER)))
913         {
914             mg.proximity = PROX_AWAY_FROM_PLAYER;
915         }
916     }
917
918     // (4) For first monster, choose location.  This is pretty intensive.
919     bool proxOK;
920     bool close_to_player;
921
922     // Player shoved out of the way?
923     bool shoved = false;
924
925     if (!mg.use_position() && !force_pos)
926     {
927         tries = 0;
928
929         // Try to pick a position that is
930         // a) not occupied
931         // b) compatible
932         // c) in the 'correct' proximity to the player
933
934         while (true)
935         {
936             if (tries++ >= 45)
937                 return 0;
938
939             // Placement already decided for PROX_NEAR_STAIRS.
940             // Else choose a random point on the map.
941             if (mg.proximity != PROX_NEAR_STAIRS)
942                 mg.pos = random_in_bounds();
943
944             if (!_valid_monster_generation_location(mg))
945                 continue;
946
947             // Is the grid verboten?
948             if (map_masked(mg.pos, mg.map_mask))
949                 continue;
950
951             // Let's recheck these even for PROX_NEAR_STAIRS, just in case.
952             // Check proximity to player.
953             proxOK = true;
954
955             switch (mg.proximity)
956             {
957             case PROX_ANYWHERE:
958                 if (distance2(you.pos(), mg.pos) < dist_range(2 + random2(3)))
959                     proxOK = false;
960                 break;
961
962             case PROX_CLOSE_TO_PLAYER:
963             case PROX_AWAY_FROM_PLAYER:
964                 // If this is supposed to measure los vs not los,
965                 // then see_cell(mg.pos) should be used instead. (jpeg)
966                 close_to_player = (distance2(you.pos(), mg.pos) <=
967                                    LOS_RADIUS_SQ);
968
969                 if (mg.proximity == PROX_CLOSE_TO_PLAYER && !close_to_player
970                     || mg.proximity == PROX_AWAY_FROM_PLAYER && close_to_player)
971                 {
972                     proxOK = false;
973                 }
974                 break;
975
976             case PROX_NEAR_STAIRS:
977                 if (pval == 2) // player on stairs
978                 {
979                     if (mons_class_base_speed(mg.cls) == 0)
980                     {
981                         proxOK = false;
982                         break;
983                     }
984                     // Swap the monster and the player spots, unless the
985                     // monster was generated in lava or deep water.
986                     if (grd(mg.pos) == DNGN_LAVA
987                         || grd(mg.pos) == DNGN_DEEP_WATER)
988                     {
989                         proxOK = false;
990                         break;
991                     }
992
993                     // You can't be shoved if you're caught in a net.
994                     if (you.caught())
995                     {
996                         proxOK = false;
997                         break;
998                     }
999
1000                     shoved = true;
1001                     coord_def mpos = mg.pos;
1002                     mg.pos         = you.pos();
1003                     you.moveto(mpos);
1004                 }
1005                 proxOK = (pval > 0);
1006                 break;
1007             }
1008
1009             if (!proxOK)
1010                 continue;
1011
1012             // Cool.. passes all tests.
1013             break;
1014         } // end while... place first monster
1015     }
1016     else if (!_valid_monster_generation_location(mg) && !dont_place)
1017     {
1018         // Sanity check that the specified position is valid.
1019         return 0;
1020     }
1021
1022     // Reset the (very) ugly thing band colour.
1023     if (ugly_colour != BLACK)
1024         ugly_colour = BLACK;
1025
1026     monster* mon = _place_monster_aux(mg, 0, place, force_pos, dont_place);
1027
1028     // Bail out now if we failed.
1029     if (!mon)
1030         return 0;
1031
1032     if (mg.props.exists("map"))
1033         mon->set_originating_map(mg.props["map"].get_string());
1034
1035     if (mg.needs_patrol_point()
1036         || (mon->type == MONS_ALLIGATOR
1037             && !testbits(mon->flags, MF_BAND_MEMBER)))
1038     {
1039         mon->patrol_point = mon->pos();
1040 #ifdef DEBUG_PATHFIND
1041         mprf("Monster %s is patrolling around (%d, %d).",
1042              mon->name(DESC_PLAIN).c_str(), mon->pos().x, mon->pos().y);
1043 #endif
1044     }
1045
1046     if (player_in_branch(BRANCH_ABYSS) && !mg.summoner
1047         && in_bounds(mon->pos())
1048         && !(mg.extra_flags & MF_WAS_IN_VIEW)
1049         && !cell_is_solid(mon->pos()))
1050     {
1051         big_cloud(CLOUD_TLOC_ENERGY, mon, mon->pos(), 3 + random2(3), 3, 3);
1052     }
1053
1054     // Message to player from stairwell/gate/abyss appearance.
1055     if (shoved)
1056     {
1057         mprf("%s shoves you out of the %s!",
1058              mon->visible_to(&you) ? mon->name(DESC_A).c_str() : "Something",
1059              stair_type == DCHAR_ARCH ? "gateway" : "stairwell");
1060     }
1061     else if (mg.proximity == PROX_NEAR_STAIRS && you.can_see(mon))
1062     {
1063         const char *msg = nullptr;
1064         switch (stair_type)
1065         {
1066         case DCHAR_STAIRS_DOWN: msg = "up the stairs."; break;
1067         case DCHAR_STAIRS_UP:   msg = "down the stairs."; break;
1068         case DCHAR_ARCH:        msg = "through the gate."; break;
1069         default: ;
1070         }
1071         if (msg)
1072             mprf("%s comes %s", mon->name(DESC_A).c_str(), msg);
1073     }
1074     else if (player_in_branch(BRANCH_ABYSS) && you.can_see(mon)
1075              && !crawl_state.generating_level
1076              && !mg.summoner && !mons_is_mimic(mon->type)
1077              && !crawl_state.is_god_acting()
1078              && !(mon->flags & MF_WAS_IN_VIEW)) // is this possible?
1079     {
1080         _abyss_monster_creation_message(mon);
1081     }
1082
1083     // Now, forget about banding if the first placement failed, or there are
1084     // too many monsters already, or we successfully placed by stairs.
1085     // Zotdef change - banding allowed on stairs for extra challenge!
1086     // Frequency reduced, though, and only after 2K turns.
1087     if (mon->mindex() >= MAX_MONSTERS - 30
1088         || (mg.proximity == PROX_NEAR_STAIRS && !crawl_state.game_is_zotdef())
1089         || (crawl_state.game_is_zotdef() && you.num_turns < 2000))
1090         return mon;
1091
1092     // Not PROX_NEAR_STAIRS, so it will be part of a band, if there is any.
1093     if (band_size > 1)
1094         mon->flags |= MF_BAND_MEMBER;
1095
1096     const bool priest = mon->is_priest();
1097
1098     mgen_data band_template = mg;
1099
1100     if (leader && !mg.summoner)
1101     {
1102         band_template.summoner = mon;
1103         band_template.flags |= MG_BAND_MINION;
1104     }
1105
1106     unwind_var<band_type> current_band(active_monster_band, band);
1107     // (5) For each band monster, loop call to place_monster_aux().
1108     for (int i = 1; i < band_size; i++)
1109     {
1110         if (band_monsters[i] == MONS_NO_MONSTER)
1111             break;
1112
1113         band_template.cls = band_monsters[i];
1114
1115         // We don't want to place a unique that has already been
1116         // generated.
1117         if (mons_is_unique(band_template.cls)
1118             && you.unique_creatures[band_template.cls])
1119         {
1120             continue;
1121         }
1122
1123         if (monster *member = _place_monster_aux(band_template, mon, place))
1124         {
1125             member->flags |= MF_BAND_MEMBER;
1126             member->props["band_leader"].get_int() = mon->mid;
1127             member->set_originating_map(mon->originating_map());
1128
1129             // Priestly band leaders should have an entourage of the
1130             // same religion, unless members of that entourage already
1131             // have a different one.
1132             if (priest && member->god == GOD_NO_GOD)
1133                 member->god = mon->god;
1134
1135             if (mon->type == MONS_PIKEL)
1136             {
1137                 // Don't give XP for the slaves to discourage hunting.  Pikel
1138                 // has an artificially large XP modifier to compensate for
1139                 // this.
1140                 member->flags |= MF_NO_REWARD;
1141                 member->props["pikel_band"] = true;
1142             }
1143             else if (mon->type == MONS_KIRKE)
1144                 member->props["kirke_band"] = true;
1145             else if (mon->type == MONS_SHEDU)
1146             {
1147                 // We store these here for later resurrection, etc.
1148                 member->number = mon->mid;
1149                 mon->number = member->mid;
1150             }
1151         }
1152     }
1153
1154     // Placement of first monster, at least, was a success.
1155     return mon;
1156 }
1157
1158 monster* get_free_monster()
1159 {
1160     for (int i = 0; i < MAX_MONSTERS; ++i)
1161         if (env.mons[i].type == MONS_NO_MONSTER)
1162         {
1163             env.mons[i].reset();
1164             return (&env.mons[i]);
1165         }
1166
1167     return NULL;
1168 }
1169
1170 void mons_add_blame(monster* mon, const string &blame_string)
1171 {
1172     const bool exists = mon->props.exists("blame");
1173     CrawlStoreValue& blame = mon->props["blame"];
1174     if (!exists)
1175         blame.new_vector(SV_STR, SFLAG_CONST_TYPE);
1176     blame.get_vector().push_back(blame_string);
1177 }
1178
1179 static void _place_twister_clouds(monster *mon)
1180 {
1181     // Yay for the abj_degree having a huge granularity.
1182     if (mon->has_ench(ENCH_ABJ))
1183     {
1184         mon_enchant abj = mon->get_ench(ENCH_ABJ);
1185         mon->lose_ench_duration(abj, abj.duration / 2);
1186     }
1187
1188     tornado_damage(mon, -10);
1189 }
1190
1191 static monster* _place_monster_aux(const mgen_data &mg, const monster *leader,
1192                                    level_id place,
1193                                    bool force_pos, bool dont_place)
1194 {
1195     coord_def fpos;
1196
1197     // Some sanity checks.
1198     if (mons_is_unique(mg.cls) && you.unique_creatures[mg.cls]
1199             && !crawl_state.game_is_arena()
1200         || mons_class_flag(mg.cls, M_CANT_SPAWN))
1201     {
1202         die("invalid monster to place: %s (%d)", mons_class_name(mg.cls), mg.cls);
1203     }
1204
1205     const monsterentry *m_ent = get_monster_data(mg.cls);
1206
1207     monster* mon = get_free_monster();
1208     if (!mon)
1209         return 0;
1210
1211     const monster_type montype = (mons_class_is_zombified(mg.cls) ? mg.base_type
1212                                                                   : mg.cls);
1213
1214     // Setup habitat and placement.
1215     // If the space is occupied, try some neighbouring square instead.
1216     if (dont_place)
1217         fpos.reset();
1218     else if (leader == 0 && in_bounds(mg.pos)
1219         && (mg.behaviour == BEH_FRIENDLY ||
1220             (!is_sanctuary(mg.pos) || mons_is_tentacle_segment(montype))
1221             || mons_is_mimic(montype))
1222         && !monster_at(mg.pos)
1223         && (you.pos() != mg.pos || fedhas_passthrough_class(mg.cls))
1224         && (force_pos || monster_habitable_grid(montype, grd(mg.pos))))
1225     {
1226         fpos = mg.pos;
1227     }
1228     else
1229     {
1230         int i;
1231         // We'll try 1000 times for a good spot.
1232         for (i = 0; i < 1000; ++i)
1233         {
1234             fpos = mg.pos + coord_def(random_range(-3, 3),
1235                                       random_range(-3, 3));
1236
1237             // Place members within LOS_SOLID of their leader.
1238             // TODO nfm - allow placing around corners but not across walls.
1239             if ((leader == 0 || cell_see_cell(fpos, leader->pos(), LOS_SOLID))
1240                 && _valid_monster_generation_location(mg, fpos))
1241             {
1242                 break;
1243             }
1244         }
1245
1246         // Did we really try 1000 times?
1247         if (i == 1000)
1248             return 0;
1249     }
1250
1251     ASSERT(!monster_at(fpos));
1252
1253     if (crawl_state.game_is_arena()
1254         && arena_veto_place_monster(mg, leader == 0, fpos))
1255     {
1256         return 0;
1257     }
1258
1259     // Now, actually create the monster. (Wheeee!)
1260     mon->set_new_monster_id();
1261     mon->type         = mg.cls;
1262     mon->base_monster = mg.base_type;
1263     mon->number       = mg.number;
1264
1265     // Set pos and link monster into monster grid.
1266     if (!dont_place && !mon->move_to_pos(fpos))
1267     {
1268         mon->reset();
1269         return 0;
1270     }
1271
1272     // Pick the correct Serpent of Hell.
1273     if (mon->type == MONS_SERPENT_OF_HELL)
1274         switch (place.branch)
1275         {
1276         case BRANCH_COCYTUS:
1277             mon->type = MONS_SERPENT_OF_HELL_COCYTUS;
1278             break;
1279         case BRANCH_DIS:
1280             mon->type = MONS_SERPENT_OF_HELL_DIS;
1281             break;
1282         case BRANCH_TARTARUS:
1283             mon->type = MONS_SERPENT_OF_HELL_TARTARUS;
1284             break;
1285         default: ; // if it spawns out of Hell (sprint, wizmode), use Gehenna
1286         }
1287
1288     // Generate a brand shiny new monster, or zombie.
1289     if (mons_class_is_zombified(mg.cls))
1290     {
1291         monster_type ztype = mg.base_type;
1292
1293         if (ztype == MONS_NO_MONSTER || ztype == RANDOM_MONSTER)
1294             ztype = pick_local_zombifiable_monster(place, mg.cls, fpos);
1295
1296         define_zombie(mon, ztype, mg.cls);
1297     }
1298     else
1299         define_monster(mon);
1300
1301     // Is it a god gift?
1302     if (mg.god != GOD_NO_GOD)
1303     {
1304         mon->god    = mg.god;
1305         mon->flags |= MF_GOD_GIFT;
1306     }
1307     // Not a god gift, give priestly monsters a god.
1308     else if (mons_class_flag(mg.cls, M_PRIEST))
1309     {
1310         // Berserkers belong to Trog.
1311         if (mg.cls == MONS_DEEP_DWARF_BERSERKER
1312             || mg.cls == MONS_SPRIGGAN_BERSERKER)
1313         {
1314             mon->god = GOD_TROG;
1315         }
1316         // Profane servitors and deep dwarf death knights belong to Yredelemnul.
1317         else if (mg.cls == MONS_PROFANE_SERVITOR
1318                  || mg.cls == MONS_DEEP_DWARF_DEATH_KNIGHT)
1319         {
1320             mon->god = GOD_YREDELEMNUL;
1321         }
1322         // Wiglaf belongs to Okawaru.
1323         else if (mg.cls == MONS_WIGLAF)
1324             mon->god = GOD_OKAWARU;
1325         else
1326         {
1327             switch (mons_genus(mg.cls))
1328             {
1329             case MONS_ORC:
1330                 mon->god = GOD_BEOGH;
1331                 break;
1332             case MONS_JELLY:
1333                 mon->god = GOD_JIYVA;
1334                 break;
1335             case MONS_MUMMY:
1336             case MONS_DRACONIAN:
1337             case MONS_ELF:
1338                 // [ds] Vault defs can request priest monsters of unusual types.
1339             default:
1340                 mon->god = GOD_NAMELESS;
1341                 break;
1342             }
1343         }
1344     }
1345     // XXX: Unborn belong to Yredelemnul, but only so they'll get the right
1346     // message when casting Injury Mirror.
1347     else if (mg.cls == MONS_UNBORN)
1348         mon->god = GOD_YREDELEMNUL;
1349     // The royal jelly belongs to Jiyva.
1350     else if (mg.cls == MONS_ROYAL_JELLY)
1351         mon->god = GOD_JIYVA;
1352     // Mennas belongs to Zin.
1353     else if (mg.cls == MONS_MENNAS)
1354         mon->god = GOD_ZIN;
1355     // Yiuf is a faithful Xommite.
1356     else if (mg.cls == MONS_CRAZY_YIUF)
1357         mon->god = GOD_XOM;
1358     // The hell lords, Grinder and Ignacio belong to Makhleb.
1359     else if (mons_species(mg.cls) == MONS_HELL_LORD
1360              || mg.cls == MONS_ANTAEUS
1361              || mg.cls == MONS_GRINDER
1362              || mg.cls == MONS_IGNACIO)
1363     {
1364         mon->god = GOD_MAKHLEB;
1365     }
1366     // 1 out of 7 non-priestly orcs are unbelievers.
1367     else if (mons_genus(mg.cls) == MONS_ORC)
1368     {
1369         if (!one_chance_in(7))
1370             mon->god = GOD_BEOGH;
1371     }
1372     else if (mg.cls == MONS_APIS)
1373         mon->god = GOD_ELYVILON;
1374     // Angels (other than Mennas) and daevas belong to TSO, but 1 out of
1375     // 7 in the Abyss are adopted by Xom.
1376     else if (mons_class_holiness(mg.cls) == MH_HOLY)
1377     {
1378         if (mg.place != BRANCH_ABYSS || !one_chance_in(7))
1379             mon->god = GOD_SHINING_ONE;
1380         else
1381             mon->god = GOD_XOM;
1382     }
1383     // 6 out of 7 demons in the Abyss belong to Lugonu, and 6 out of 7
1384     // demons in hell belong to Makhleb.
1385     else if (mons_class_holiness(mg.cls) == MH_DEMONIC)
1386     {
1387         if (mg.place == BRANCH_ABYSS && !one_chance_in(7))
1388             mon->god = GOD_LUGONU;
1389         else if ((mg.place == BRANCH_VESTIBULE_OF_HELL || player_in_hell())
1390                  && !one_chance_in(7))
1391         {
1392             mon->god = GOD_MAKHLEB;
1393         }
1394     }
1395
1396     // Holy monsters need their halo!
1397     if (mon->holiness() == MH_HOLY)
1398         invalidate_agrid(true);
1399     if (mg.cls == MONS_SILENT_SPECTRE || mg.cls == MONS_PROFANE_SERVITOR
1400         || mg.cls == MONS_MOTH_OF_SUPPRESSION)
1401     {
1402         invalidate_agrid(true);
1403     }
1404
1405     // If the caller requested a specific colour for this monster, apply
1406     // it now.
1407     if (mg.colour != BLACK)
1408         mon->colour = mg.colour;
1409
1410     if (mg.mname != "")
1411         mon->mname = mg.mname;
1412
1413     if (mg.hd != 0)
1414     {
1415         mon->hit_dice = mg.hd;
1416         // Re-roll HP.
1417         int hp = hit_points(mg.hd, m_ent->hpdice[1], m_ent->hpdice[2]);
1418         // But only for monsters with random HP.
1419         if (hp > 0)
1420         {
1421             mon->max_hit_points = hp;
1422             mon->hit_points = hp;
1423         }
1424     }
1425
1426     if (mg.hp != 0)
1427     {
1428         mon->max_hit_points = mg.hp;
1429         mon->hit_points = mg.hp;
1430     }
1431
1432     if (!crawl_state.game_is_arena())
1433     {
1434         mon->max_hit_points = min(mon->max_hit_points, MAX_MONSTER_HP);
1435         mon->hit_points = min(mon->hit_points, MAX_MONSTER_HP);
1436     }
1437
1438     // Store the extra flags here.
1439     mon->flags       |= mg.extra_flags;
1440
1441     // The return of Boris is now handled in monster_die().  Not setting
1442     // this for Boris here allows for multiple Borises in the dungeon at
1443     // the same time. - bwr
1444     if (mons_is_unique(mg.cls))
1445         you.unique_creatures.set(mg.cls);
1446
1447     if (mons_class_flag(mg.cls, M_INVIS))
1448         mon->add_ench(ENCH_INVIS);
1449
1450     if (mons_class_flag(mg.cls, M_CONFUSED))
1451         mon->add_ench(ENCH_CONFUSION);
1452
1453     if (montype == MONS_SHAPESHIFTER)
1454         mon->add_ench(ENCH_SHAPESHIFTER);
1455
1456     if (montype == MONS_GLOWING_SHAPESHIFTER)
1457         mon->add_ench(ENCH_GLOWING_SHAPESHIFTER);
1458
1459     if (mg.cls == MONS_TOADSTOOL || mg.cls == MONS_PILLAR_OF_SALT)
1460     {
1461         // This enchantment is a timer that counts down until death.
1462         // It should last longer than the lifespan of a corpse, to avoid
1463         // spawning mushrooms in the same place over and over.  Aside
1464         // from that, the value is slightly randomised to avoid
1465         // simultaneous die-offs of mushroom rings.
1466         mon->add_ench(ENCH_SLOWLY_DYING);
1467     }
1468     else if (mg.cls == MONS_HYPERACTIVE_BALLISTOMYCETE)
1469         mon->add_ench(ENCH_EXPLODING);
1470
1471     if (mg.cls == MONS_TWISTER || mg.cls == MONS_DIAMOND_OBELISK)
1472     {
1473         mon->props["tornado_since"].get_int() = you.elapsed_time;
1474         mon->add_ench(mon_enchant(ENCH_TORNADO, 0, 0, INFINITE_DURATION));
1475     }
1476
1477     if (!crawl_state.game_is_arena() && you.misled())
1478         update_mislead_monster(mon);
1479
1480     mon->flags |= MF_JUST_SUMMONED;
1481
1482     // Don't leave shifters in their starting shape.
1483     if (mg.cls == MONS_SHAPESHIFTER || mg.cls == MONS_GLOWING_SHAPESHIFTER)
1484     {
1485         no_messages nm;
1486         monster_polymorph(mon, mg.initial_shifter);
1487
1488         // It's not actually a known shapeshifter if it happened to be
1489         // placed in LOS of the player.
1490         mon->flags &= ~MF_KNOWN_SHIFTER;
1491     }
1492
1493     // dur should always be 1-6 for monsters that can be abjured.
1494     const bool summoned = mg.abjuration_duration >= 1
1495                        && mg.abjuration_duration <= 6;
1496
1497     if (mons_class_is_animated_weapon(mg.cls))
1498     {
1499         if (mg.props.exists(TUKIMA_WEAPON))
1500             give_specific_item(mon, mg.props[TUKIMA_WEAPON].get_item());
1501         else
1502             give_item(mon, place.absdepth(), summoned);
1503
1504         // Dancing weapons *always* have a weapon. Fail to create them
1505         // otherwise.
1506         const item_def* wpn = mon->mslot_item(MSLOT_WEAPON);
1507         if (!wpn)
1508         {
1509             mon->destroy_inventory();
1510             mon->reset();
1511             mgrd(fpos) = NON_MONSTER;
1512             return 0;
1513         }
1514         else
1515             mon->colour = wpn->colour;
1516     }
1517     else if (mons_class_itemuse(mg.cls) >= MONUSE_STARTING_EQUIPMENT)
1518     {
1519         give_item(mon, place.absdepth(), summoned);
1520         // Give these monsters a second weapon. - bwr
1521         if (mons_class_wields_two_weapons(mg.cls))
1522             give_weapon(mon, place.absdepth(), summoned);
1523
1524         unwind_var<int> save_speedinc(mon->speed_increment);
1525         mon->wield_melee_weapon(false);
1526     }
1527
1528     if (mg.cls == MONS_SLIME_CREATURE)
1529     {
1530         if (mg.number > 1)
1531         {
1532             // Boost HP to what it would have been if it had grown this
1533             // big by merging.
1534             mon->hit_points     *= mg.number;
1535             mon->max_hit_points *= mg.number;
1536         }
1537     }
1538
1539     if (monster_can_submerge(mon, grd(fpos)) && !one_chance_in(5) && !summoned)
1540         mon->add_ench(ENCH_SUBMERGED);
1541
1542     if (mons_is_mimic(mg.cls))
1543         mon->props = mg.props;
1544
1545     // Set attitude, behaviour and target.
1546     mon->attitude  = ATT_HOSTILE;
1547     mon->behaviour = mg.behaviour;
1548
1549     // Statues cannot sleep (nor wander but it means they are a bit
1550     // more aware of the player than they'd be otherwise).
1551     if (mons_is_statue(mg.cls))
1552         mon->behaviour = BEH_WANDER;
1553     // Trapdoor spiders lurk, they don't sleep
1554     if (mg.cls == MONS_TRAPDOOR_SPIDER)
1555         mon->behaviour = BEH_LURK;
1556
1557     mon->foe_memory = 0;
1558
1559     // Setting attitude will always make the monster wander...
1560     // If you want sleeping hostiles, use BEH_SLEEP since the default
1561     // attitude is hostile.
1562     if (mg.behaviour > NUM_BEHAVIOURS)
1563     {
1564         if (mg.behaviour == BEH_FRIENDLY)
1565             mon->attitude = ATT_FRIENDLY;
1566
1567         if (mg.behaviour == BEH_GOOD_NEUTRAL)
1568             mon->attitude = ATT_GOOD_NEUTRAL;
1569
1570         if (mg.behaviour == BEH_NEUTRAL)
1571             mon->attitude = ATT_NEUTRAL;
1572
1573         if (mg.behaviour == BEH_STRICT_NEUTRAL)
1574             mon->attitude = ATT_STRICT_NEUTRAL;
1575
1576         mon->behaviour = BEH_WANDER;
1577     }
1578
1579     if (summoned)
1580     {
1581         // Instead of looking for dancing weapons, look for Tukima's dance.
1582         // Dancing weapons can be created with shadow creatures. {due}
1583         bool mark_items = mg.summon_type != SPELL_TUKIMAS_DANCE;
1584
1585         mon->mark_summoned(mg.abjuration_duration,
1586                            mark_items,
1587                            mg.summon_type);
1588     }
1589
1590     // Perm summons shouldn't leave gear either.
1591     if (mg.extra_flags & MF_HARD_RESET && mg.extra_flags & MF_NO_REWARD)
1592         mon->mark_summoned(0, true, 0, false);
1593
1594     ASSERT(!invalid_monster_index(mg.foe)
1595            || mg.foe == MHITYOU || mg.foe == MHITNOT);
1596     mon->foe = mg.foe;
1597
1598     string blame_prefix;
1599
1600     if (mg.flags & MG_BAND_MINION)
1601         blame_prefix = "led by ";
1602     else if (mg.abjuration_duration > 0)
1603     {
1604         blame_prefix = "summoned by ";
1605
1606         if (mg.summoner != NULL && mg.summoner->alive()
1607             && mg.summoner->type == MONS_MARA)
1608         {
1609             blame_prefix = "woven by ";
1610         }
1611
1612         if (mg.cls == MONS_DANCING_WEAPON)
1613             blame_prefix = "animated by ";
1614     }
1615     else if (mons_class_is_zombified(mg.cls))
1616         blame_prefix = "animated by ";
1617     else if (mg.summon_type == SPELL_STICKS_TO_SNAKES)
1618         blame_prefix = "transmuted by ";
1619     else if (mg.cls == MONS_ELDRITCH_TENTACLE
1620              || mg.cls == MONS_ELDRITCH_TENTACLE_SEGMENT)
1621     {
1622         blame_prefix = "called by ";
1623     }
1624     else if (mons_is_child_tentacle(mg.cls))
1625         blame_prefix = "attached to ";
1626     else
1627         blame_prefix = "created by ";
1628
1629     if (!mg.non_actor_summoner.empty())
1630         mons_add_blame(mon, blame_prefix + mg.non_actor_summoner);
1631     // NOTE: The summoner might be dead if the summoned is placed by a
1632     // beam which killed the summoner first (like fire vortexes placed
1633     // by the Fire Storm spell); a deceased summoner's mindex might also
1634     // be reused to create its summon, so make sure the summon doesn't
1635     // think it has summoned itself.
1636     else if (mg.summoner != NULL && mg.summoner->alive()
1637              && mg.summoner != mon)
1638     {
1639         ASSERT(mg.summoner->alive());
1640         mon->summoner = mg.summoner->mid;
1641         if (mg.summoner->is_player())
1642             mons_add_blame(mon, blame_prefix + "the player character");
1643         else
1644         {
1645             const monster* sum = mg.summoner->as_monster();
1646             mons_add_blame(mon, (blame_prefix
1647                                  + sum->full_name(DESC_A, true)));
1648             if (sum->props.exists("blame"))
1649             {
1650                 const CrawlVector& oldblame = sum->props["blame"].get_vector();
1651                 for (CrawlVector::const_iterator i = oldblame.begin();
1652                      i != oldblame.end(); ++i)
1653                 {
1654                     mons_add_blame(mon, i->get_string());
1655                 }
1656             }
1657         }
1658     }
1659
1660     // Initialise (very) ugly things and pandemonium demons.
1661     if (mon->type == MONS_UGLY_THING
1662         || mon->type == MONS_VERY_UGLY_THING)
1663     {
1664         ghost_demon ghost;
1665         ghost.init_ugly_thing(mon->type == MONS_VERY_UGLY_THING, false,
1666                               mg.colour);
1667         mon->set_ghost(ghost);
1668         mon->uglything_init();
1669     }
1670 #if TAG_MAJOR_VERSION == 34
1671     else if (mon->type == MONS_LABORATORY_RAT)
1672         mon->type = MONS_RAT;
1673 #endif
1674     else if (mons_class_is_animated_weapon(mon->type))
1675     {
1676         ghost_demon ghost;
1677         // We can't use monster::weapon here because it wants to look
1678         // at attack types, which are in the ghost structure we're
1679         // building.
1680         ASSERT(mon->mslot_item(MSLOT_WEAPON));
1681         if (mon->type == MONS_DANCING_WEAPON)
1682         {
1683             // Dancing weapons are placed at pretty high power.  Remember, the
1684             // player is fighting them one-on-one, while he will often summon
1685             // several.
1686             ghost.init_dancing_weapon(*(mon->mslot_item(MSLOT_WEAPON)),
1687                                       mg.props.exists(TUKIMA_POWER) ?
1688                                           mg.props[TUKIMA_POWER].get_int() : 100);
1689         }
1690         else
1691         {
1692             // Spectral weapons are placed at pretty high power.
1693             // They shouldn't ever be placed in a normal game.
1694             ghost.init_spectral_weapon(*(mon->mslot_item(MSLOT_WEAPON)),
1695                                        mg.props.exists(TUKIMA_POWER) ?
1696                                            mg.props[TUKIMA_POWER].get_int() : 100,
1697                                        mg.props.exists(TUKIMA_SKILL) ?
1698                                            mg.props[TUKIMA_SKILL].get_int() : 270);
1699         }
1700         mon->set_ghost(ghost);
1701         mon->ghost_demon_init();
1702     }
1703     else if (mons_class_is_chimeric(mon->type))
1704     {
1705         ghost_demon ghost;
1706
1707         // Requires 3 parts
1708         if (mg.chimera_mons.size() != 3)
1709         {
1710             if (!ghost.init_chimera_for_place(mon, place, mg.cls, fpos))
1711             {
1712                 mon->reset();
1713                 return 0;
1714             }
1715         }
1716         else
1717         {
1718             monster_type parts[] =
1719             {
1720                 mg.chimera_mons[0],
1721                 mg.chimera_mons[1],
1722                 mg.chimera_mons[2],
1723             };
1724             ghost.init_chimera(mon, parts);
1725         }
1726         mon->set_ghost(ghost);
1727         mon->ghost_demon_init();
1728     }
1729
1730     tile_init_props(mon);
1731
1732 #ifndef DEBUG_DIAGNOSTICS
1733     // A rare case of a debug message NOT showing in the debug mode.
1734     if (mons_class_flag(mon->type, M_UNFINISHED))
1735     {
1736         mprf(MSGCH_WARN, "Warning: monster '%s' is not yet fully coded.",
1737              mon->name(DESC_PLAIN, true).c_str());
1738     }
1739 #endif
1740
1741     mark_interesting_monst(mon, mg.behaviour);
1742
1743     if (crawl_state.game_is_arena())
1744         arena_placed_monster(mon);
1745     else if (!crawl_state.generating_level && !dont_place && you.can_see(mon))
1746     {
1747         if (mg.flags & MG_DONT_COME)
1748             mon->seen_context = SC_JUST_SEEN;
1749         // FIXME: This causes "comes into view" messages at the
1750         //        wrong time, since code checks for placement
1751         //        success before printing messages.
1752         handle_seen_interrupt(mon);
1753     }
1754
1755     // Area effects can produce additional messages, and thus need to be
1756     // done after come in view ones.
1757     if (mon->type == MONS_TWISTER && !dont_place)
1758         _place_twister_clouds(mon);
1759
1760     return mon;
1761 }
1762
1763 monster_type pick_random_zombie()
1764 {
1765     static vector<monster_type> zombifiable;
1766
1767     if (zombifiable.empty())
1768     {
1769         for (monster_type mcls = MONS_0; mcls < NUM_MONSTERS; ++mcls)
1770         {
1771             if (mons_species(mcls) != mcls || mcls == MONS_PROGRAM_BUG)
1772                 continue;
1773
1774             if (!mons_zombie_size(mcls) || mons_is_unique(mcls))
1775                 continue;
1776             if (mons_class_holiness(mcls) != MH_NATURAL)
1777                 continue;
1778
1779             zombifiable.push_back(mcls);
1780         }
1781
1782         ASSERT(!zombifiable.empty());
1783     }
1784
1785     return (zombifiable[random2(zombifiable.size())]);
1786 }
1787
1788 // Check base monster class against zombie type and position if set.
1789 static bool _good_zombie(monster_type base, monster_type cs,
1790                          const coord_def& pos)
1791 {
1792     // Actually pick a monster that is happy where we want to put it.
1793     // Fish zombies on land are helpless and uncool.
1794     if (in_bounds(pos) && !monster_habitable_grid(base, grd(pos)))
1795         return false;
1796
1797     if (cs == MONS_NO_MONSTER)
1798         return true;
1799
1800     // If skeleton, monster must have a skeleton.
1801     if (cs == MONS_SKELETON && !mons_skeleton(base))
1802         return false;
1803
1804     // If zombie, monster must have unrotted meat.
1805     if (cs == MONS_ZOMBIE && !mons_zombifiable(base))
1806         return false;
1807
1808     return true;
1809 }
1810
1811 // Veto for the zombie picker class
1812 bool zombie_picker::veto(monster_type mt)
1813 {
1814     // Zombifiability in general.
1815     if (mons_species(mt) != mt)
1816         return true;
1817     // Monsters that don't really exist
1818     if (mons_class_flag(mt, M_UNFINISHED))
1819         return true;
1820     // Monsters that can have derived undead, but never randomly generated.
1821     if (mons_class_flag(mt, M_NO_GEN_DERIVED))
1822         return true;
1823     if (!mons_zombie_size(mt) || mons_is_unique(mt))
1824         return true;
1825     if (mons_class_holiness(mt) != MH_NATURAL)
1826         return true;
1827
1828     return !_good_zombie(mt, zombie_kind, pos);
1829 }
1830
1831 monster_type pick_local_zombifiable_monster(level_id place,
1832                                             monster_type cs,
1833                                             const coord_def& pos)
1834 {
1835     if (crawl_state.game_is_zotdef())
1836     {
1837         place = level_id(BRANCH_MAIN_DUNGEON,
1838                          you.num_turns / (2 * ZOTDEF_CYCLE_LENGTH) + 6);
1839     }
1840     else if (place.branch == BRANCH_ZIGGURAT)
1841     {
1842         // Get Zigs something reasonable to work with, if there's no place
1843         // explicitly defined.
1844         place = level_id(BRANCH_MAIN_DUNGEON, 31 - (27 - place.depth) / 3);
1845     }
1846     else
1847     {
1848         // Zombies tend to be weaker than their normal counterparts;
1849         // thus, make them OOD proportional to the current dungeon depth.
1850         place.depth += 1 + div_rand_round(place.absdepth(), 5);
1851     }
1852
1853     zombie_picker picker = zombie_picker(pos, cs);
1854
1855     place.depth = max(1, min(place.depth, branch_ood_cap(place.branch)));
1856
1857     if (monster_type mt = pick_monster(place, picker))
1858         return mt;
1859
1860     return pick_monster_all_branches(place.absdepth(), picker);
1861 }
1862
1863 void roll_zombie_hp(monster* mon)
1864 {
1865     ASSERT(mons_class_is_zombified(mon->type));
1866
1867     int hp = 0;
1868
1869     switch (mon->type)
1870     {
1871     case MONS_ZOMBIE:
1872         hp = hit_points(mon->hit_dice, 6, 5);
1873         break;
1874
1875     case MONS_SKELETON:
1876         hp = hit_points(mon->hit_dice, 5, 4);
1877         break;
1878
1879     case MONS_SIMULACRUM:
1880         // Simulacra aren't tough, but you can create piles of them. - bwr
1881         hp = hit_points(mon->hit_dice, 1, 4);
1882         break;
1883
1884     case MONS_SPECTRAL_THING:
1885         hp = hit_points(mon->hit_dice, 4, 4);
1886         break;
1887
1888     default:
1889         die("invalid zombie type %d (%s)", mon->type,
1890             mons_class_name(mon->type));
1891     }
1892
1893     mon->max_hit_points = max(hp, 1);
1894     mon->hit_points     = mon->max_hit_points;
1895 }
1896
1897 static void _roll_zombie_ac_ev_mods(monster* mon, int& acmod, int& evmod)
1898 {
1899     ASSERT(mons_class_is_zombified(mon->type));
1900
1901     switch (mon->type)
1902     {
1903     case MONS_ZOMBIE:
1904         acmod = -2;
1905         evmod = -5;
1906         break;
1907
1908     case MONS_SKELETON:
1909         acmod = -6;
1910         evmod = -7;
1911         break;
1912
1913     case MONS_SIMULACRUM:
1914         // Simulacra aren't tough, but you can create piles of them. - bwr
1915         acmod = -2;
1916         evmod = -5;
1917         break;
1918
1919     case MONS_SPECTRAL_THING:
1920         acmod = +2;
1921         evmod = -5;
1922         break;
1923
1924     default:
1925         die("invalid zombie type %d (%s)", mon->type,
1926             mons_class_name(mon->type));
1927     }
1928 }
1929
1930 static void _roll_zombie_ac_ev(monster* mon)
1931 {
1932     ASSERT(mons_class_is_zombified(mon->type));
1933
1934     int acmod = 0;
1935     int evmod = 0;
1936
1937     _roll_zombie_ac_ev_mods(mon, acmod, evmod);
1938
1939     mon->ac = max(mon->ac + acmod, 0);
1940     mon->ev = max(mon->ev + evmod, 0);
1941 }
1942
1943 void define_zombie(monster* mon, monster_type ztype, monster_type cs)
1944 {
1945 #if TAG_MAJOR_VERSION == 34
1946     // Upgrading monster enums is a losing battle, they sneak through too many
1947     // channels, like env props, etc.  So convert them on placement, too.
1948     if (cs == MONS_ZOMBIE_SMALL || cs == MONS_ZOMBIE_LARGE)
1949         cs = MONS_ZOMBIE;
1950     if (cs == MONS_SKELETON_SMALL || cs == MONS_SKELETON_LARGE)
1951         cs = MONS_SKELETON;
1952     if (cs == MONS_SIMULACRUM_SMALL || cs == MONS_SIMULACRUM_LARGE)
1953         cs = MONS_SIMULACRUM;
1954 #endif
1955
1956     ASSERT(ztype != MONS_NO_MONSTER);
1957     ASSERT(!invalid_monster_type(ztype));
1958     ASSERT(mons_class_is_zombified(cs));
1959
1960     monster_type base = mons_species(ztype);
1961
1962     // Set type to the original type to calculate appropriate stats.
1963     mon->type         = ztype;
1964     mon->base_monster = MONS_PROGRAM_BUG;
1965     define_monster(mon);
1966
1967     mon->type         = cs;
1968     mon->base_monster = base;
1969
1970     mon->colour       = mons_class_colour(mon->type);
1971     mon->speed        = (cs == MONS_SPECTRAL_THING
1972                             ? mons_class_base_speed(mon->base_monster)
1973                             : mons_class_zombie_base_speed(mon->base_monster));
1974
1975     // Turn off all melee ability flags except dual-wielding.
1976     mon->flags       &= (~MF_MELEE_MASK | MF_TWO_WEAPONS);
1977
1978     // Turn off all spellcasting and priestly ability flags.
1979     // Hack - kraken get to keep their spell-like ability.
1980     if (mon->base_monster != MONS_KRAKEN)
1981         mon->flags   &= ~MF_SPELL_MASK;
1982
1983     // Turn off regeneration if the base monster cannot regenerate.
1984     // This is needed for e.g. spectral things of non-regenerating
1985     // monsters.
1986     if (!mons_class_can_regenerate(mon->base_monster))
1987         mon->flags   |= MF_NO_REGEN;
1988
1989     roll_zombie_hp(mon);
1990     _roll_zombie_ac_ev(mon);
1991 }
1992
1993 bool downgrade_zombie_to_skeleton(monster* mon)
1994 {
1995     if (mon->type != MONS_ZOMBIE || !mons_skeleton(mon->base_monster))
1996         return false;
1997
1998     int acmod = 0;
1999     int evmod = 0;
2000
2001     _roll_zombie_ac_ev_mods(mon, acmod, evmod);
2002
2003     // Reverse the zombie AC and EV mods, since they will be replaced
2004     // with the skeleton AC and EV mods below.
2005     mon->ac = max(mon->ac - acmod, 0);
2006     mon->ev = max(mon->ev - evmod, 0);
2007
2008     const int old_hp    = mon->hit_points;
2009     const int old_maxhp = mon->max_hit_points;
2010
2011     mon->type           = MONS_SKELETON;
2012     mon->colour         = mons_class_colour(mon->type);
2013     mon->speed          = mons_class_zombie_base_speed(mon->base_monster);
2014
2015     roll_zombie_hp(mon);
2016     _roll_zombie_ac_ev(mon);
2017
2018     // Scale the skeleton HP to the zombie HP.
2019     mon->hit_points     = old_hp * mon->max_hit_points / old_maxhp;
2020     mon->hit_points     = max(mon->hit_points, 1);
2021
2022     return true;
2023 }
2024
2025 static band_type _choose_band(monster_type mon_type, int &band_size,
2026                               bool &natural_leader)
2027 {
2028 #ifdef DEBUG_MON_CREATION
2029     mpr("in _choose_band()", MSGCH_DIAGNOSTICS);
2030 #endif
2031     // Band size describes the number of monsters in addition to
2032     // the band leader.
2033     band_size = 0; // Single monster, no band.
2034     natural_leader = false;
2035     band_type band = BAND_NO_BAND;
2036
2037     switch (mon_type)
2038     {
2039     case MONS_ORC:
2040         if (coinflip())
2041             break;
2042         // intentional fall-through {dlb}
2043     case MONS_ORC_WIZARD:
2044         band = BAND_ORCS;
2045         band_size = 2 + random2(3);
2046         break;
2047
2048     case MONS_ORC_PRIEST:
2049     case MONS_ORC_WARRIOR:
2050         band = BAND_ORC_WARRIOR;
2051         band_size = 2 + random2(3);
2052         break;
2053
2054     case MONS_ORC_WARLORD:
2055     case MONS_SAINT_ROKA:
2056         band_size = 5 + random2(5);   // warlords have large bands
2057         // intentional fall through
2058     case MONS_ORC_KNIGHT:
2059         band = BAND_ORC_KNIGHT;       // orcs + knight
2060         band_size += 3 + random2(4);
2061         natural_leader = true;
2062         break;
2063
2064     case MONS_ORC_HIGH_PRIEST:
2065         band = BAND_ORC_HIGH_PRIEST;
2066         band_size = 4 + random2(4);
2067         natural_leader = true;
2068         break;
2069
2070     case MONS_BIG_KOBOLD:
2071         if (env.absdepth0 > 3)
2072         {
2073             band = BAND_KOBOLDS;
2074             band_size = 2 + random2(6);
2075         }
2076         break;
2077
2078     case MONS_KILLER_BEE:
2079         band = BAND_KILLER_BEES;
2080         band_size = 2 + random2(4);
2081         break;
2082
2083     case MONS_FLYING_SKULL:
2084         band = BAND_FLYING_SKULLS;
2085         band_size = 2 + random2(4);
2086         break;
2087     case MONS_SLIME_CREATURE:
2088         band = BAND_SLIME_CREATURES;
2089         band_size = 2 + random2(4);
2090         break;
2091     case MONS_YAK:
2092         band = BAND_YAKS;
2093         band_size = 2 + random2(4);
2094         break;
2095     case MONS_UGLY_THING:
2096     case MONS_VERY_UGLY_THING:
2097         band = BAND_UGLY_THINGS;
2098         band_size = 2 + random2(4);
2099         break;
2100     case MONS_HELL_HOUND:
2101         band = BAND_HELL_HOUNDS;
2102         band_size = 2 + random2(3);
2103         break;
2104     case MONS_JACKAL:
2105         band = BAND_JACKALS;
2106         band_size = 1 + random2(3);
2107         break;
2108     case MONS_MARGERY:
2109         natural_leader = true;
2110     case MONS_HELL_KNIGHT:
2111         band = BAND_HELL_KNIGHTS;
2112         band_size = 4 + random2(4);
2113         break;
2114     case MONS_JOSEPHINE:
2115         band_size = 1 + random2(2);
2116         // intentional fall-through
2117     case MONS_NECROMANCER:
2118         natural_leader = true;
2119         band = BAND_NECROMANCER;
2120         band_size += 3 + random2(3);
2121         break;
2122     case MONS_VAMPIRE_MAGE:
2123         if (one_chance_in(3))
2124         {
2125             natural_leader = true;
2126             band = BAND_JIANGSHI;
2127             band_size = 2 + random2(2);
2128         }
2129         break;
2130     case MONS_JIANGSHI:
2131             band = BAND_JIANGSHI;
2132             band_size = random2(3);
2133         break;
2134     case MONS_GNOLL:
2135         if (!player_in_branch(BRANCH_MAIN_DUNGEON) || you.depth > 1)
2136         {
2137             band = BAND_GNOLLS;
2138             band_size = (coinflip() ? 3 : 2);
2139         }
2140         break;
2141     case MONS_GNOLL_SHAMAN:
2142     case MONS_GNOLL_SERGEANT:
2143         band = BAND_GNOLLS;
2144         band_size = 3 + random2(4);
2145         break;
2146     case MONS_DEEP_DWARF_DEATH_KNIGHT:
2147         if (x_chance_in_y(2, 3))
2148         {
2149             natural_leader = true;
2150             band = BAND_DEATH_KNIGHT;
2151             band_size = 3 + random2(2);
2152         }
2153         break;
2154     case MONS_GRUM:
2155         natural_leader = true;
2156         band = BAND_WOLVES;
2157         band_size = 2 + random2(3);
2158         break;
2159     case MONS_CENTAUR_WARRIOR:
2160         natural_leader = true;
2161     case MONS_CENTAUR:
2162         if (env.absdepth0 > 9 && one_chance_in(3) && !player_in_branch(BRANCH_SHOALS))
2163         {
2164             band = BAND_CENTAURS;
2165             band_size = 2 + random2(4);
2166         }
2167         break;
2168
2169     case MONS_YAKTAUR_CAPTAIN:
2170         natural_leader = true;
2171     case MONS_YAKTAUR:
2172         if (coinflip())
2173         {
2174             band = BAND_YAKTAURS;
2175             band_size = 2 + random2(3);
2176         }
2177         break;
2178
2179     case MONS_DEATH_YAK:
2180         band = BAND_DEATH_YAKS;
2181         band_size = 2 + random2(4);
2182         break;
2183     case MONS_INSUBSTANTIAL_WISP:
2184         band = BAND_INSUBSTANTIAL_WISPS;
2185         band_size = 4 + random2(5);
2186         break;
2187     case MONS_OGRE_MAGE:
2188         natural_leader = true;
2189         band = BAND_OGRE_MAGE;
2190         band_size = 4 + random2(4);
2191         break;
2192     case MONS_BALRUG:
2193         natural_leader = true;
2194         band = BAND_BALRUG;
2195         band_size = 2 + random2(3);
2196         break;
2197     case MONS_CACODEMON:
2198         natural_leader = true;
2199         band = BAND_CACODEMON;
2200         band_size = 1 + random2(3);
2201         break;
2202
2203     case MONS_EXECUTIONER:
2204         if (coinflip())
2205         {
2206             natural_leader = true;
2207             band = BAND_EXECUTIONER;
2208             band_size = 1 + random2(3);
2209         }
2210         break;
2211
2212     case MONS_PANDEMONIUM_LORD:
2213         natural_leader = true;
2214         band = BAND_PANDEMONIUM_LORD;
2215         band_size = random_range(1, 3);
2216         break;
2217
2218     case MONS_HELLWING:
2219         if (coinflip())
2220         {
2221             band = BAND_HELLWING;
2222             band_size = 1 + random2(4);
2223         }
2224         break;
2225
2226     case MONS_DEEP_ELF_FIGHTER:
2227         if (coinflip())
2228         {
2229             band = BAND_DEEP_ELF_FIGHTER;
2230             band_size = 2 + random2(3);
2231         }
2232         break;
2233
2234     case MONS_DEEP_ELF_KNIGHT:
2235         if (coinflip())
2236         {
2237             band = BAND_DEEP_ELF_KNIGHT;
2238             band_size = 3 + random2(2);
2239         }
2240         break;
2241
2242     case MONS_DEEP_ELF_HIGH_PRIEST:
2243         if (coinflip())
2244         {
2245             natural_leader = true;
2246             band = BAND_DEEP_ELF_HIGH_PRIEST;
2247             band_size = 3 + random2(4);
2248         }
2249         break;
2250
2251     case MONS_KOBOLD_DEMONOLOGIST:
2252         if (coinflip())
2253         {
2254             band = BAND_KOBOLD_DEMONOLOGIST;
2255             band_size = 3 + random2(6);
2256         }
2257         break;
2258
2259     case MONS_NAGA_MAGE:
2260     case MONS_NAGA_WARRIOR:
2261         band = BAND_NAGAS;
2262         band_size = 3 + random2(4);
2263         break;
2264
2265     case MONS_WOLF:
2266         band = BAND_WOLVES;
2267         band_size = 2 + random2(4);
2268         break;
2269
2270     case MONS_GREEN_RAT:
2271         band = BAND_GREEN_RATS;
2272         band_size = 4 + random2(6);
2273         break;
2274
2275     case MONS_ORANGE_RAT:
2276         band = BAND_ORANGE_RATS;
2277         band_size = 3 + random2(4);
2278         break;
2279
2280     case MONS_SHEEP:
2281         band = BAND_SHEEP;
2282         band_size = 3 + random2(5);
2283         break;
2284
2285     case MONS_GHOUL:
2286         band = BAND_GHOULS;
2287         band_size = 2 + random2(3);
2288         break;
2289
2290     case MONS_KIRKE:
2291         band_size = 2 + random2(3);
2292         natural_leader = true;
2293     case MONS_HOG:
2294         band = BAND_HOGS;
2295         band_size += 1 + random2(3);
2296         break;
2297
2298     case MONS_VAMPIRE_MOSQUITO:
2299         band = BAND_VAMPIRE_MOSQUITOES;
2300         band_size = 1 + random2(3);
2301         break;
2302
2303     case MONS_FIRE_BAT:
2304         band = BAND_FIRE_BATS;
2305         band_size = 1 + random2(3);
2306         break;
2307
2308     case MONS_DEEP_TROLL_EARTH_MAGE:
2309     case MONS_DEEP_TROLL_SHAMAN:
2310         band = BAND_DEEP_TROLLS;
2311         band_size = 3 + random2(3);
2312         break;
2313
2314     case MONS_HELL_HOG:
2315         band = BAND_HELL_HOGS;
2316         band_size = 1 + random2(3);
2317         break;
2318
2319     case MONS_BOGGART:
2320         band = BAND_BOGGARTS;
2321         band_size = 2 + random2(3);
2322         break;
2323
2324     case MONS_PRINCE_RIBBIT:
2325         natural_leader = true;
2326         // Intentional fallthrough
2327     case MONS_BLINK_FROG:
2328         band = BAND_BLINK_FROGS;
2329         band_size += 2 + random2(3);
2330         break;
2331
2332     case MONS_WIGHT:
2333         band = BAND_WIGHTS;
2334         band_size = 2 + random2(3);
2335         break;
2336
2337     case MONS_ANCIENT_CHAMPION:
2338         if (coinflip())
2339             break;
2340
2341         natural_leader = true;
2342         // Intentional fallthrough
2343     case MONS_SKELETAL_WARRIOR:
2344         band = BAND_SKELETAL_WARRIORS;
2345         band_size = 2 + random2(3);
2346         break;
2347
2348     case MONS_CYCLOPS:
2349         if (one_chance_in(5) || player_in_branch(BRANCH_SHOALS))
2350         {
2351             natural_leader = true;
2352             band = BAND_SHEEP;  // Odyssey reference
2353             band_size = 2 + random2(3);
2354         }
2355         break;
2356
2357     case MONS_ALLIGATOR:
2358         // Alligators with kids!
2359         if (one_chance_in(5))
2360         {
2361             natural_leader = true;
2362             band = BAND_ALLIGATOR;
2363             band_size = 2 + random2(3);
2364         }
2365         break;
2366
2367     case MONS_POLYPHEMUS:
2368         natural_leader = true;
2369         band = BAND_POLYPHEMUS;
2370         band_size = 3 + random2(3);
2371         break;
2372
2373     case MONS_HARPY:
2374         band = BAND_HARPIES;
2375         band_size = 2 + random2(3);
2376         break;
2377
2378     // Journey -- Added Draconian Packs
2379     case MONS_WHITE_DRACONIAN:
2380     case MONS_RED_DRACONIAN:
2381     case MONS_PURPLE_DRACONIAN:
2382     case MONS_MOTTLED_DRACONIAN:
2383     case MONS_YELLOW_DRACONIAN:
2384     case MONS_BLACK_DRACONIAN:
2385     case MONS_GREEN_DRACONIAN:
2386     case MONS_GREY_DRACONIAN:
2387     case MONS_PALE_DRACONIAN:
2388         if (env.absdepth0 > 18 && one_chance_in(3) && player_in_connected_branch())
2389         {
2390             band = BAND_DRACONIAN;
2391             band_size = random_range(2, 4);
2392         }
2393         break;
2394
2395     case MONS_DRACONIAN_CALLER:
2396     case MONS_DRACONIAN_MONK:
2397     case MONS_DRACONIAN_SCORCHER:
2398     case MONS_DRACONIAN_KNIGHT:
2399     case MONS_DRACONIAN_ANNIHILATOR:
2400     case MONS_DRACONIAN_ZEALOT:
2401     case MONS_DRACONIAN_SHIFTER:
2402         if (env.absdepth0 > 20 && player_in_connected_branch())
2403         {
2404             band = BAND_DRACONIAN;
2405             band_size = random_range(3, 6);
2406         }
2407         break;
2408
2409     case MONS_TIAMAT:
2410         natural_leader = true;
2411         band = BAND_DRACONIAN;
2412         // yup, scary
2413         band_size = random_range(3,6) + random_range(3,6) + 2;
2414         break;
2415
2416     case MONS_ILSUIW:
2417         band = BAND_ILSUIW;
2418         band_size = 3 + random2(3);
2419         break;
2420
2421     case MONS_AZRAEL:
2422         natural_leader = true;
2423         band = BAND_AZRAEL;
2424         band_size = 4 + random2(5);
2425         break;
2426
2427     case MONS_DUVESSA:
2428         // no natural_leader since this band is supposed to be symmetric
2429         band = BAND_DUVESSA;
2430         band_size = 1;
2431         break;
2432
2433     case MONS_KHUFU:
2434         natural_leader = true;
2435         band = BAND_KHUFU;
2436         band_size = 3;
2437         break;
2438
2439     case MONS_GOLDEN_EYE:
2440         band = BAND_GOLDEN_EYE;
2441         band_size = 1 + random2(5);
2442         break;
2443
2444     case MONS_PIKEL:
2445         natural_leader = true;
2446         band = BAND_PIKEL;
2447         band_size = 4;
2448         break;
2449
2450     case MONS_MERFOLK_AQUAMANCER:
2451         band = BAND_MERFOLK_AQUAMANCER;
2452         band_size = random_range(3, 6);
2453         break;
2454
2455     case MONS_MERFOLK_JAVELINEER:
2456         band = BAND_MERFOLK_JAVELINEER;
2457         band_size = random_range(3, 5);
2458         break;
2459
2460     case MONS_MERFOLK_IMPALER:
2461         band = BAND_MERFOLK_IMPALER;
2462         band_size = random_range(3, 5);
2463         break;
2464
2465     case MONS_ELEPHANT:
2466         band = BAND_ELEPHANT;
2467         band_size = 2 + random2(4);
2468         break;
2469
2470     case MONS_SHEDU:
2471         band = BAND_SHEDU;
2472         band_size = 1;
2473         break;
2474
2475     case MONS_REDBACK:
2476         band = BAND_REDBACK;
2477         band_size = 1 + random2(5);
2478         break;
2479
2480     case MONS_SPIDER:
2481         band = BAND_SPIDER;
2482         band_size = 1 + random2(4);
2483         break;
2484
2485     case MONS_JUMPING_SPIDER:
2486         if (coinflip())
2487         {
2488             band = BAND_JUMPING_SPIDER;
2489             band_size = 1 + random2(5);
2490         }
2491         break;
2492
2493     case MONS_TARANTELLA:
2494         if (coinflip())
2495         {
2496             band = BAND_TARANTELLA;
2497             band_size = 1 + random2(4);
2498         }
2499         break;
2500
2501     case MONS_VAULT_WARDEN:
2502         natural_leader = true;
2503         if (coinflip())
2504         {
2505             band = BAND_YAKTAURS;
2506             band_size = 2 + random2(4);
2507         }
2508         else
2509         {
2510             band = BAND_VAULT_WARDEN;
2511             band_size = 2 + random2(3);
2512         }
2513         break;
2514
2515     case MONS_IRONHEART_PRESERVER:
2516         natural_leader = true;
2517         switch (random2(3))
2518         {
2519             case 0:
2520                 band = BAND_DEEP_ELF_HIGH_PRIEST;
2521                 band_size = 3 + random2(4);
2522                 break;
2523             case 1:
2524                 band = BAND_DEEP_TROLLS;
2525                 band_size = 3 + random2(3);
2526                 break;
2527             case 2:
2528                 band = BAND_OGRE_MAGE_EXTERN;
2529                 band_size = 4 + random2(4);
2530                 break;
2531         }
2532         break;
2533
2534     case MONS_SATYR:
2535         natural_leader = true;
2536     case MONS_FAUN:
2537         band = BAND_FAUNS;
2538         band_size = 2 + random2(3);
2539         break;
2540
2541     case MONS_TENGU_CONJURER:
2542     case MONS_TENGU_WARRIOR:
2543         natural_leader = true;
2544     case MONS_TENGU:
2545         if (coinflip())
2546             break;
2547         band = BAND_TENGU;
2548         band_size = 2 + random2(3);
2549         break;
2550
2551     case MONS_SOJOBO:
2552         natural_leader = true;
2553         band = BAND_SOJOBO;
2554         band_size = 2;
2555         break;
2556
2557     case MONS_SPRIGGAN_AIR_MAGE:
2558         natural_leader = true;
2559         band = BAND_AIR_ELEMENTALS;
2560         band_size = random_range(2, 3);
2561         break;
2562
2563     case MONS_SPRIGGAN_RIDER:
2564         band = BAND_SPRIGGAN_RIDERS;
2565         band_size = random_range(2, 3);
2566         break;
2567
2568     case MONS_SPRIGGAN_DRUID:
2569     case MONS_SPRIGGAN_BERSERKER:
2570         if (one_chance_in(3))
2571             break;
2572         natural_leader = true;
2573     case MONS_SPRIGGAN:
2574         band = BAND_SPRIGGANS;
2575         band_size = 2 + random2(3);
2576         break;
2577
2578     case MONS_SPRIGGAN_DEFENDER:
2579         natural_leader = true;
2580         band = BAND_SPRIGGAN_ELITES;
2581         band_size = 2 + random2(4);
2582         break;
2583
2584     case MONS_THE_ENCHANTRESS:
2585         natural_leader = true;
2586         band = BAND_ENCHANTRESS;
2587         band_size = 6 + random2avg(5, 2);
2588         break;
2589
2590     case MONS_TREANT:
2591         if (one_chance_in(4))
2592         {
2593             band = BAND_SPRIGGAN_DRUID;
2594             band_size = 1;
2595         }
2596         break;
2597
2598     case MONS_SPIRIT_WOLF:
2599         band = BAND_SPIRIT_WOLVES;
2600         band_size = random_range(0, 2);
2601         break;
2602
2603     case MONS_VAMPIRE_KNIGHT:
2604         if (one_chance_in(4))
2605         {
2606             band = BAND_PHANTASMAL_WARRIORS;
2607             band_size = 2;
2608         }
2609         break;
2610
2611     case MONS_ELEMENTAL_WELLSPRING:
2612         natural_leader = true;
2613         band = BAND_WATER_ELEMENTALS;
2614         band_size = random_range(2, 3);
2615         break;
2616
2617     case MONS_THRASHING_HORROR:
2618     {
2619         int depth = min(brdepth[BRANCH_ABYSS], you.depth);
2620         band = BAND_THRASHING_HORRORS;
2621         band_size = random2(depth);
2622         break;
2623     }
2624
2625     default: ;
2626     }
2627
2628     if (band != BAND_NO_BAND && band_size == 0)
2629         band = BAND_NO_BAND;
2630
2631     if (band_size >= BIG_BAND)
2632         band_size = BIG_BAND - 1;
2633
2634     return band;
2635 }
2636
2637 static monster_type _band_member(band_type band, int which)
2638 {
2639     if (band == BAND_NO_BAND)
2640         return MONS_PROGRAM_BUG;
2641
2642     switch (band)
2643     {
2644     case BAND_KOBOLDS:
2645         return MONS_KOBOLD;
2646
2647     case BAND_ORCS:
2648         if (one_chance_in(8)) // 12.50%
2649             return MONS_ORC_PRIEST;
2650         if (one_chance_in(6)) // 14.58%
2651             return MONS_ORC_WIZARD;
2652         return MONS_ORC;
2653
2654     case BAND_ORC_WARRIOR:
2655         if (one_chance_in(7)) // 14.29%
2656             return MONS_ORC_PRIEST;
2657         if (one_chance_in(5)) // 17.14%
2658             return MONS_ORC_WIZARD;
2659         return MONS_ORC;
2660
2661     case BAND_ORC_KNIGHT:
2662     case BAND_ORC_HIGH_PRIEST:
2663         // XXX: For Beogh punishment, ogres and trolls look out of place...
2664         // (For normal generation, they're okay, of course.)
2665         return random_choose_weighted(12, MONS_ORC,
2666                                        9, MONS_ORC_WARRIOR,
2667                                        2, MONS_WARG,
2668                                        2, MONS_ORC_WIZARD,
2669                                        2, MONS_ORC_PRIEST,
2670                                        1, MONS_OGRE,
2671                                        1, MONS_TROLL,
2672                                        1, MONS_ORC_SORCERER,
2673                                        0);
2674
2675     case BAND_KILLER_BEES:
2676         return MONS_KILLER_BEE;
2677
2678     case BAND_FLYING_SKULLS:
2679         return MONS_FLYING_SKULL;
2680
2681     case BAND_SLIME_CREATURES:
2682         return MONS_SLIME_CREATURE;
2683
2684     case BAND_YAKS:
2685         return MONS_YAK;
2686
2687     case BAND_HARPIES:
2688         return MONS_HARPY;
2689
2690     case BAND_UGLY_THINGS:
2691         return (env.absdepth0 > 21 && one_chance_in(4)) ?
2692                    MONS_VERY_UGLY_THING : MONS_UGLY_THING;
2693
2694     case BAND_HELL_HOUNDS:
2695         return MONS_HELL_HOUND;
2696
2697     case BAND_JACKALS:
2698         return MONS_JACKAL;
2699
2700     case BAND_GNOLLS:
2701         return MONS_GNOLL;
2702
2703     case BAND_CENTAURS:
2704         return MONS_CENTAUR;
2705
2706     case BAND_YAKTAURS:
2707         return MONS_YAKTAUR;
2708
2709     case BAND_INSUBSTANTIAL_WISPS:
2710         return MONS_INSUBSTANTIAL_WISP;
2711
2712     case BAND_POLYPHEMUS:
2713         if (which == 1)
2714             return MONS_CATOBLEPAS;
2715     case BAND_DEATH_YAKS:
2716         return MONS_DEATH_YAK;
2717
2718     case BAND_NECROMANCER:
2719         return random_choose_weighted(6, MONS_ZOMBIE,
2720                                       6, MONS_SKELETON,
2721                                       3, MONS_SIMULACRUM,
2722                                       0);
2723
2724     case BAND_BALRUG:
2725         return coinflip() ? MONS_SUN_DEMON : MONS_RED_DEVIL;
2726
2727     case BAND_CACODEMON:
2728         return coinflip() ? MONS_SIXFIRHY : MONS_ORANGE_DEMON;
2729         break;
2730
2731     case BAND_EXECUTIONER:
2732         return MONS_ABOMINATION_LARGE;
2733         break;
2734
2735     case BAND_PANDEMONIUM_LORD:
2736         if (one_chance_in(7))
2737         {
2738             return random_choose_weighted(50, MONS_LICH,
2739                                           10, MONS_ANCIENT_LICH,
2740                                            0);
2741         }
2742         else if (one_chance_in(6))
2743         {
2744             return random_choose_weighted(50, MONS_ABOMINATION_SMALL,
2745                                           40, MONS_ABOMINATION_LARGE,
2746                                           10, MONS_TENTACLED_MONSTROSITY,
2747                                            0);
2748         }
2749         else
2750         {
2751             return summon_any_demon(random_choose_weighted(
2752                                           50, RANDOM_DEMON_COMMON,
2753                                           20, RANDOM_DEMON_GREATER,
2754                                           10, RANDOM_DEMON,
2755                                            0));
2756         }
2757         break;
2758
2759     case BAND_HELLWING:
2760         return coinflip() ? MONS_HELLWING : MONS_SMOKE_DEMON;
2761
2762     case BAND_DEEP_ELF_FIGHTER:
2763         return random_choose_weighted(3, MONS_DEEP_ELF_FIGHTER,
2764                                       3, MONS_DEEP_ELF_MAGE,
2765                                       2, MONS_DEEP_ELF_PRIEST,
2766                                       1, MONS_DEEP_ELF_CONJURER,
2767                                       0);
2768
2769     case BAND_DEEP_ELF_KNIGHT:
2770         return random_choose_weighted(66, MONS_DEEP_ELF_FIGHTER,
2771                                       52, MONS_DEEP_ELF_MAGE,
2772                                       28, MONS_DEEP_ELF_KNIGHT,
2773                                       20, MONS_DEEP_ELF_CONJURER,
2774                                       16, MONS_DEEP_ELF_PRIEST,
2775                                       12, MONS_DEEP_ELF_SUMMONER,
2776                                        3, MONS_DEEP_ELF_DEATH_MAGE,
2777                                        2, MONS_DEEP_ELF_DEMONOLOGIST,
2778                                        2, MONS_DEEP_ELF_ANNIHILATOR,
2779                                        2, MONS_DEEP_ELF_SORCERER,
2780                                        0);
2781
2782     case BAND_DEEP_ELF_HIGH_PRIEST:
2783         return random_choose_weighted(5, MONS_DEEP_ELF_FIGHTER,
2784                                       2, MONS_DEEP_ELF_PRIEST,
2785                                       2, MONS_DEEP_ELF_MAGE,
2786                                       1, MONS_DEEP_ELF_SUMMONER,
2787                                       1, MONS_DEEP_ELF_CONJURER,
2788                                       1, MONS_DEEP_ELF_DEMONOLOGIST,
2789                                       1, MONS_DEEP_ELF_ANNIHILATOR,
2790                                       1, MONS_DEEP_ELF_SORCERER,
2791                                       1, MONS_DEEP_ELF_DEATH_MAGE,
2792                                       0);
2793
2794     case BAND_HELL_KNIGHTS:
2795         if (one_chance_in(4))
2796             return MONS_NECROMANCER;
2797         return MONS_HELL_KNIGHT;
2798
2799     case BAND_OGRE_MAGE_EXTERN:
2800         if (which == 1)
2801             return MONS_OGRE_MAGE;
2802         // Deliberate fallthrough
2803     case BAND_OGRE_MAGE:
2804         if (one_chance_in(3))
2805             return MONS_TWO_HEADED_OGRE;
2806         return MONS_OGRE;
2807
2808     case BAND_KOBOLD_DEMONOLOGIST:
2809         return random_choose_weighted(8, MONS_KOBOLD,
2810                                           4, MONS_BIG_KOBOLD,
2811                                           1, MONS_KOBOLD_DEMONOLOGIST,
2812                                           0);
2813         break;
2814
2815     case BAND_NAGAS:
2816         return MONS_NAGA;
2817     case BAND_WOLVES:
2818         return MONS_WOLF;
2819     case BAND_GREEN_RATS:
2820         return MONS_GREEN_RAT;
2821     case BAND_ORANGE_RATS:
2822         return MONS_ORANGE_RAT;
2823     case BAND_SHEEP:
2824         return MONS_SHEEP;
2825     case BAND_GHOULS:
2826         return random_choose_weighted(4, MONS_GHOUL,
2827                                       3, MONS_NECROPHAGE,
2828                                       2, MONS_PLAGUE_SHAMBLER,
2829                                       0);
2830     case BAND_DEEP_TROLLS:
2831         if (one_chance_in(3))
2832             return random_choose(MONS_DEEP_TROLL_EARTH_MAGE,
2833                                  MONS_DEEP_TROLL_SHAMAN,
2834                                  -1);
2835         return MONS_DEEP_TROLL;
2836     case BAND_HOGS:
2837         return MONS_HOG;
2838     case BAND_HELL_HOGS:
2839         return MONS_HELL_HOG;
2840     case BAND_VAMPIRE_MOSQUITOES:
2841         return MONS_VAMPIRE_MOSQUITO;
2842     case BAND_FIRE_BATS:
2843         return MONS_FIRE_BAT;
2844     case BAND_BOGGARTS:
2845         return MONS_BOGGART;
2846     case BAND_BLINK_FROGS:
2847         return MONS_BLINK_FROG;
2848     case BAND_WIGHTS:
2849         return MONS_WIGHT;
2850     case BAND_SKELETAL_WARRIORS:
2851         return MONS_SKELETAL_WARRIOR;
2852
2853     case BAND_DRACONIAN:
2854         if (env.absdepth0 >= 24 && x_chance_in_y(13, 40))
2855         {
2856             // Hack: race is rolled elsewhere.
2857             return random_choose_weighted(
2858                 1, MONS_DRACONIAN_CALLER,
2859                 2, MONS_DRACONIAN_KNIGHT,
2860                 2, MONS_DRACONIAN_MONK,
2861                 2, MONS_DRACONIAN_SHIFTER,
2862                 2, MONS_DRACONIAN_ANNIHILATOR,
2863                 2, MONS_DRACONIAN_SCORCHER,
2864                 2, MONS_DRACONIAN_ZEALOT,
2865                 0);
2866         }
2867
2868         return random_draconian_monster_species();
2869
2870     case BAND_ILSUIW:
2871         return random_choose_weighted(30, MONS_MERMAID,
2872                                       15, MONS_MERFOLK,
2873                                       10, MONS_MERFOLK_JAVELINEER,
2874                                       10, MONS_MERFOLK_IMPALER,
2875                                        0);
2876
2877     case BAND_AZRAEL:
2878         return coinflip() ? MONS_FIRE_ELEMENTAL : MONS_HELL_HOUND;
2879
2880     case BAND_DUVESSA:
2881         return MONS_DOWAN;
2882
2883     case BAND_ALLIGATOR:
2884         return MONS_BABY_ALLIGATOR;
2885
2886     case BAND_KHUFU:
2887         return coinflip() ? MONS_GREATER_MUMMY : MONS_MUMMY;
2888
2889     case BAND_GOLDEN_EYE:
2890         return MONS_GOLDEN_EYE;
2891
2892     case BAND_PIKEL:
2893         return MONS_SLAVE;
2894
2895     case BAND_MERFOLK_AQUAMANCER:
2896         return random_choose_weighted( 8, MONS_MERFOLK,
2897                                       10, MONS_WATER_ELEMENTAL,
2898                                        0);
2899
2900     case BAND_MERFOLK_IMPALER:
2901     case BAND_MERFOLK_JAVELINEER:
2902         return MONS_MERFOLK;
2903
2904     case BAND_ELEPHANT:
2905         return MONS_ELEPHANT;
2906
2907     case BAND_SHEDU: