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