1 /*
2  *  File:       mon-pick.cc
3  *  Summary:    Functions used to help determine which monsters should appear.
4  *  Written by: Linley Henzell
5  *
6  *  Change History (most recent first):
7  *
8  *               <2>   08-Mar-2000      DLB             enumeration & clean-up
9  *               <1>     -/--/--        LRH             Created
10  */
11 
12 #include "AppHdr.h"
13 #include "mon-pick.h"
14 
15 #include "externs.h"
16 
17 static int mons_cocytus_level(int mcls);
18 static int mons_cocytus_rare(int mcls);
19 static int mons_crypt_level(int mcls);
20 static int mons_crypt_rare(int mcls);
21 static int mons_dis_level(int mcls);
22 static int mons_dis_rare(int mcls);
23 static int mons_gehenna_level(int mcls);
24 static int mons_gehenna_rare(int mcls);
25 static int mons_hallblade_level(int mcls);
26 static int mons_hallblade_rare(int mcls);
27 static int mons_hallelf_level(int mcls);
28 static int mons_hallelf_rare(int mcls);
29 static int mons_hallzot_level(int mcls);
30 static int mons_hallzot_rare(int mcls);
31 static int mons_hive_level(int mcls);
32 static int mons_hive_rare(int mcls);
33 static int mons_lair_level(int mcls);
34 static int mons_lair_rare(int mcls);
35 static int mons_mineorc_level(int mcls);
36 static int mons_mineorc_rare(int mcls);
37 static int mons_pitslime_level(int mcls);
38 static int mons_pitslime_rare(int mcls);
39 static int mons_pitsnake_level(int mcls);
40 static int mons_pitsnake_rare(int mcls);
41 static int mons_standard_level(int mcls);
42 static int mons_standard_rare(int mcls);
43 static int mons_swamp_level(int mcls);
44 static int mons_swamp_rare(int mcls);
45 static int mons_tartarus_level(int mcls);
46 static int mons_tartarus_rare(int mcls);
47 static int mons_tomb_level(int mcls);
48 static int mons_tomb_rare(int mcls);
49 
50 /* ******************* BEGIN EXTERNAL FUNCTIONS ******************* */
branch_depth(int branch)51 int branch_depth(int branch)
52 {
53     switch (branch)
54     {
55     case STAIRS_LAIR:
56         return 10;
57 
58     case STAIRS_VAULTS:
59         return 8;
60 
61     case STAIRS_ELVEN_HALLS:
62         return 7;
63 
64     case STAIRS_SLIME_PITS:
65         return 6;
66 
67     case STAIRS_CRYPT:
68     case STAIRS_HALL_OF_ZOT:
69     case STAIRS_SNAKE_PIT:
70     case STAIRS_SWAMP:
71         return 5;
72 
73     case STAIRS_HIVE:
74     case STAIRS_ORCISH_MINES:
75         return 4;
76 
77     case STAIRS_TOMB:
78         return 3;
79 
80     case STAIRS_ECUMENICAL_TEMPLE:
81     case STAIRS_HALL_OF_BLADES:
82         return 1;
83 
84     default:
85         return 0;
86     }
87 }                               // end branch_depth()
88 
89 // NB - When adding new branches or levels above 50, you must
90 // change pre-game deletion routine in new_game in newgame.cc
91 
mons_level(int mcls)92 int mons_level(int mcls)
93 {
94     int monster_level = 0;
95     int (*fnc_level) (int) = 0;
96 
97     if (you.level_type == LEVEL_ABYSS)
98         monster_level = ((mons_abyss(mcls)) ? 51 : 0);
99     else if (you.level_type == LEVEL_PANDEMONIUM)
100         monster_level = ((mons_pan(mcls)) ? 52 : 0);
101     else
102     {
103         fnc_level =
104             ((you.where_are_you == BRANCH_DIS)          ? mons_dis_level :
105              (you.where_are_you == BRANCH_GEHENNA)      ? mons_gehenna_level :
106              (you.where_are_you == BRANCH_COCYTUS)      ? mons_cocytus_level :
107              (you.where_are_you == BRANCH_TARTARUS)     ? mons_tartarus_level :
108              (you.where_are_you == BRANCH_ORCISH_MINES) ? mons_mineorc_level :
109              (you.where_are_you == BRANCH_HIVE)         ? mons_hive_level :
110              (you.where_are_you == BRANCH_LAIR)         ? mons_lair_level :
111              (you.where_are_you == BRANCH_SLIME_PITS)   ? mons_pitslime_level :
112              (you.where_are_you == BRANCH_CRYPT)        ? mons_crypt_level :
113              (you.where_are_you == BRANCH_HALL_OF_BLADES)?mons_hallblade_level :
114              (you.where_are_you == BRANCH_HALL_OF_ZOT)  ? mons_hallzot_level :
115              (you.where_are_you == BRANCH_SNAKE_PIT)    ? mons_pitsnake_level :
116              (you.where_are_you == BRANCH_ELVEN_HALLS)  ? mons_hallelf_level :
117              (you.where_are_you == BRANCH_TOMB)         ? mons_tomb_level :
118              (you.where_are_you == BRANCH_SWAMP)        ? mons_swamp_level :
119              (you.where_are_you == BRANCH_VAULTS)       ? mons_standard_level
120                                                         : mons_standard_level);
121 
122         monster_level = fnc_level(mcls);
123     }
124 
125     return (monster_level);
126 }                               // end mons_level()
127 
128 // higher values returned means the monster is "more common"
129 // a return value of zero means the monster will never appear {dlb}
mons_rarity(int mcls)130 int mons_rarity(int mcls)
131 {
132     int monster_rarity = 0;
133     int (*fnc_rarity) (int) = 0;
134 
135     // now, what about pandemonium ??? {dlb}
136     if (you.level_type == LEVEL_ABYSS)
137         return mons_rare_abyss(mcls);
138     else
139     {
140         fnc_rarity =
141              ((you.where_are_you == BRANCH_DIS)           ? mons_dis_rare :
142               (you.where_are_you == BRANCH_GEHENNA)       ? mons_gehenna_rare :
143               (you.where_are_you == BRANCH_COCYTUS)       ? mons_cocytus_rare :
144               (you.where_are_you == BRANCH_TARTARUS)      ? mons_tartarus_rare :
145               (you.where_are_you == BRANCH_ORCISH_MINES)  ? mons_mineorc_rare :
146               (you.where_are_you == BRANCH_HIVE)          ? mons_hive_rare :
147               (you.where_are_you == BRANCH_LAIR)          ? mons_lair_rare :
148               (you.where_are_you == BRANCH_SLIME_PITS)    ? mons_pitslime_rare :
149               (you.where_are_you == BRANCH_CRYPT)         ? mons_crypt_rare :
150               (you.where_are_you == BRANCH_HALL_OF_BLADES)?mons_hallblade_rare :
151               (you.where_are_you == BRANCH_HALL_OF_ZOT)   ? mons_hallzot_rare :
152               (you.where_are_you == BRANCH_SNAKE_PIT)     ? mons_pitsnake_rare :
153               (you.where_are_you == BRANCH_ELVEN_HALLS)   ? mons_hallelf_rare :
154               (you.where_are_you == BRANCH_TOMB)          ? mons_tomb_rare :
155               (you.where_are_you == BRANCH_SWAMP)         ? mons_swamp_rare :
156               (you.where_are_you == BRANCH_VAULTS)        ? mons_standard_rare
157                                                           : mons_standard_rare);
158 
159         monster_rarity = fnc_rarity(mcls);
160     }
161 
162     return (monster_rarity);
163 }                               // end mons_rarity()
164 
mons_abyss(int mcls)165 bool mons_abyss(int mcls)
166 {
167     switch (mcls)
168     {
169     case MONS_ABOMINATION_LARGE:
170     case MONS_ABOMINATION_SMALL:
171     case MONS_AIR_ELEMENTAL:
172     case MONS_ANCIENT_LICH:
173     case MONS_BALRUG:
174     case MONS_BLUE_DEATH:
175     case MONS_BLUE_DEVIL:
176     case MONS_BRAIN_WORM:
177     case MONS_CACODEMON:
178     case MONS_CLAY_GOLEM:
179     case MONS_CRYSTAL_GOLEM:
180     case MONS_DANCING_WEAPON:
181     case MONS_DEMONIC_CRAWLER:
182     case MONS_EARTH_ELEMENTAL:
183     case MONS_EFREET:
184     case MONS_EXECUTIONER:
185     case MONS_EYE_OF_DEVASTATION:
186     case MONS_EYE_OF_DRAINING:
187     case MONS_FIRE_ELEMENTAL:
188     case MONS_FLAYED_GHOST:
189     case MONS_FLYING_SKULL:
190     case MONS_FREEZING_WRAITH:
191     case MONS_FUNGUS:
192     case MONS_GIANT_EYEBALL:
193     case MONS_GIANT_ORANGE_BRAIN:
194     case MONS_GIANT_SPORE:
195     case MONS_GREAT_ORB_OF_EYES:
196     case MONS_GREEN_DEATH:
197     case MONS_GUARDIAN_NAGA:
198     case MONS_HAIRY_DEVIL:
199     case MONS_HELLION:
200     case MONS_HELLWING:
201     case MONS_HELL_HOUND:
202     case MONS_HELL_KNIGHT:
203     case MONS_HUNGRY_GHOST:
204     case MONS_ICE_BEAST:
205     case MONS_ICE_DEVIL:
206     case MONS_IMP:
207     case MONS_INSUBSTANTIAL_WISP:
208     case MONS_IRON_DEVIL:
209     case MONS_IRON_GOLEM:
210     case MONS_JELLY:
211     case MONS_SKELETON_LARGE:
212     case MONS_LEMURE:
213     case MONS_LICH:
214     case MONS_LOROCYPROCA:
215     case MONS_MANES:
216     case MONS_MIDGE:
217     case MONS_MUMMY:
218     case MONS_NAGA_MAGE:
219     case MONS_NAGA_WARRIOR:
220     case MONS_NECROMANCER:
221     case MONS_NECROPHAGE:
222     case MONS_NEQOXEC:
223     case MONS_ORANGE_DEMON:
224     case MONS_PHANTOM:
225     case MONS_PIT_FIEND:
226     case MONS_RAKSHASA:
227     case MONS_REAPER:
228     case MONS_RED_DEVIL:
229     case MONS_ROTTING_DEVIL:
230     case MONS_SHADOW:
231     case MONS_SHADOW_DEMON:
232     case MONS_SHADOW_IMP:
233     case MONS_SHINING_EYE:
234     case MONS_SKELETAL_DRAGON:
235     case MONS_SKELETAL_WARRIOR:
236     case MONS_SKELETON_SMALL:
237     case MONS_SMOKE_DEMON:
238     case MONS_SOUL_EATER:
239     case MONS_SPECTRAL_WARRIOR:
240     case MONS_SPINY_WORM:
241     case MONS_STONE_GOLEM:
242     case MONS_SUN_DEMON:
243     case MONS_TENTACLED_MONSTROSITY:
244     case MONS_TOENAIL_GOLEM:
245     case MONS_TORMENTOR:
246     case MONS_UFETUBUS:
247     case MONS_UGLY_THING:
248     case MONS_UNSEEN_HORROR:
249     case MONS_VAMPIRE:
250     case MONS_VAPOUR:
251     case MONS_VERY_UGLY_THING:
252     case MONS_WHITE_IMP:
253     case MONS_WIGHT:
254     case MONS_WIZARD:
255     case MONS_WOOD_GOLEM:
256     case MONS_WRAITH:
257     case MONS_YNOXINUL:
258     case MONS_ZOMBIE_LARGE:
259     case MONS_ZOMBIE_SMALL:
260     case MONS_SIMULACRUM_LARGE:
261     case MONS_SIMULACRUM_SMALL:
262         return true;
263     default:
264         return false;
265     }
266 }                               // end mons_abyss()
267 
mons_rare_abyss(int mcls)268 int mons_rare_abyss(int mcls)
269 {
270     switch (mcls)
271     {
272     case MONS_ABOMINATION_LARGE:
273     case MONS_ABOMINATION_SMALL:
274         return 99;
275 
276     case MONS_LEMURE:
277     case MONS_MANES:
278     case MONS_MIDGE:
279     case MONS_UFETUBUS:
280     case MONS_WHITE_IMP:
281         return 80;
282 
283     case MONS_HELLWING:
284     case MONS_NEQOXEC:
285     case MONS_ORANGE_DEMON:
286     case MONS_SMOKE_DEMON:
287     case MONS_YNOXINUL:
288         return 50;
289 
290     case MONS_SKELETON_LARGE:
291     case MONS_SKELETAL_WARRIOR:
292     case MONS_SKELETON_SMALL:
293         return 40;
294 
295     case MONS_ZOMBIE_LARGE:
296     case MONS_ZOMBIE_SMALL:
297         return 35;
298 
299     case MONS_SKELETAL_DRAGON:
300         return 20;
301 
302     case MONS_EFREET:
303         return 18;
304 
305     case MONS_RAKSHASA:
306         return 17;
307 
308     case MONS_BRAIN_WORM:
309         return 16;
310 
311     case MONS_FLYING_SKULL:
312     case MONS_FREEZING_WRAITH:
313     case MONS_GIANT_ORANGE_BRAIN:
314     case MONS_VERY_UGLY_THING:
315     case MONS_WRAITH:
316         return 15;
317 
318     case MONS_EYE_OF_DRAINING:
319     case MONS_LICH:
320         return 14;
321 
322     case MONS_INSUBSTANTIAL_WISP:
323     case MONS_UNSEEN_HORROR:
324         return 12;
325 
326     case MONS_HELL_HOUND:
327     case MONS_HUNGRY_GHOST:
328     case MONS_SHADOW:
329         return 11;
330 
331     case MONS_BALRUG:
332     case MONS_BLUE_DEATH:
333     case MONS_BLUE_DEVIL:
334     case MONS_CACODEMON:
335     case MONS_DEMONIC_CRAWLER:
336     case MONS_EXECUTIONER:
337     case MONS_GREEN_DEATH:
338     case MONS_GUARDIAN_NAGA:
339     case MONS_HAIRY_DEVIL:
340     case MONS_HELLION:
341     case MONS_ICE_DEVIL:
342     case MONS_IMP:
343     case MONS_LOROCYPROCA:
344     case MONS_MUMMY:
345     case MONS_NECROPHAGE:
346     case MONS_ROTTING_DEVIL:
347     case MONS_SHADOW_DEMON:
348     case MONS_SHADOW_IMP:
349     case MONS_SUN_DEMON:
350     case MONS_WIGHT:
351         return 10;
352 
353     case MONS_ICE_BEAST:
354     case MONS_JELLY:
355     case MONS_TORMENTOR:
356     case MONS_VAMPIRE:
357     case MONS_VAPOUR:
358     case MONS_SIMULACRUM_LARGE:
359     case MONS_SIMULACRUM_SMALL:
360         return 9;
361 
362     case MONS_FUNGUS:
363     case MONS_GIANT_EYEBALL:
364     case MONS_PHANTOM:
365     case MONS_REAPER:
366         return 8;
367 
368     case MONS_SOUL_EATER:
369         return 7;
370 
371     case MONS_IRON_DEVIL:
372         return 6;
373 
374     case MONS_ANCIENT_LICH:
375     case MONS_CLAY_GOLEM:
376     case MONS_GREAT_ORB_OF_EYES:
377     case MONS_IRON_GOLEM:
378     case MONS_NAGA_MAGE:
379     case MONS_NAGA_WARRIOR:
380     case MONS_PIT_FIEND:
381     case MONS_RED_DEVIL:
382     case MONS_SHINING_EYE:
383     case MONS_SPECTRAL_WARRIOR:
384     case MONS_SPINY_WORM:
385     case MONS_STONE_GOLEM:
386     case MONS_TENTACLED_MONSTROSITY:
387     case MONS_WIZARD:
388     case MONS_WOOD_GOLEM:
389         return 5;
390 
391     case MONS_AIR_ELEMENTAL:
392     case MONS_EARTH_ELEMENTAL:
393     case MONS_FIRE_ELEMENTAL:
394     case MONS_FLAYED_GHOST:
395         return 4;
396 
397     case MONS_CRYSTAL_GOLEM:
398     case MONS_EYE_OF_DEVASTATION:
399     case MONS_HELL_KNIGHT:
400     case MONS_NECROMANCER:
401     case MONS_UGLY_THING:
402         return 3;
403 
404     case MONS_DANCING_WEAPON:
405     case MONS_GIANT_SPORE:
406         return 2;
407 
408     case MONS_TOENAIL_GOLEM:
409         return 1;
410 
411     default:
412         return 0;
413     }
414 }                               // end mons_rare_abyss()
415 
mons_pan(int mcls)416 bool mons_pan(int mcls)
417 {
418     switch (mcls)
419     {
420     // icky monsters
421     case MONS_BRAIN_WORM:
422     case MONS_FUNGUS:
423     case MONS_GIANT_ORANGE_BRAIN:
424     case MONS_JELLY:
425     case MONS_SLIME_CREATURE:
426     // undead
427     case MONS_FLAYED_GHOST:
428     case MONS_FLYING_SKULL:
429     case MONS_FREEZING_WRAITH:
430     case MONS_HUNGRY_GHOST:
431     case MONS_SKELETON_LARGE:
432     case MONS_LICH:
433     case MONS_MUMMY:
434     case MONS_NECROPHAGE:
435     case MONS_PHANTOM:
436     case MONS_SHADOW:
437     case MONS_SKELETON_SMALL:
438     case MONS_SPECTRAL_WARRIOR:
439     case MONS_VAMPIRE:
440     case MONS_WIGHT:
441     case MONS_WRAITH:
442     case MONS_ZOMBIE_LARGE:
443     case MONS_ZOMBIE_SMALL:
444     case MONS_SIMULACRUM_LARGE:
445     case MONS_SIMULACRUM_SMALL:
446     // "things"
447     case MONS_ABOMINATION_LARGE:
448     case MONS_ABOMINATION_SMALL:
449     case MONS_INSUBSTANTIAL_WISP:
450     case MONS_PULSATING_LUMP:
451     case MONS_UNSEEN_HORROR:
452     // eyes
453     case MONS_EYE_OF_DRAINING:
454     case MONS_GIANT_EYEBALL:
455     case MONS_GREAT_ORB_OF_EYES:
456     // malign beings
457     case MONS_EFREET:
458     case MONS_RAKSHASA:
459     //case MONS_RAKSHASA_FAKE:    //jmf: FIXME: really create these?
460                                   // I'm guessing not -- bwr
461     // golems
462     case MONS_CLAY_GOLEM:
463     case MONS_CRYSTAL_GOLEM:
464     case MONS_IRON_GOLEM:
465     case MONS_STONE_GOLEM:
466     case MONS_TOENAIL_GOLEM:
467     case MONS_WOOD_GOLEM:
468     // dragon(s)
469     case MONS_MOTTLED_DRAGON:
470     // elementals
471     case MONS_AIR_ELEMENTAL:
472     case MONS_EARTH_ELEMENTAL:
473     case MONS_FIRE_ELEMENTAL:
474     // humanoids
475     case MONS_NECROMANCER:
476     case MONS_STONE_GIANT:
477     case MONS_WIZARD:
478     // demons
479     case MONS_BALRUG:
480     case MONS_BLUE_DEATH:
481     case MONS_CACODEMON:
482     case MONS_EXECUTIONER:
483     case MONS_GREEN_DEATH:
484     case MONS_HELLWING:
485     case MONS_LEMURE:
486     case MONS_MANES:
487     case MONS_MIDGE:
488     case MONS_NEQOXEC:
489     case MONS_ORANGE_DEMON:
490     case MONS_SMOKE_DEMON:
491     case MONS_UFETUBUS:
492     case MONS_WHITE_IMP:
493     case MONS_YNOXINUL:
494         return true;
495     default:
496         return false;
497     }
498 }                               // end mons_pan()
499 
500 /* ******************** END EXTERNAL FUNCTIONS ******************** */
501 
mons_dis_level(int mcls)502 static int mons_dis_level(int mcls)
503 {
504     int mlev = 26;
505 
506     switch (mcls)
507     {
508     case MONS_CLAY_GOLEM:
509     case MONS_IMP:
510     case MONS_NECROPHAGE:
511     case MONS_RED_DEVIL:
512     case MONS_SKELETAL_WARRIOR:
513     case MONS_ZOMBIE_LARGE:
514         mlev++;
515         break;
516 
517     case MONS_HELL_HOUND:
518     case MONS_HELL_KNIGHT:
519     case MONS_SKELETON_LARGE:
520     case MONS_PHANTOM:
521     case MONS_ROTTING_DEVIL:
522     case MONS_SHADOW:
523     case MONS_SKELETON_SMALL:
524     case MONS_STONE_GOLEM:
525     case MONS_TORMENTOR:
526     case MONS_WIGHT:
527     case MONS_ZOMBIE_SMALL:
528         mlev += 2;
529         break;
530 
531     case MONS_EFREET:
532     case MONS_FLYING_SKULL:
533     case MONS_HELLION:
534     case MONS_HELL_HOG:
535     case MONS_IRON_GOLEM:
536     case MONS_MUMMY:
537         mlev += 3;
538         break;
539 
540     case MONS_FLAYED_GHOST:
541     case MONS_FREEZING_WRAITH:
542     case MONS_HAIRY_DEVIL:
543     case MONS_IRON_DEVIL:
544     case MONS_VAMPIRE:
545     case MONS_WRAITH:
546         mlev += 4;
547         break;
548 
549     case MONS_BLUE_DEVIL:
550     case MONS_DANCING_WEAPON:
551     case MONS_ICE_DEVIL:
552     case MONS_ICE_DRAGON:
553     case MONS_LICH:
554     case MONS_REAPER:
555     case MONS_SOUL_EATER:
556     case MONS_SPECTRAL_WARRIOR:
557         mlev += 5;
558         break;
559 
560     case MONS_ANCIENT_LICH:
561     case MONS_FIEND:
562     case MONS_IRON_DRAGON:
563     case MONS_SKELETAL_DRAGON:
564         mlev += 6;
565         break;
566 
567     default:
568         return 0;
569     }
570 
571     return (mlev);
572 }                               // end mons_dis_level()
573 
mons_dis_rare(int mcls)574 static int mons_dis_rare(int mcls)
575 {
576     switch (mcls)
577     {
578     case MONS_IMP:
579     case MONS_IRON_DEVIL:
580     case MONS_ZOMBIE_LARGE:
581     case MONS_ZOMBIE_SMALL:
582         return 99;
583 
584     case MONS_REAPER:
585         return 77;
586 
587     case MONS_TORMENTOR:
588         return 66;
589 
590     case MONS_RED_DEVIL:
591     case MONS_SKELETAL_WARRIOR:
592         return 50;
593 
594     case MONS_WRAITH:
595         return 48;
596 
597     case MONS_SHADOW:
598         return 56;
599 
600     case MONS_HELL_HOUND:
601         return 46;
602 
603     case MONS_MUMMY:
604     case MONS_WIGHT:
605         return 45;
606 
607     case MONS_HELLION:
608     case MONS_BLUE_DEVIL:
609         return 40;
610 
611     case MONS_FLYING_SKULL:
612         return 35;
613 
614     case MONS_FREEZING_WRAITH:
615     case MONS_ICE_DEVIL:
616         return 30;
617 
618     case MONS_FLAYED_GHOST:
619     case MONS_SKELETON_LARGE:
620     case MONS_NECROPHAGE:
621     case MONS_SKELETON_SMALL:
622         return 25;
623 
624     case MONS_HELL_HOG:
625     case MONS_SKELETAL_DRAGON:
626         return 20;
627 
628     case MONS_VAMPIRE:
629         return 19;
630 
631     case MONS_PHANTOM:
632         return 17;
633 
634     case MONS_HAIRY_DEVIL:
635         return 15;
636 
637     case MONS_CLAY_GOLEM:
638     case MONS_DANCING_WEAPON:
639     case MONS_EFREET:
640     case MONS_HELL_KNIGHT:
641     case MONS_IRON_GOLEM:
642     case MONS_LICH:
643     case MONS_ROTTING_DEVIL:
644     case MONS_SOUL_EATER:
645     case MONS_SPECTRAL_WARRIOR:
646     case MONS_STONE_GOLEM:
647         return 10;
648 
649     case MONS_IRON_DRAGON:
650         return 5;
651 
652     case MONS_ANCIENT_LICH:
653     case MONS_FIEND:
654         return 3;
655 
656     default:
657         return 0;
658     }
659 }                               // end mons_dis_rare()
660 
mons_gehenna_level(int mcls)661 static int mons_gehenna_level(int mcls)
662 {
663     int mlev = 26;
664 
665     switch (mcls)
666     {
667     case MONS_CLAY_GOLEM:
668     case MONS_SKELETON_LARGE:
669     case MONS_RED_DEVIL:
670     case MONS_SKELETON_SMALL:
671     case MONS_ZOMBIE_LARGE:
672     case MONS_ZOMBIE_SMALL:
673         mlev++;
674         break;
675 
676     case MONS_HELL_HOG:
677     case MONS_HELL_HOUND:
678     case MONS_IMP:
679     case MONS_NECROPHAGE:
680     case MONS_STONE_GOLEM:
681         mlev += 2;
682         break;
683 
684     case MONS_FLYING_SKULL:
685     case MONS_IRON_GOLEM:
686     case MONS_MUMMY:
687     case MONS_PHANTOM:
688     case MONS_ROTTING_DEVIL:
689     case MONS_SHADOW:
690     case MONS_WIGHT:
691         mlev += 3;
692         break;
693 
694     case MONS_HAIRY_DEVIL:
695     case MONS_HELL_KNIGHT:
696     case MONS_VAMPIRE:
697     case MONS_WRAITH:
698         mlev += 4;
699         break;
700 
701     case MONS_EFREET:
702     case MONS_FLAYED_GHOST:
703     case MONS_HELLION:
704     case MONS_TORMENTOR:
705         mlev += 5;
706         break;
707 
708     case MONS_ANCIENT_LICH:
709     case MONS_FIEND:
710     case MONS_LICH:
711     case MONS_PIT_FIEND:
712     case MONS_REAPER:
713     case MONS_SERPENT_OF_HELL:
714     case MONS_SKELETAL_DRAGON:
715     case MONS_SOUL_EATER:
716     case MONS_SPECTRAL_WARRIOR:
717         mlev += 6;
718         break;
719 
720     default:
721         return 0;
722     }
723 
724     return (mlev);
725 }                               // end mons_gehenna_level()
726 
mons_gehenna_rare(int mcls)727 static int mons_gehenna_rare(int mcls)
728 {
729     switch (mcls)
730     {
731     case MONS_SKELETON_LARGE:
732     case MONS_SKELETON_SMALL:
733     case MONS_ZOMBIE_LARGE:
734     case MONS_ZOMBIE_SMALL:
735         return 99;
736 
737     case MONS_MUMMY:
738         return 70;
739 
740     case MONS_SHADOW:
741         return 61;
742 
743     case MONS_RED_DEVIL:
744     case MONS_WIGHT:
745         return 60;
746 
747     case MONS_HELLION:
748         return 54;
749 
750     case MONS_WRAITH:
751         return 53;
752 
753     case MONS_NECROPHAGE:
754     case MONS_ROTTING_DEVIL:
755         return 50;
756 
757     case MONS_VAMPIRE:
758         return 44;
759 
760     case MONS_FLYING_SKULL:
761     case MONS_REAPER:
762         return 43;
763 
764     case MONS_TORMENTOR:
765         return 42;
766 
767     case MONS_HELL_HOUND:
768         return 41;
769 
770     case MONS_FLAYED_GHOST:
771     case MONS_PHANTOM:
772         return 32;
773 
774     case MONS_HELL_HOG:
775     case MONS_IMP:
776     case MONS_IRON_DEVIL:
777         return 30;
778 
779     case MONS_LICH:
780         return 25;
781 
782     case MONS_HELL_KNIGHT:
783         return 21;
784 
785     case MONS_HAIRY_DEVIL:
786     case MONS_SPECTRAL_WARRIOR:
787         return 20;
788 
789     case MONS_CLAY_GOLEM:
790     case MONS_SKELETAL_DRAGON:
791         return 10;
792 
793     case MONS_STONE_GOLEM:
794         return 8;
795 
796     case MONS_PIT_FIEND:
797         return 7;
798 
799     case MONS_EFREET:
800     case MONS_FIEND:
801     case MONS_IRON_GOLEM:
802     case MONS_SOUL_EATER:
803         return 5;
804 
805     case MONS_ANCIENT_LICH:
806     case MONS_SERPENT_OF_HELL:
807         return 4;
808 
809     default:
810         return 0;
811     }
812 }                               // end mons_gehenna_rare()
813 
mons_cocytus_level(int mcls)814 static int mons_cocytus_level(int mcls)
815 {
816     int mlev = 26;
817 
818     switch (mcls)
819     {
820     case MONS_SKELETON_LARGE:
821     case MONS_NECROPHAGE:
822     case MONS_SKELETAL_WARRIOR:
823     case MONS_SKELETON_SMALL:
824     case MONS_ZOMBIE_LARGE:
825     case MONS_ZOMBIE_SMALL:
826     case MONS_SIMULACRUM_LARGE:
827     case MONS_SIMULACRUM_SMALL:
828         mlev++;
829         break;
830 
831     case MONS_BLUE_DEVIL:
832     case MONS_ICE_BEAST:
833     case MONS_PHANTOM:
834     case MONS_SHADOW:
835         mlev += 2;
836         break;
837 
838     case MONS_FLYING_SKULL:
839     case MONS_ROTTING_DEVIL:
840     case MONS_VAMPIRE:
841     case MONS_WIGHT:
842         mlev += 3;
843         break;
844 
845     case MONS_FREEZING_WRAITH:
846     case MONS_HAIRY_DEVIL:
847     case MONS_HUNGRY_GHOST:
848     case MONS_MUMMY:
849     case MONS_SPECTRAL_WARRIOR:
850     case MONS_WRAITH:
851         mlev += 4;
852         break;
853 
854     case MONS_ICE_DEVIL:
855     case MONS_ICE_DRAGON:
856     case MONS_TORMENTOR:
857         mlev += 5;
858         break;
859 
860     case MONS_ANCIENT_LICH:
861     case MONS_LICH:
862     case MONS_REAPER:
863     case MONS_SKELETAL_DRAGON:
864     case MONS_SOUL_EATER:
865         mlev += 6;
866         break;
867 
868     default:
869         return 0;
870     }
871 
872     return (mlev);
873 }                               // end mons_cocytus_level()
874 
mons_cocytus_rare(int mcls)875 static int mons_cocytus_rare(int mcls)
876 {
877     switch (mcls)
878     {
879     case MONS_FREEZING_WRAITH:
880         return 87;
881 
882     case MONS_ICE_BEAST:
883     case MONS_SKELETON_LARGE:
884     case MONS_SKELETON_SMALL:
885     case MONS_ZOMBIE_LARGE:
886     case MONS_ZOMBIE_SMALL:
887         return 85;
888 
889     case MONS_BLUE_DEVIL:
890     case MONS_ICE_DEVIL:
891         return 76;
892 
893     case MONS_FLYING_SKULL:
894         return 57;
895 
896     case MONS_SHADOW:
897         return 56;
898 
899     case MONS_SKELETAL_WARRIOR:
900         return 50;
901 
902     case MONS_REAPER:
903         return 47;
904 
905     case MONS_WIGHT:
906     case MONS_WRAITH:
907         return 45;
908 
909     case MONS_ICE_DRAGON:
910         return 38;
911 
912     case MONS_ROTTING_DEVIL:
913     case MONS_TORMENTOR:
914         return 37;
915 
916     case MONS_MUMMY:
917         return 35;
918 
919     case MONS_VAMPIRE:
920         return 34;
921 
922     case MONS_HAIRY_DEVIL:
923     case MONS_HUNGRY_GHOST:
924         return 26;
925 
926     case MONS_NECROPHAGE:
927     case MONS_PHANTOM:
928         return 25;
929 
930     case MONS_SPECTRAL_WARRIOR:
931         return 20;
932 
933     case MONS_SOUL_EATER:
934         return 19;
935 
936     case MONS_LICH:
937     case MONS_SKELETAL_DRAGON:
938     case MONS_SIMULACRUM_LARGE:
939     case MONS_SIMULACRUM_SMALL:
940         return 12;
941 
942     case MONS_ANCIENT_LICH:
943         return 5;
944 
945     default:
946         return 0;
947     }
948 }                               // end mons_cocytus_rare()
949 
mons_tartarus_level(int mcls)950 static int mons_tartarus_level(int mcls)
951 {
952     int mlev = 26;
953 
954     switch (mcls)
955     {
956     case MONS_IMP:
957     case MONS_SKELETON_LARGE:
958     case MONS_RED_DEVIL:
959     case MONS_SHADOW_IMP:
960     case MONS_SKELETAL_WARRIOR:
961     case MONS_SKELETON_SMALL:
962         mlev++;
963         break;
964 
965     case MONS_HELL_KNIGHT:
966     case MONS_NECROPHAGE:
967     case MONS_PHANTOM:
968     case MONS_WIGHT:
969     case MONS_ZOMBIE_LARGE:
970     case MONS_ZOMBIE_SMALL:
971         mlev += 2;
972         break;
973 
974     case MONS_FREEZING_WRAITH:
975     case MONS_HELL_HOUND:
976     case MONS_NECROMANCER:
977     case MONS_SHADOW:
978     case MONS_SHADOW_DEMON:
979     case MONS_WRAITH:
980         mlev += 3;
981         break;
982 
983     case MONS_BLUE_DEVIL:
984     case MONS_FLAYED_GHOST:
985     case MONS_HUNGRY_GHOST:
986     case MONS_ICE_DEVIL:
987     case MONS_MUMMY:
988     case MONS_SKELETAL_DRAGON:
989     case MONS_SPECTRAL_WARRIOR:
990     case MONS_TORMENTOR:
991     case MONS_SIMULACRUM_LARGE:
992     case MONS_SIMULACRUM_SMALL:
993         mlev += 4;
994         break;
995 
996     case MONS_FLYING_SKULL:
997     case MONS_HELLION:
998     case MONS_REAPER:
999     case MONS_ROTTING_DEVIL:
1000     case MONS_SHADOW_DRAGON:
1001     case MONS_VAMPIRE:
1002         mlev += 5;
1003         break;
1004 
1005     case MONS_ANCIENT_LICH:
1006     case MONS_HAIRY_DEVIL:
1007     case MONS_LICH:
1008     case MONS_SOUL_EATER:
1009         mlev += 6;
1010         break;
1011 
1012     default:
1013         return 0;
1014     }
1015 
1016     return (mlev);
1017 }                               // end mons_tartarus_level()
1018 
mons_tartarus_rare(int mcls)1019 static int mons_tartarus_rare(int mcls)
1020 {
1021     switch (mcls)
1022     {
1023     case MONS_SKELETON_LARGE:
1024     case MONS_SHADOW_IMP:
1025     case MONS_SKELETAL_WARRIOR:
1026     case MONS_SKELETON_SMALL:
1027     case MONS_ZOMBIE_LARGE:
1028     case MONS_ZOMBIE_SMALL:
1029         return 99;
1030 
1031     case MONS_SHADOW:
1032         return 92;
1033 
1034     case MONS_REAPER:
1035         return 73;
1036 
1037     case MONS_NECROPHAGE:
1038         return 72;
1039 
1040     case MONS_WIGHT:
1041         return 71;
1042 
1043     case MONS_ROTTING_DEVIL:
1044         return 62;
1045 
1046     case MONS_FREEZING_WRAITH:
1047         return 60;
1048 
1049     case MONS_FLYING_SKULL:
1050         return 53;
1051 
1052     case MONS_HELL_HOUND:
1053     case MONS_PHANTOM:
1054     case MONS_WRAITH:
1055         return 52;
1056 
1057     case MONS_SHADOW_DEMON:
1058         return 50;
1059 
1060     case MONS_SPECTRAL_WARRIOR:
1061         return 45;
1062 
1063     case MONS_VAMPIRE:
1064         return 44;
1065 
1066     case MONS_HELLION:
1067     case MONS_TORMENTOR:
1068         return 42;
1069 
1070     case MONS_SKELETAL_DRAGON:
1071         return 40;
1072 
1073     case MONS_SOUL_EATER:
1074         return 35;
1075 
1076     case MONS_ICE_DEVIL:        // not really appropriate for a fiery hell
1077         return 34;
1078 
1079     case MONS_MUMMY:
1080         return 33;
1081 
1082     case MONS_BLUE_DEVIL:
1083     case MONS_HUNGRY_GHOST:
1084         return 32;
1085 
1086     case MONS_FLAYED_GHOST:
1087     case MONS_HAIRY_DEVIL:
1088         return 30;
1089 
1090     case MONS_LICH:
1091         return 24;
1092 
1093     case MONS_IMP:
1094     case MONS_SHADOW_DRAGON:
1095         return 20;
1096 
1097     case MONS_RED_DEVIL:
1098         return 13;
1099 
1100     case MONS_HELL_KNIGHT:
1101         return 14;
1102 
1103     case MONS_NECROMANCER:
1104     case MONS_SIMULACRUM_LARGE:
1105     case MONS_SIMULACRUM_SMALL:
1106         return 12;
1107 
1108     case MONS_ANCIENT_LICH:
1109         return 6;
1110 
1111     default:
1112         return 0;
1113     }
1114 }
1115 
mons_mineorc_level(int mcls)1116 static int mons_mineorc_level(int mcls)
1117 {
1118     int mlev = you.branch_stairs[STAIRS_ORCISH_MINES] + 1;
1119 
1120     switch (mcls)
1121     {
1122     case MONS_HOBGOBLIN:
1123     case MONS_ORC_PRIEST:
1124     case MONS_ORC_WARRIOR:
1125         mlev++;
1126         break;
1127 
1128     case MONS_GNOLL:
1129     case MONS_OGRE:
1130     case MONS_WARG:
1131     case MONS_ORC_KNIGHT:
1132     case MONS_ORC_WIZARD:
1133         mlev += 2;
1134         break;
1135 
1136     case MONS_CYCLOPS:
1137     case MONS_IRON_TROLL:
1138     case MONS_OGRE_MAGE:
1139     case MONS_ORC_HIGH_PRIEST:
1140     case MONS_ORC_SORCERER:
1141     case MONS_ORC_WARLORD:
1142     case MONS_ROCK_TROLL:
1143     case MONS_STONE_GIANT:
1144     case MONS_TROLL:
1145     case MONS_TWO_HEADED_OGRE:
1146     case MONS_ETTIN:
1147         mlev += 3;
1148         break;
1149 
1150     case MONS_FUNGUS:
1151     case MONS_GOBLIN:
1152     case MONS_ORC:
1153     default:
1154         mlev += 0;
1155     }
1156 
1157     return (mlev);
1158 }                               // end mons_mineorc_level()
1159 
mons_mineorc_rare(int mcls)1160 static int mons_mineorc_rare(int mcls)
1161 {
1162     switch (mcls)
1163     {
1164     case MONS_ORC:
1165         return 300;
1166 
1167     case MONS_GOBLIN:
1168     case MONS_ORC_WARRIOR:
1169         return 30;
1170 
1171     case MONS_HOBGOBLIN:
1172     case MONS_OGRE:
1173         return 20;
1174 
1175     case MONS_TROLL:
1176     case MONS_WARG:
1177         return 13;
1178 
1179     case MONS_FUNGUS:
1180     case MONS_ORC_KNIGHT:
1181     case MONS_ORC_PRIEST:
1182     case MONS_ORC_SORCERER:
1183     case MONS_ORC_WIZARD:
1184         return 10;
1185 
1186     case MONS_ORC_WARLORD:
1187     case MONS_ORC_HIGH_PRIEST:
1188     case MONS_CYCLOPS:
1189     case MONS_TWO_HEADED_OGRE:
1190         return 5;
1191 
1192     case MONS_ETTIN:
1193     case MONS_IRON_TROLL:
1194     case MONS_ROCK_TROLL:
1195     case MONS_STONE_GIANT:
1196         return 3;
1197 
1198     case MONS_GNOLL:
1199         return 2;
1200 
1201     case MONS_OGRE_MAGE:
1202         return 1;
1203 
1204     default:
1205         return 0;
1206     }
1207 }                               // end mons_mineorc_rare()
1208 
mons_hive_level(int mcls)1209 static int mons_hive_level(int mcls)
1210 {
1211     int mlev = you.branch_stairs[STAIRS_HIVE] + 1;
1212 
1213     switch (mcls)
1214     {
1215     case MONS_PLANT:
1216     case MONS_KILLER_BEE:
1217         mlev += 0;
1218         break;
1219 
1220     case MONS_KILLER_BEE_LARVA:
1221         mlev += 2;
1222         break;
1223 
1224     default:
1225         return 99;
1226     }
1227 
1228     return (mlev);
1229 }                               // end mons_hive_level()
1230 
mons_hive_rare(int mcls)1231 static int mons_hive_rare(int mcls)
1232 {
1233     switch (mcls)
1234     {
1235     case MONS_KILLER_BEE:
1236         return 300;
1237 
1238     case MONS_PLANT:
1239         return 100;
1240 
1241     case MONS_KILLER_BEE_LARVA:
1242         return 50;
1243 
1244     default:
1245         return 0;
1246     }
1247 }                               // end mons_hive_rare()
1248 
mons_lair_level(int mcls)1249 static int mons_lair_level(int mcls)
1250 {
1251     int mlev = you.branch_stairs[STAIRS_LAIR] + 1;
1252 
1253     switch (mcls)
1254     {
1255     case MONS_GIANT_GECKO:
1256     case MONS_GIANT_BAT:
1257     case MONS_JACKAL:
1258     case MONS_GIANT_NEWT:
1259     case MONS_RAT:
1260     case MONS_QUOKKA:
1261         mlev += 0;
1262         break;
1263 
1264     case MONS_GIANT_CENTIPEDE:
1265     case MONS_GIANT_IGUANA:
1266         mlev++;
1267         break;
1268 
1269     case MONS_GIANT_FROG:
1270     case MONS_GILA_MONSTER:
1271     case MONS_GREY_RAT:
1272     case MONS_HOUND:
1273     case MONS_BLACK_BEAR:
1274         mlev += 2;
1275         break;
1276 
1277     case MONS_WORM:
1278     case MONS_WOLF:
1279         mlev += 3;
1280         break;
1281 
1282     case MONS_FUNGUS:
1283     case MONS_GIANT_BROWN_FROG:
1284     case MONS_GIANT_LIZARD:
1285     case MONS_GIANT_MITE:
1286     case MONS_GREEN_RAT:
1287     case MONS_SCORPION:
1288     case MONS_SNAKE:
1289         mlev += 4;
1290         break;
1291 
1292     case MONS_BROWN_SNAKE:
1293     case MONS_BUTTERFLY:
1294     case MONS_GIANT_BEETLE:
1295     case MONS_GIANT_SLUG:
1296     case MONS_HIPPOGRIFF:
1297     case MONS_PLANT:
1298     case MONS_SPINY_FROG:
1299     case MONS_WAR_DOG:
1300     case MONS_YELLOW_WASP:
1301     case MONS_BEAR:
1302         mlev += 5;
1303         break;
1304 
1305     case MONS_BLINK_FROG:
1306     case MONS_GIANT_SNAIL:
1307     case MONS_GIANT_SPORE:
1308     case MONS_KOMODO_DRAGON:
1309     case MONS_ORANGE_RAT:
1310     case MONS_SHEEP:
1311     case MONS_STEAM_DRAGON:
1312     case MONS_WOLF_SPIDER:
1313     case MONS_YAK:
1314     case MONS_GRIZZLY_BEAR:
1315         mlev += 6;
1316         break;
1317 
1318     case MONS_BLACK_SNAKE:
1319     case MONS_BRAIN_WORM:
1320     case MONS_BUMBLEBEE:
1321     case MONS_FIREDRAKE:
1322     case MONS_HYDRA:
1323     case MONS_OKLOB_PLANT:
1324     case MONS_WYVERN:
1325         mlev += 7;
1326         break;
1327 
1328     case MONS_ELEPHANT_SLUG:
1329     case MONS_POLAR_BEAR:
1330     case MONS_GRIFFON:
1331     case MONS_LINDWURM:
1332     case MONS_REDBACK:
1333     case MONS_WANDERING_MUSHROOM:
1334         mlev += 8;
1335         break;
1336 
1337     case MONS_BORING_BEETLE:
1338     case MONS_BOULDER_BEETLE:
1339     case MONS_DEATH_YAK:
1340     case MONS_SPINY_WORM:
1341         mlev += 9;
1342         break;
1343 
1344     default:
1345         return 99;
1346     }
1347 
1348     return (mlev);
1349 }                               // end mons_lair_level()
1350 
mons_lair_rare(int mcls)1351 static int mons_lair_rare(int mcls)
1352 {
1353     switch (mcls)
1354     {
1355     case MONS_RAT:
1356         return 200;
1357 
1358     case MONS_GIANT_BAT:
1359     case MONS_GIANT_BROWN_FROG:
1360     case MONS_GIANT_FROG:
1361     case MONS_GREY_RAT:
1362     case MONS_QUOKKA:
1363         return 99;
1364 
1365     case MONS_BROWN_SNAKE:
1366     case MONS_GIANT_LIZARD:
1367         return 90;
1368 
1369     case MONS_PLANT:
1370     case MONS_SNAKE:
1371         return 80;
1372 
1373     case MONS_SPINY_FROG:
1374         return 75;
1375 
1376     case MONS_JACKAL:
1377     case MONS_GIANT_IGUANA:
1378     case MONS_GILA_MONSTER:
1379         return 70;
1380 
1381     case MONS_GREEN_RAT:
1382         return 64;
1383 
1384     case MONS_HOUND:
1385         return 60;
1386 
1387     case MONS_GIANT_SNAIL:
1388         return 56;
1389 
1390     case MONS_GIANT_SLUG:
1391         return 55;
1392 
1393     case MONS_FUNGUS:
1394     case MONS_GIANT_GECKO:
1395     case MONS_GIANT_CENTIPEDE:
1396     case MONS_HIPPOGRIFF:
1397     case MONS_HYDRA:
1398     case MONS_KOMODO_DRAGON:
1399     case MONS_YAK:
1400         return 50;
1401 
1402     case MONS_BLACK_SNAKE:
1403         return 47;
1404 
1405     case MONS_BLINK_FROG:
1406         return 45;
1407 
1408     case MONS_SHEEP:
1409     case MONS_FIREDRAKE:
1410         return 36;
1411 
1412     case MONS_WAR_DOG:
1413         return 35;
1414 
1415     case MONS_WORM:
1416     case MONS_GIANT_MITE:
1417     case MONS_GRIFFON:
1418     case MONS_DEATH_YAK:
1419     case MONS_ELEPHANT_SLUG:
1420         return 30;
1421 
1422     case MONS_BORING_BEETLE:
1423         return 29;
1424 
1425     case MONS_BOULDER_BEETLE:
1426     case MONS_GIANT_NEWT:
1427     case MONS_WOLF:
1428     case MONS_WYVERN:
1429         return 20;
1430 
1431     case MONS_BLACK_BEAR:
1432     case MONS_BEAR:
1433     case MONS_GRIZZLY_BEAR:
1434     case MONS_POLAR_BEAR:
1435         return 15;
1436 
1437     case MONS_GIANT_BEETLE:
1438     case MONS_SCORPION:
1439     case MONS_OKLOB_PLANT:
1440     case MONS_STEAM_DRAGON:
1441     case MONS_LINDWURM:
1442     case MONS_ORANGE_RAT:
1443         return 10;
1444 
1445     case MONS_SPINY_WORM:
1446         return 9;
1447 
1448     case MONS_WANDERING_MUSHROOM:
1449     case MONS_REDBACK:
1450         return 8;
1451 
1452     case MONS_BRAIN_WORM:
1453     case MONS_BUMBLEBEE:
1454         return 7;
1455 
1456     case MONS_WOLF_SPIDER:
1457         return 6;
1458 
1459     case MONS_YELLOW_WASP:
1460     case MONS_BUTTERFLY:
1461         return 5;
1462 
1463     case MONS_GIANT_SPORE:
1464         return 2;
1465 
1466     default:
1467         return 0;
1468     }
1469 }                               // end mons_lair_rare()
1470 
mons_pitslime_level(int mcls)1471 static int mons_pitslime_level(int mcls)
1472 {
1473     int mlev = you.branch_stairs[STAIRS_SLIME_PITS] + 1;
1474 
1475 
1476     switch (mcls)
1477     {
1478     case MONS_JELLY:
1479     case MONS_OOZE:
1480     case MONS_ACID_BLOB:
1481     case MONS_GIANT_SPORE:
1482     case MONS_GIANT_EYEBALL:
1483         mlev++;
1484         break;
1485 
1486     case MONS_BROWN_OOZE:
1487     case MONS_SLIME_CREATURE:
1488     case MONS_EYE_OF_DRAINING:
1489         mlev += 2;
1490         break;
1491 
1492     case MONS_GIANT_AMOEBA:
1493     case MONS_AZURE_JELLY:
1494     case MONS_SHINING_EYE:
1495         mlev += 3;
1496         break;
1497 
1498     case MONS_PULSATING_LUMP:
1499     case MONS_GREAT_ORB_OF_EYES:
1500     case MONS_EYE_OF_DEVASTATION:
1501         mlev += 4;
1502         break;
1503 
1504     case MONS_DEATH_OOZE:
1505     case MONS_TENTACLED_MONSTROSITY:
1506     case MONS_GIANT_ORANGE_BRAIN:
1507         mlev += 5;
1508         break;
1509 
1510     default:
1511         mlev += 0;
1512         break;
1513     }
1514 
1515     return (mlev);
1516 }                               // end mons_pitslime_level()
1517 
mons_pitslime_rare(int mcls)1518 static int mons_pitslime_rare(int mcls)
1519 {
1520     switch (mcls)
1521     {
1522     case MONS_JELLY:
1523         return 300;
1524 
1525     case MONS_SLIME_CREATURE:
1526         return 200;
1527 
1528     case MONS_BROWN_OOZE:
1529         return 150;
1530 
1531     case MONS_GIANT_AMOEBA:
1532     case MONS_ACID_BLOB:
1533         return 100;
1534 
1535     case MONS_OOZE:
1536     case MONS_AZURE_JELLY:
1537     case MONS_GIANT_SPORE:
1538     case MONS_GIANT_EYEBALL:
1539     case MONS_EYE_OF_DRAINING:
1540     case MONS_SHINING_EYE:
1541         return 50;
1542 
1543     case MONS_DEATH_OOZE:
1544     case MONS_GREAT_ORB_OF_EYES:
1545     case MONS_EYE_OF_DEVASTATION:
1546         return 30;
1547 
1548     case MONS_PULSATING_LUMP:
1549     case MONS_GIANT_ORANGE_BRAIN:
1550         return 20;
1551 
1552     case MONS_TENTACLED_MONSTROSITY:
1553         return 2;
1554 
1555     default:
1556         return 0;
1557     }
1558 }                               // end mons_pitslime_rare()
1559 
mons_crypt_level(int mcls)1560 static int mons_crypt_level(int mcls)
1561 {
1562     int mlev = you.branch_stairs[STAIRS_CRYPT] + 1;
1563 
1564     switch (mcls)
1565     {
1566     case MONS_ZOMBIE_SMALL:
1567         mlev += 0;
1568         break;
1569 
1570     case MONS_PHANTOM:
1571     case MONS_SKELETON_SMALL:
1572     case MONS_SKELETON_LARGE:
1573     case MONS_ZOMBIE_LARGE:
1574     case MONS_WIGHT:
1575         mlev++;
1576         break;
1577 
1578     case MONS_SHADOW:
1579     case MONS_HUNGRY_GHOST:
1580     case MONS_NECROPHAGE:
1581     case MONS_SKELETAL_WARRIOR:
1582     case MONS_SIMULACRUM_SMALL:
1583     case MONS_SIMULACRUM_LARGE:
1584         mlev += 2;
1585         break;
1586 
1587     case MONS_NECROMANCER:
1588     case MONS_PULSATING_LUMP:
1589     case MONS_FLAYED_GHOST:
1590     case MONS_GHOUL:
1591     case MONS_ROTTING_HULK:
1592     case MONS_WRAITH:
1593     case MONS_FLYING_SKULL:
1594         mlev += 3;
1595         break;
1596 
1597     case MONS_SPECTRAL_WARRIOR:
1598     case MONS_SHADOW_WRAITH:
1599     case MONS_VAMPIRE_KNIGHT:
1600     case MONS_VAMPIRE_MAGE:
1601     case MONS_SKELETAL_DRAGON:
1602     case MONS_ABOMINATION_SMALL:
1603     case MONS_MUMMY:
1604     case MONS_VAMPIRE:
1605     case MONS_ABOMINATION_LARGE:
1606         mlev += 4;
1607         break;
1608 
1609     case MONS_REAPER:
1610     case MONS_ANCIENT_LICH:
1611     case MONS_LICH:
1612         mlev += 5;
1613         break;
1614 
1615     default:
1616         mlev += 99;
1617     }
1618 
1619     return (mlev);
1620 }                               // end mons_crypt_level()
1621 
mons_crypt_rare(int mcls)1622 static int mons_crypt_rare(int mcls)
1623 {
1624     switch (mcls)
1625     {
1626     case MONS_ZOMBIE_SMALL:
1627     case MONS_SKELETON_SMALL:
1628     case MONS_SKELETON_LARGE:
1629         return 410;
1630 
1631     case MONS_ZOMBIE_LARGE:
1632         return 300;
1633 
1634     case MONS_SKELETAL_WARRIOR:
1635         return 75;
1636 
1637     case MONS_NECROPHAGE:
1638         return 50;
1639 
1640     case MONS_WIGHT:
1641         return 35;
1642 
1643     case MONS_WRAITH:
1644         return 33;
1645 
1646     case MONS_SHADOW:
1647         return 30;
1648 
1649     case MONS_NECROMANCER:
1650     case MONS_GHOUL:
1651         return 25;
1652 
1653     case MONS_MUMMY:
1654     case MONS_SKELETAL_DRAGON:
1655         return 24;
1656 
1657     case MONS_VAMPIRE:
1658     case MONS_PHANTOM:
1659         return 21;
1660 
1661     case MONS_VAMPIRE_KNIGHT:
1662     case MONS_VAMPIRE_MAGE:
1663         return 20;
1664 
1665     case MONS_ROTTING_HULK:
1666         return 17;
1667 
1668     case MONS_SPECTRAL_WARRIOR:
1669         return 14;
1670 
1671     case MONS_FLYING_SKULL:
1672     case MONS_FLAYED_GHOST:
1673         return 13;
1674 
1675     case MONS_HUNGRY_GHOST:
1676         return 12;
1677 
1678     case MONS_SHADOW_WRAITH:
1679     case MONS_SIMULACRUM_SMALL:
1680     case MONS_SIMULACRUM_LARGE:
1681         return 10;
1682 
1683     case MONS_ANCIENT_LICH:
1684         return 8;
1685 
1686     case MONS_ABOMINATION_SMALL:
1687     case MONS_LICH:
1688     case MONS_REAPER:
1689         return 5;
1690 
1691     case MONS_ABOMINATION_LARGE:
1692         return 4;
1693 
1694     case MONS_PULSATING_LUMP:
1695         return 3;
1696 
1697     default:
1698         return 0;
1699     }
1700 }                               // end mons_crypt_rare()
1701 
mons_pitsnake_level(int mcls)1702 static int mons_pitsnake_level(int mcls)
1703 {
1704     int mlev = you.branch_stairs[STAIRS_SNAKE_PIT] + 1;
1705 
1706     switch (mcls)
1707     {
1708     case MONS_SMALL_SNAKE:
1709     case MONS_SNAKE:
1710         mlev++;
1711         break;
1712 
1713     case MONS_BROWN_SNAKE:
1714     case MONS_BLACK_SNAKE:
1715     case MONS_YELLOW_SNAKE:
1716     case MONS_GREY_SNAKE:
1717     case MONS_NAGA:
1718         mlev += 2;
1719         break;
1720 
1721     case MONS_NAGA_WARRIOR:
1722     case MONS_NAGA_MAGE:
1723         mlev += 3;
1724         break;
1725 
1726     case MONS_GUARDIAN_NAGA:
1727         mlev += 4;
1728         break;
1729 
1730     case MONS_GREATER_NAGA:
1731         mlev += 5;
1732         break;
1733 
1734     default:
1735         mlev += 99;
1736     }
1737 
1738     return (mlev);
1739 }                               // end mons_pitsnake_level()
1740 
mons_pitsnake_rare(int mcls)1741 static int mons_pitsnake_rare(int mcls)
1742 {
1743     switch (mcls)
1744     {
1745     case MONS_SNAKE:
1746     case MONS_BROWN_SNAKE:
1747         return 99;
1748 
1749     case MONS_BLACK_SNAKE:
1750         return 72;
1751 
1752     case MONS_NAGA:
1753         return 53;
1754 
1755     case MONS_NAGA_WARRIOR:
1756     case MONS_NAGA_MAGE:
1757         return 34;
1758 
1759     case MONS_YELLOW_SNAKE:
1760     case MONS_GREY_SNAKE:
1761         return 32;
1762 
1763     case MONS_GREATER_NAGA:
1764     case MONS_GUARDIAN_NAGA:
1765     case MONS_SMALL_SNAKE:
1766         return 15;
1767 
1768     default:
1769         return 0;
1770     }
1771 }                               // end mons_pitsnake_rare()
1772 
mons_hallelf_level(int mcls)1773 static int mons_hallelf_level(int mcls)
1774 {
1775     int mlev = you.branch_stairs[STAIRS_ELVEN_HALLS] + 1;
1776 
1777     switch (mcls)
1778     {
1779     case MONS_DEEP_ELF_SOLDIER:
1780     case MONS_DEEP_ELF_FIGHTER:
1781     case MONS_ORC:
1782     case MONS_ORC_WARRIOR:
1783         mlev++;
1784         break;
1785 
1786     case MONS_ORC_WIZARD:
1787     case MONS_DEEP_ELF_MAGE:
1788     case MONS_DEEP_ELF_SUMMONER:
1789         mlev += 2;
1790         break;
1791 
1792     case MONS_FUNGUS:
1793     case MONS_DEEP_ELF_CONJURER:
1794     case MONS_SHAPESHIFTER:
1795     case MONS_ORC_KNIGHT:
1796         mlev += 3;
1797         break;
1798 
1799     case MONS_ORC_SORCERER:
1800     case MONS_DEEP_ELF_PRIEST:
1801     case MONS_GLOWING_SHAPESHIFTER:
1802     case MONS_DEEP_ELF_KNIGHT:
1803         mlev += 4;
1804         break;
1805 
1806     case MONS_ORC_PRIEST:
1807     case MONS_ORC_HIGH_PRIEST:
1808         mlev += 5;
1809         break;
1810 
1811     case MONS_DEEP_ELF_HIGH_PRIEST:
1812     case MONS_DEEP_ELF_DEMONOLOGIST:
1813     case MONS_DEEP_ELF_ANNIHILATOR:
1814     case MONS_DEEP_ELF_SORCERER:
1815     case MONS_DEEP_ELF_DEATH_MAGE:
1816         mlev += 7;
1817         break;
1818 
1819     default:
1820         mlev += 99;
1821         break;
1822     }
1823 
1824     return (mlev);
1825 }                               // end mons_hallelf_level()
1826 
mons_hallelf_rare(int mcls)1827 static int mons_hallelf_rare(int mcls)
1828 {
1829     switch (mcls)
1830     {
1831     case MONS_FUNGUS:
1832         return 300;
1833 
1834     case MONS_DEEP_ELF_SOLDIER:
1835     case MONS_DEEP_ELF_FIGHTER:
1836     case MONS_DEEP_ELF_MAGE:
1837         return 100;
1838 
1839     case MONS_DEEP_ELF_KNIGHT:
1840         return 80;
1841 
1842     case MONS_DEEP_ELF_SUMMONER:
1843         return 72;
1844 
1845     case MONS_DEEP_ELF_CONJURER:
1846         return 63;
1847 
1848     case MONS_DEEP_ELF_PRIEST:
1849         return 44;
1850 
1851     case MONS_SHAPESHIFTER:
1852         return 25;
1853 
1854     case MONS_ORC:
1855         return 20;
1856 
1857     case MONS_DEEP_ELF_DEMONOLOGIST:
1858     case MONS_DEEP_ELF_SORCERER:
1859         return 17;
1860 
1861     case MONS_DEEP_ELF_ANNIHILATOR:
1862     case MONS_DEEP_ELF_DEATH_MAGE:
1863     case MONS_ORC_WIZARD:
1864         return 13;
1865 
1866     case MONS_ORC_WARRIOR:
1867         return 11;
1868 
1869     case MONS_DEEP_ELF_HIGH_PRIEST:
1870     case MONS_ORC_SORCERER:
1871     case MONS_GLOWING_SHAPESHIFTER:
1872         return 10;
1873 
1874     case MONS_ORC_KNIGHT:
1875     case MONS_ORC_PRIEST:
1876     case MONS_ORC_HIGH_PRIEST:
1877         return 5;
1878 
1879     default:
1880         return 0;
1881     }
1882 }                               // end mons_hallelf_rare()
1883 
mons_tomb_level(int mcls)1884 static int mons_tomb_level(int mcls)
1885 {
1886     int mlev = you.branch_stairs[STAIRS_CRYPT] + 1;
1887 
1888     switch (mcls)
1889     {
1890     case MONS_ZOMBIE_SMALL:
1891         mlev += 0;
1892         break;
1893 
1894     case MONS_MUMMY:
1895     case MONS_ZOMBIE_LARGE:
1896     case MONS_SKELETON_SMALL:
1897     case MONS_SKELETON_LARGE:
1898         mlev++;
1899         break;
1900 
1901     case MONS_GUARDIAN_MUMMY:
1902     case MONS_FLYING_SKULL:
1903     case MONS_SIMULACRUM_SMALL:
1904     case MONS_SIMULACRUM_LARGE:
1905         mlev += 2;
1906         break;
1907 
1908     case MONS_LICH:
1909     case MONS_ANCIENT_LICH:
1910     case MONS_MUMMY_PRIEST:
1911         mlev += 3;
1912         break;
1913 
1914     default:
1915         mlev += 99;
1916     }
1917 
1918     return (mlev);
1919 }                               // end mons_tomb_level()
1920 
mons_tomb_rare(int mcls)1921 static int mons_tomb_rare(int mcls)
1922 {
1923     switch (mcls)
1924     {
1925     case MONS_MUMMY:
1926         return 300;
1927 
1928     case MONS_GUARDIAN_MUMMY:
1929         return 202;
1930 
1931     case MONS_MUMMY_PRIEST:
1932         return 40;
1933 
1934     case MONS_FLYING_SKULL:
1935         return 33;
1936 
1937     case MONS_ZOMBIE_LARGE:
1938     case MONS_SKELETON_SMALL:
1939     case MONS_SKELETON_LARGE:
1940         return 21;
1941 
1942     case MONS_ZOMBIE_SMALL:
1943         return 20;
1944 
1945     case MONS_SIMULACRUM_SMALL:
1946     case MONS_SIMULACRUM_LARGE:
1947         return 10;
1948 
1949     case MONS_LICH:
1950         return 4;
1951 
1952     case MONS_ANCIENT_LICH:
1953         return 2;
1954 
1955     default:
1956         return 0;
1957     }
1958 }                               // end mons_tomb_rare()
1959 
mons_swamp_level(int mcls)1960 static int mons_swamp_level(int mcls)
1961 {
1962     int mlev = you.branch_stairs[STAIRS_SWAMP] + 1;
1963 
1964     switch (mcls)
1965     {
1966     case MONS_GIANT_BAT:
1967     case MONS_GIANT_BLOWFLY:
1968     case MONS_GIANT_FROG:
1969     case MONS_GIANT_AMOEBA:
1970     case MONS_GIANT_SLUG:
1971     case MONS_GIANT_NEWT:
1972     case MONS_GIANT_GECKO:
1973     case MONS_RAT:
1974     case MONS_SWAMP_DRAKE:
1975     case MONS_WORM:
1976         mlev++;
1977         break;
1978 
1979     case MONS_GIANT_BROWN_FROG:
1980     case MONS_FUNGUS:
1981     case MONS_NECROPHAGE:
1982     case MONS_PLANT:
1983     case MONS_SNAKE:
1984     case MONS_BUTTERFLY:
1985     case MONS_GIANT_LIZARD:
1986     case MONS_GIANT_MOSQUITO:
1987     case MONS_GIANT_SNAIL:
1988     case MONS_HYDRA:
1989         mlev += 2;
1990         break;
1991 
1992     case MONS_BROWN_SNAKE:
1993     case MONS_HUNGRY_GHOST:
1994     case MONS_INSUBSTANTIAL_WISP:
1995     case MONS_JELLY:
1996     case MONS_KOMODO_DRAGON:
1997     case MONS_PHANTOM:
1998     case MONS_RED_WASP:
1999     case MONS_SPINY_FROG:
2000     case MONS_SWAMP_DRAGON:
2001     case MONS_UGLY_THING:
2002         mlev += 3;
2003         break;
2004 
2005     case MONS_BLINK_FROG:
2006     case MONS_SLIME_CREATURE:
2007     case MONS_VERY_UGLY_THING:
2008     case MONS_VAPOUR:
2009     case MONS_TENTACLED_MONSTROSITY:
2010         mlev += 4;
2011         break;
2012 
2013     default:
2014         mlev += 99;
2015     }
2016 
2017     return (mlev);
2018 }                               // end mons_swamp_level()
2019 
mons_swamp_rare(int mcls)2020 static int mons_swamp_rare(int mcls)
2021 {
2022     switch (mcls)
2023     {
2024     case MONS_GIANT_MOSQUITO:
2025         return 250;
2026 
2027     case MONS_PLANT:
2028         return 200;
2029 
2030     case MONS_GIANT_FROG:
2031         return 150;
2032 
2033     case MONS_GIANT_BLOWFLY:
2034         return 100;
2035 
2036     case MONS_GIANT_BAT:
2037     case MONS_FUNGUS:
2038         return 99;
2039 
2040     case MONS_GIANT_BROWN_FROG:
2041         return 90;
2042 
2043     case MONS_SWAMP_DRAKE:
2044         return 80;
2045 
2046     case MONS_HYDRA:
2047         return 70;
2048 
2049     case MONS_RAT:
2050         return 61;
2051 
2052     case MONS_SLIME_CREATURE:
2053         return 54;
2054 
2055     case MONS_SNAKE:
2056         return 52;
2057 
2058     case MONS_INSUBSTANTIAL_WISP:
2059         return 43;
2060 
2061     case MONS_BROWN_SNAKE:
2062         return 33;
2063 
2064     case MONS_RED_WASP:
2065     case MONS_SWAMP_DRAGON:
2066     case MONS_SPINY_FROG:
2067         return 30;
2068 
2069     case MONS_JELLY:
2070     case MONS_BUTTERFLY:
2071     case MONS_GIANT_LIZARD:
2072         return 25;
2073 
2074     case MONS_WORM:
2075         return 20;
2076 
2077     case MONS_KOMODO_DRAGON:
2078     case MONS_VERY_UGLY_THING:
2079     case MONS_VAPOUR:
2080         return 15;
2081 
2082     case MONS_PHANTOM:
2083     case MONS_UGLY_THING:
2084     case MONS_HUNGRY_GHOST:
2085         return 13;
2086 
2087     case MONS_NECROPHAGE:
2088         return 12;
2089 
2090     case MONS_BLINK_FROG:
2091     case MONS_GIANT_AMOEBA:
2092     case MONS_GIANT_GECKO:
2093     case MONS_GIANT_NEWT:
2094     case MONS_GIANT_SLUG:
2095     case MONS_GIANT_SNAIL:
2096         return 10;
2097 
2098     case MONS_TENTACLED_MONSTROSITY:
2099         return 5;
2100 
2101     default:
2102         return 0;
2103     }
2104 }                               // end mons_swamp_rare()
2105 
mons_hallblade_level(int mcls)2106 static int mons_hallblade_level(int mcls)
2107 {
2108     if (mcls == MONS_DANCING_WEAPON)
2109         return (you.branch_stairs[STAIRS_HALL_OF_BLADES] + 1);
2110     else
2111         return 0;
2112 }                               // end mons_hallblade_level
2113 
mons_hallblade_rare(int mcls)2114 static int mons_hallblade_rare(int mcls)
2115 {
2116     return ((mcls == MONS_DANCING_WEAPON) ? 1000 : 0);
2117 }                               // end mons_hallblade_rare()
2118 
2119 //    New branch must be added in:
2120 //    - new_game stair location
2121 //    - down/up stairs (to and back) misc.cc
2122 //    - new_level (2 places) (misc.cc)
2123 //    - item_check items.cc
2124 //    - look_around (direct.cc)
2125 //    - ouch ouch.cc (death message)
2126 //    - and here...
2127 
mons_hallzot_level(int mcls)2128 static int mons_hallzot_level(int mcls)
2129 {
2130     int mlev = you.branch_stairs[STAIRS_HALL_OF_ZOT];
2131 
2132     switch (mcls)
2133     {
2134     case MONS_GOLDEN_DRAGON:
2135     case MONS_GUARDIAN_MUMMY:
2136         mlev += 6;
2137         break;
2138     case MONS_KILLER_KLOWN:
2139     case MONS_SHADOW_DRAGON:
2140     case MONS_SKELETAL_DRAGON:
2141     case MONS_STORM_DRAGON:
2142         mlev += 5;
2143         break;
2144     case MONS_DEATH_COB:
2145     case MONS_DRAGON:
2146     case MONS_ICE_DRAGON:
2147         mlev += 4;
2148         break;
2149     case MONS_DEEP_ELF_ANNIHILATOR:
2150     case MONS_DEEP_ELF_DEATH_MAGE:
2151     case MONS_DEEP_ELF_DEMONOLOGIST:
2152     case MONS_DEEP_ELF_HIGH_PRIEST:
2153     case MONS_DEEP_ELF_SORCERER:
2154     case MONS_TENTACLED_MONSTROSITY:
2155         mlev += 3;
2156         break;
2157     case MONS_MOTH_OF_WRATH:
2158         mlev += 2;
2159         break;
2160     case MONS_ORB_OF_FIRE:
2161     case MONS_ELECTRIC_GOLEM:
2162         mlev += 1;
2163         break;
2164     default:
2165         mlev += 99;             // I think this won't be a problem {dlb}
2166         break;
2167     }
2168 
2169     return (mlev);
2170 }                               // end mons_hallzot_level()
2171 
mons_hallzot_rare(int mcls)2172 static int mons_hallzot_rare(int mcls)
2173 {
2174     switch (mcls)
2175     {
2176     case MONS_MOTH_OF_WRATH:
2177         return 88;
2178     case MONS_STORM_DRAGON:
2179     case MONS_TENTACLED_MONSTROSITY:
2180         return 50;
2181     case MONS_GOLDEN_DRAGON:
2182         return 42;
2183     case MONS_DEATH_COB:
2184     case MONS_DRAGON:
2185     case MONS_ICE_DRAGON:
2186     case MONS_SKELETAL_DRAGON:
2187         return 40;
2188     case MONS_SHADOW_DRAGON:
2189         return 30;
2190     case MONS_DEEP_ELF_ANNIHILATOR:
2191     case MONS_DEEP_ELF_DEATH_MAGE:
2192     case MONS_DEEP_ELF_DEMONOLOGIST:
2193     case MONS_DEEP_ELF_HIGH_PRIEST:
2194     case MONS_DEEP_ELF_SORCERER:
2195         return 29;
2196     case MONS_GUARDIAN_MUMMY:
2197     case MONS_ELECTRIC_GOLEM:
2198         return 20;
2199     case MONS_KILLER_KLOWN:
2200     case MONS_ORB_OF_FIRE:
2201         return 15;
2202     default:
2203         return 0;
2204     }
2205 }                               // end mons_hallzot_rare()
2206 
mons_standard_level(int mcls)2207 static int mons_standard_level(int mcls)
2208 {
2209     switch (mcls)
2210     {
2211     case MONS_GOBLIN:
2212     case MONS_GIANT_NEWT:
2213         return 1;
2214 
2215     case MONS_GIANT_COCKROACH:
2216     case MONS_OOZE:
2217     case MONS_SMALL_SNAKE:
2218         return 2;
2219 
2220     case MONS_GIANT_BAT:
2221     case MONS_KOBOLD:
2222     case MONS_RAT:
2223         return 4;
2224 
2225     case MONS_GIANT_GECKO:
2226     case MONS_GIANT_MITE:
2227     case MONS_GNOLL:
2228     case MONS_HOBGOBLIN:
2229     case MONS_JACKAL:
2230     case MONS_KILLER_BEE_LARVA:
2231         return 5;
2232 
2233     case MONS_WORM:
2234     case MONS_SNAKE:
2235     case MONS_QUOKKA:
2236         return 6;
2237 
2238     case MONS_ORC:
2239         return 7;
2240 
2241     case MONS_FUNGUS:
2242     case MONS_GIANT_ANT:
2243     case MONS_GIANT_EYEBALL:
2244     case MONS_HOUND:
2245     case MONS_GIANT_IGUANA:
2246     case MONS_OGRE:
2247     case MONS_ORC_WIZARD:
2248     case MONS_PHANTOM:
2249     case MONS_SCORPION:
2250         return 8;
2251 
2252     case MONS_BROWN_SNAKE:
2253     case MONS_CENTAUR:
2254     case MONS_ICE_BEAST:
2255     case MONS_IMP:
2256     case MONS_JELLY:
2257     case MONS_NECROPHAGE:
2258     case MONS_QUASIT:
2259     case MONS_ZOMBIE_SMALL:
2260         return 9;
2261 
2262     case MONS_DEEP_ELF_SOLDIER:
2263     case MONS_GIANT_BEETLE:
2264     case MONS_GIANT_FROG:
2265     case MONS_GIANT_SPORE:
2266     case MONS_MUMMY:
2267     case MONS_ORC_WARRIOR:
2268     case MONS_STEAM_DRAGON:
2269     case MONS_WIGHT:
2270         return 10;
2271 
2272     case MONS_GIANT_LIZARD:
2273     case MONS_HIPPOGRIFF:
2274     case MONS_HUNGRY_GHOST:
2275     case MONS_KILLER_BEE:
2276     case MONS_SHADOW:
2277     case MONS_YELLOW_WASP:
2278         return 11;
2279 
2280     case MONS_EYE_OF_DRAINING:
2281     case MONS_GILA_MONSTER:
2282     case MONS_MANTICORE:
2283     case MONS_PLANT:
2284     case MONS_UNSEEN_HORROR:
2285     case MONS_WYVERN:
2286         return 12;
2287 
2288     case MONS_BIG_KOBOLD:
2289     case MONS_GIANT_BROWN_FROG:
2290     case MONS_GIANT_CENTIPEDE:
2291     case MONS_OKLOB_PLANT:
2292     case MONS_TROLL:
2293     case MONS_TWO_HEADED_OGRE:
2294     case MONS_WOOD_GOLEM:
2295     case MONS_YAK:
2296         return 13;
2297 
2298     case MONS_HILL_GIANT:
2299     case MONS_KOMODO_DRAGON:
2300     case MONS_SOLDIER_ANT:
2301     case MONS_WOLF_SPIDER:
2302     case MONS_WRAITH:
2303         return 14;
2304 
2305     case MONS_ARMOUR_MIMIC:
2306     case MONS_BRAIN_WORM:
2307     case MONS_CYCLOPS:
2308     case MONS_EFREET:
2309     case MONS_ETTIN:
2310     case MONS_EYE_OF_DEVASTATION:
2311     case MONS_GOLD_MIMIC:
2312     case MONS_HYDRA:
2313     case MONS_MOTTLED_DRAGON:
2314     case MONS_ORC_PRIEST:
2315     case MONS_POTION_MIMIC:
2316     case MONS_SCROLL_MIMIC:
2317     case MONS_SKELETAL_WARRIOR:
2318     case MONS_WEAPON_MIMIC:
2319         return 15;
2320 
2321     case MONS_BLINK_FROG:
2322     case MONS_BUTTERFLY:
2323     case MONS_GIANT_BLOWFLY:
2324     case MONS_GUARDIAN_NAGA:
2325     case MONS_RAKSHASA:
2326     case MONS_SLIME_CREATURE:
2327     case MONS_STONE_GOLEM:
2328     case MONS_VAMPIRE:
2329     case MONS_WANDERING_MUSHROOM:
2330     case MONS_ZOMBIE_LARGE:
2331         return 16;
2332 
2333     case MONS_BOGGART:
2334     case MONS_CENTAUR_WARRIOR:
2335     case MONS_CLAY_GOLEM:
2336     case MONS_GRIFFON:
2337     case MONS_SHAPESHIFTER:
2338     case MONS_UGLY_THING:
2339     case MONS_WIZARD:
2340     case MONS_SIMULACRUM_SMALL:
2341     case MONS_SIMULACRUM_LARGE:
2342         return 17;
2343 
2344     case MONS_DRAGON:
2345     case MONS_GARGOYLE:
2346     case MONS_GIANT_AMOEBA:
2347     case MONS_KOBOLD_DEMONOLOGIST:
2348         return 18;
2349 
2350     case MONS_GIANT_SLUG:
2351     case MONS_IRON_GOLEM:
2352     case MONS_OGRE_MAGE:
2353     case MONS_ROCK_TROLL:
2354     case MONS_TOENAIL_GOLEM:
2355     case MONS_YAKTAUR:
2356         return 19;
2357 
2358     case MONS_AIR_ELEMENTAL:
2359     case MONS_DEEP_ELF_FIGHTER:
2360     case MONS_DEEP_ELF_KNIGHT:
2361     case MONS_DEEP_ELF_MAGE:
2362     case MONS_DEEP_ELF_SUMMONER:
2363     case MONS_EARTH_ELEMENTAL:
2364     case MONS_FIRE_ELEMENTAL:
2365     case MONS_GIANT_ORANGE_BRAIN:
2366     case MONS_GIANT_SNAIL:
2367     case MONS_GREAT_ORB_OF_EYES:
2368     case MONS_ICE_DRAGON:
2369     case MONS_SKELETON_LARGE:
2370     case MONS_NAGA_MAGE:
2371     case MONS_NAGA_WARRIOR:
2372     case MONS_NECROMANCER:
2373     case MONS_ORC_KNIGHT:
2374     case MONS_QUEEN_BEE:
2375     case MONS_RED_WASP:
2376     case MONS_SHADOW_WRAITH:
2377     case MONS_SKELETON_SMALL:
2378     case MONS_SPINY_WORM:
2379     case MONS_VERY_UGLY_THING:
2380         return 20;
2381 
2382     case MONS_BOULDER_BEETLE:
2383     case MONS_ORC_HIGH_PRIEST:
2384     case MONS_PULSATING_LUMP:
2385         return 21;
2386 
2387     case MONS_BORING_BEETLE:
2388     case MONS_CRYSTAL_GOLEM:
2389     case MONS_FLAYED_GHOST:
2390     case MONS_FREEZING_WRAITH:
2391     case MONS_REDBACK:
2392     case MONS_SPHINX:
2393     case MONS_VAPOUR:
2394         return 22;
2395 
2396     case MONS_ORC_SORCERER:
2397     case MONS_SHINING_EYE:
2398         return 23;
2399 
2400     case MONS_BUMBLEBEE:
2401     case MONS_ORC_WARLORD:
2402     case MONS_IRON_TROLL:
2403     case MONS_YAKTAUR_CAPTAIN:
2404         return 24;
2405 
2406     case MONS_DANCING_WEAPON:
2407     case MONS_DEEP_TROLL:
2408     case MONS_FIRE_GIANT:
2409     case MONS_FROST_GIANT:
2410     case MONS_HELL_KNIGHT:
2411     case MONS_INSUBSTANTIAL_WISP:
2412     case MONS_LICH:
2413     case MONS_STONE_GIANT:
2414         return 25;
2415 
2416     case MONS_DEEP_ELF_CONJURER:
2417     case MONS_SPECTRAL_WARRIOR:
2418     case MONS_STORM_DRAGON:
2419         return 26;
2420 
2421     case MONS_DEEP_ELF_PRIEST:
2422     case MONS_GLOWING_SHAPESHIFTER:
2423     case MONS_TENTACLED_MONSTROSITY:
2424         return 27;
2425 
2426     case MONS_ANCIENT_LICH:
2427     case MONS_DEEP_ELF_ANNIHILATOR:
2428     case MONS_DEEP_ELF_DEATH_MAGE:
2429     case MONS_DEEP_ELF_DEMONOLOGIST:
2430     case MONS_DEEP_ELF_HIGH_PRIEST:
2431     case MONS_DEEP_ELF_SORCERER:
2432     case MONS_GOLDEN_DRAGON:
2433     case MONS_IRON_DRAGON:
2434     case MONS_QUICKSILVER_DRAGON:
2435     case MONS_SHADOW_DRAGON:
2436     case MONS_SKELETAL_DRAGON:
2437     case MONS_TITAN:
2438         return 30;
2439 
2440     case MONS_BIG_FISH:
2441     case MONS_ELECTRICAL_EEL:
2442     case MONS_GIANT_GOLDFISH:
2443     case MONS_JELLYFISH:
2444     case MONS_LAVA_FISH:
2445     case MONS_LAVA_SNAKE:
2446     case MONS_LAVA_WORM:
2447     case MONS_SWAMP_WORM:
2448     case MONS_WATER_ELEMENTAL:
2449         return 500;
2450 
2451     default:
2452         return 99;
2453     }
2454 }                               // end mons_standard_level()
2455 
mons_standard_rare(int mcls)2456 static int mons_standard_rare(int mcls)
2457 {
2458     switch (mcls)
2459     {
2460 // "another lava thing" has no stats!  (GDL)
2461 //    case MONS_ANOTHER_LAVA_THING:
2462     case MONS_BIG_FISH:
2463     case MONS_ELECTRICAL_EEL:
2464     case MONS_GIANT_GOLDFISH:
2465     case MONS_JELLYFISH:
2466     case MONS_LAVA_FISH:
2467     case MONS_LAVA_SNAKE:
2468     case MONS_LAVA_WORM:
2469     case MONS_SWAMP_WORM:
2470     case MONS_WATER_ELEMENTAL:
2471     case MONS_SALAMANDER:
2472         return 500;
2473 
2474     case MONS_GIANT_BAT:
2475     case MONS_GIANT_FROG:
2476     case MONS_GOBLIN:
2477     case MONS_HILL_GIANT:
2478     case MONS_HOBGOBLIN:
2479     case MONS_IMP:
2480     case MONS_KOBOLD:
2481     case MONS_SKELETON_LARGE:
2482     case MONS_ORC:
2483     case MONS_RAT:
2484     case MONS_RED_DEVIL:
2485     case MONS_SKELETON_SMALL:
2486     case MONS_UGLY_THING:
2487     case MONS_ZOMBIE_LARGE:
2488     case MONS_ZOMBIE_SMALL:
2489         return 99;
2490 
2491     case MONS_CENTAUR_WARRIOR:
2492     case MONS_GIANT_ANT:
2493     case MONS_SNAKE:
2494         return 80;
2495 
2496     case MONS_FLYING_SKULL:
2497     case MONS_SLIME_CREATURE:
2498         return 75;
2499 
2500     case MONS_HELL_HOUND:
2501         return 71;
2502 
2503     case MONS_CENTAUR:
2504     case MONS_CYCLOPS:
2505     case MONS_GIANT_BROWN_FROG:
2506     case MONS_HELLION:
2507     case MONS_HOUND:
2508     case MONS_OGRE:
2509     case MONS_ORC_WARRIOR:
2510     case MONS_TROLL:
2511     case MONS_YAK:
2512     case MONS_YAKTAUR_CAPTAIN:
2513         return 70;
2514 
2515     case MONS_JELLY:
2516     case MONS_ORC_KNIGHT:
2517     case MONS_ROTTING_DEVIL:
2518         return 60;
2519 
2520     case MONS_SHAPESHIFTER:
2521         return 59;
2522 
2523     case MONS_STONE_GIANT:
2524         return 53;
2525 
2526     case MONS_BIG_KOBOLD:
2527     case MONS_GIANT_BEETLE:
2528     case MONS_GIANT_BLOWFLY:
2529     case MONS_GIANT_COCKROACH:
2530     case MONS_GIANT_GECKO:
2531     case MONS_GIANT_IGUANA:
2532     case MONS_GIANT_NEWT:
2533     case MONS_HIPPOGRIFF:
2534     case MONS_HYDRA:
2535     case MONS_ICE_BEAST:
2536     case MONS_KILLER_BEE:
2537     case MONS_ORC_WIZARD:
2538     case MONS_QUOKKA:
2539     case MONS_SCORPION:
2540     case MONS_TORMENTOR:
2541     case MONS_UNSEEN_HORROR:
2542     case MONS_WORM:
2543         return 50;
2544 
2545     case MONS_ROCK_TROLL:
2546         return 48;
2547 
2548     case MONS_MANTICORE:
2549     case MONS_OGRE_MAGE:
2550         return 45;
2551 
2552     case MONS_HUNGRY_GHOST:
2553     case MONS_SHADOW:
2554         return 41;
2555 
2556     case MONS_GIANT_CENTIPEDE:
2557     case MONS_GIANT_EYEBALL:
2558     case MONS_GIANT_SPORE:
2559     case MONS_GRIFFON:
2560     case MONS_HAIRY_DEVIL:
2561     case MONS_JACKAL:
2562     case MONS_MOTTLED_DRAGON:
2563     case MONS_PHANTOM:
2564     case MONS_REAPER:
2565     case MONS_TWO_HEADED_OGRE:
2566     case MONS_WIGHT:
2567     case MONS_WRAITH:
2568     case MONS_WYVERN:
2569     case MONS_YAKTAUR:
2570         return 40;
2571 
2572     case MONS_WOLF_SPIDER:
2573         return 36;
2574 
2575     case MONS_FREEZING_WRAITH:
2576     case MONS_GIANT_AMOEBA:
2577     case MONS_GILA_MONSTER:
2578     case MONS_GLOWING_SHAPESHIFTER:
2579     case MONS_SOLDIER_ANT:
2580         return 35;
2581 
2582     case MONS_BOULDER_BEETLE:
2583         return 34;
2584 
2585     case MONS_EYE_OF_DRAINING:
2586         return 33;
2587 
2588     case MONS_GIANT_SLUG:
2589         return 32;
2590 
2591     case MONS_ARMOUR_MIMIC:
2592     case MONS_BROWN_SNAKE:
2593     case MONS_DRAGON:
2594     case MONS_ETTIN:
2595     case MONS_FIRE_VORTEX:
2596     case MONS_GIANT_LIZARD:
2597     case MONS_GIANT_MITE:
2598     case MONS_GNOLL:
2599     case MONS_GOLD_MIMIC:
2600     case MONS_KOMODO_DRAGON:
2601     case MONS_MUMMY:
2602     case MONS_NECROPHAGE:
2603     case MONS_POTION_MIMIC:
2604     case MONS_SCROLL_MIMIC:
2605     case MONS_SKELETAL_WARRIOR:
2606     case MONS_SMALL_SNAKE:
2607     case MONS_SOUL_EATER:
2608     case MONS_SPINY_WORM:
2609     case MONS_VAMPIRE:
2610     case MONS_WEAPON_MIMIC:
2611     case MONS_YELLOW_WASP:
2612         return 30;
2613 
2614     case MONS_FLAYED_GHOST:
2615         return 29;
2616 
2617     case MONS_BRAIN_WORM:
2618         return 26;
2619 
2620     case MONS_BOGGART:
2621     case MONS_DEEP_ELF_FIGHTER:
2622     case MONS_DEEP_ELF_KNIGHT:
2623     case MONS_DEEP_TROLL:
2624     case MONS_FIRE_GIANT:
2625     case MONS_FROST_GIANT:
2626     case MONS_GREAT_ORB_OF_EYES:
2627     case MONS_IRON_TROLL:
2628     case MONS_OOZE:
2629     case MONS_ORC_PRIEST:
2630     case MONS_PLANT:
2631     case MONS_RED_WASP:
2632     case MONS_SIMULACRUM_SMALL:
2633     case MONS_SIMULACRUM_LARGE:
2634         return 25;
2635 
2636     case MONS_BUTTERFLY:
2637     case MONS_FUNGUS:
2638     case MONS_GIANT_SNAIL:
2639     case MONS_ICE_DRAGON:
2640     case MONS_INSUBSTANTIAL_WISP:
2641     case MONS_RAKSHASA:
2642     case MONS_REDBACK:
2643     case MONS_SHADOW_DRAGON:
2644     case MONS_SPECTRAL_WARRIOR:
2645     case MONS_SPHINX:
2646     case MONS_STEAM_DRAGON:
2647     case MONS_STORM_DRAGON:
2648     case MONS_VERY_UGLY_THING:
2649     case MONS_WIZARD:
2650         return 20;
2651 
2652     case MONS_BORING_BEETLE:
2653     case MONS_LICH:
2654     case MONS_TENTACLED_MONSTROSITY:
2655         return 17;
2656 
2657     case MONS_BLINK_FROG:
2658     case MONS_CLAY_GOLEM:
2659     case MONS_EFREET:
2660     case MONS_EYE_OF_DEVASTATION:
2661     case MONS_NECROMANCER:
2662     case MONS_WOOD_GOLEM:
2663         return 15;
2664 
2665     case MONS_KOBOLD_DEMONOLOGIST:
2666         return 13;
2667 
2668     case MONS_BUMBLEBEE:
2669     case MONS_ORC_HIGH_PRIEST:
2670         return 12;
2671 
2672     case MONS_DEEP_ELF_SOLDIER:
2673     case MONS_GIANT_ORANGE_BRAIN:
2674     case MONS_HELL_KNIGHT:
2675     case MONS_IRON_GOLEM:
2676     case MONS_OKLOB_PLANT:
2677     case MONS_ORC_SORCERER:
2678     case MONS_SHADOW_WRAITH:
2679     case MONS_STONE_GOLEM:
2680     case MONS_TITAN:
2681     case MONS_WANDERING_MUSHROOM:
2682         return 10;
2683 
2684     case MONS_GOLDEN_DRAGON:
2685     case MONS_ORC_WARLORD:
2686         return 7;
2687 
2688     case MONS_GARGOYLE:
2689         return 6;
2690 
2691     case MONS_CRYSTAL_GOLEM:
2692     case MONS_DANCING_WEAPON:
2693     case MONS_DEEP_ELF_HIGH_PRIEST:
2694     case MONS_DEEP_ELF_MAGE:
2695     case MONS_DEEP_ELF_SUMMONER:
2696     case MONS_IRON_DRAGON:
2697     case MONS_NAGA_MAGE:
2698     case MONS_NAGA_WARRIOR:
2699     case MONS_SKELETAL_DRAGON:
2700     case MONS_QUICKSILVER_DRAGON:
2701     case MONS_VAPOUR:
2702         return 5;
2703 
2704     case MONS_AIR_ELEMENTAL:
2705     case MONS_DEEP_ELF_CONJURER:
2706     case MONS_EARTH_ELEMENTAL:
2707     case MONS_FIRE_ELEMENTAL:
2708         return 4;
2709 
2710     case MONS_ANCIENT_LICH:
2711     case MONS_DEEP_ELF_ANNIHILATOR:
2712     case MONS_DEEP_ELF_DEATH_MAGE:
2713     case MONS_DEEP_ELF_DEMONOLOGIST:
2714     case MONS_DEEP_ELF_PRIEST:
2715     case MONS_DEEP_ELF_SORCERER:
2716     case MONS_GUARDIAN_NAGA:
2717         return 3;
2718 
2719     case MONS_PULSATING_LUMP:
2720     case MONS_SHINING_EYE:
2721     case MONS_TOENAIL_GOLEM:
2722         return 2;
2723 
2724     default:
2725         return 0;
2726     }
2727 }                               // end mons_standard_rare()
2728