* Fixed siren movement into deep water.

* Reorder branch dependent placement functions in monplace.cc.
* Added chances for trapdoor spider in the Dungeon, Lair, Hive, 
  and Tomb (!) 

I know it doesn't fit there in an obvious way, not being undead, 
but aren't the pyramids rumoured to contain traps and such? 
A self-hiding poisonous spider pretty much fits that bill.


git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@7707 c06c8d41-db1a-0410-9941-cceddc491573

5 files changed, 1541 insertions, 1449 deletions

diff --git a/crawl-ref/source/effects.cc b/crawl-ref/source/effects.cc
index 8bddb089fd..3fdbb64552 100644
--- a/crawl-ref/source/effects.cc
+++ b/crawl-ref/source/effects.cc
@@ -2627,7 +2627,7 @@ void change_labyrinth(bool msg)
                 }
             }
         }
-        else if (one_chance_in(750))
+        else if (one_chance_in(500))
         {
             // Sometimes (rarely) add blood randomly, accumulating with time...
             env.map(p).property |= FPROP_BLOODY;
@@ -2680,7 +2680,7 @@ void change_labyrinth(bool msg)
                 }
             }
         }
-        else if (one_chance_in(150))
+        else if (one_chance_in(100))
         {
             // Occasionally add blood randomly, accumulating with time...
             env.map(p).property |= FPROP_BLOODY;
diff --git a/crawl-ref/source/mon-pick.cc b/crawl-ref/source/mon-pick.cc
index 6b4b2635ab..4f2efd9004 100644
--- a/crawl-ref/source/mon-pick.cc
+++ b/crawl-ref/source/mon-pick.cc
@@ -17,6 +17,16 @@
 
 // NB - When adding new branches or levels above 50, you must
 // change pre-game deletion routine in new_game in newgame.cc
+
+//    New branch must be added in:
+//    - new_game stair location
+//    - down/up stairs (to and back) misc.cc
+//    - new_level (2 places) (misc.cc)
+//    - item_check items.cc
+//    - ouch ouch.cc (death message)
+//    - and here...
+
+// NOTE: The lower the level the earlier a monster may appear.
 int mons_level(int mcls, const level_id &place)
 {
     int monster_level = 0;
@@ -160,8 +170,8 @@ int mons_global_level(int mcls)
     return (0);
 }
 
-// higher values returned means the monster is "more common"
-// a return value of zero means the monster will never appear {dlb}
+// NOTE: Higher values returned means the monster is "more common".
+// A return value of zero means the monster will never appear. {dlb}
 int mons_rarity(int mcls, const level_id &place)
 {
     // now, what about pandemonium ??? {dlb}
@@ -171,6 +181,10 @@ int mons_rarity(int mcls, const level_id &place)
         return branches[place.branch].mons_rarity_function(mcls);
 }
 
+// level_area_type != LEVEL_DUNGEON
+// NOTE: Labyrinths and portal vaults have no random monster generation.
+
+// The Abyss
 bool mons_abyss(int mcls)
 {
     switch (mcls)
@@ -291,7 +305,7 @@ bool mons_abyss(int mcls)
     default:
         return (false);
     }
-}                               // end mons_abyss()
+}
 
 int mons_rare_abyss(int mcls)
 {
@@ -458,8 +472,9 @@ int mons_rare_abyss(int mcls)
     default:
         return 0;
     }
-}                               // end mons_rare_abyss()
+}
 
+// Pandemonium
 bool mons_pan(int mcls)
 {
     switch (mcls)
@@ -541,630 +556,543 @@ bool mons_pan(int mcls)
     default:
         return (false);
     }
-}                               // end mons_pan()
+}
 
 /* ******************** END EXTERNAL FUNCTIONS ******************** */
 
-int mons_dis_level(int mcls)
-{
-    int mlev = 26;
+// LEVEL_DUNGEON
 
+// The Main Dungeon
+int mons_standard_level(int mcls)
+{
     switch (mcls)
     {
-    case MONS_CLAY_GOLEM:
-    case MONS_IMP:
-    case MONS_NECROPHAGE:
-    case MONS_RED_DEVIL:
-    case MONS_SKELETAL_WARRIOR:
-    case MONS_ZOMBIE_LARGE:
-        mlev++;
-        break;
-
-    case MONS_HELL_HOUND:
-    case MONS_HELL_KNIGHT:
-    case MONS_SKELETON_LARGE:
-    case MONS_PHANTOM:
-    case MONS_ROTTING_DEVIL:
-    case MONS_SHADOW:
-    case MONS_SKELETON_SMALL:
-    case MONS_STONE_GOLEM:
-    case MONS_TORMENTOR:
-    case MONS_WIGHT:
-    case MONS_ZOMBIE_SMALL:
-        mlev += 2;
-        break;
+    case MONS_GOBLIN:
+    case MONS_GIANT_NEWT:
+        return 1;
 
-    case MONS_EFREET:
-    case MONS_FLYING_SKULL:
-    case MONS_HELLION:
-    case MONS_HELL_HOG:
-    case MONS_IRON_GOLEM:
-    case MONS_MUMMY:
-        mlev += 3;
-        break;
+    case MONS_GIANT_COCKROACH:
+    case MONS_OOZE:
+    case MONS_SMALL_SNAKE:
+        return 2;
 
-    case MONS_FLAYED_GHOST:
-    case MONS_FREEZING_WRAITH:
-    case MONS_DEATH_DRAKE:
-    case MONS_HAIRY_DEVIL:
-    case MONS_IRON_DEVIL:
-    case MONS_VAMPIRE:
-    case MONS_WRAITH:
-        mlev += 3;
-        break;
+    case MONS_GIANT_BAT:
+    case MONS_KOBOLD:
+    case MONS_RAT:
+        return 4;
 
-    case MONS_BLUE_DEVIL:
-    case MONS_DANCING_WEAPON:
-    case MONS_FLAMING_CORPSE:
-    case MONS_ICE_DEVIL:
-    case MONS_ICE_DRAGON:
-    case MONS_LICH:
-    case MONS_REAPER:
-    case MONS_SOUL_EATER:
-    case MONS_SPECTRAL_WARRIOR:
-        mlev += 5;
-        break;
+    case MONS_GIANT_GECKO:
+    case MONS_GIANT_MITE:
+    case MONS_GNOLL:
+    case MONS_HOBGOBLIN:
+    case MONS_JACKAL:
+    case MONS_KILLER_BEE_LARVA:
+        return 5;
 
-    case MONS_ANCIENT_LICH:
-    case MONS_FIEND:
-    case MONS_IRON_DRAGON:
-    case MONS_SKELETAL_DRAGON:
-        mlev += 6;
-        break;
+    case MONS_WORM:
+    case MONS_SNAKE:
+    case MONS_QUOKKA:
+        return 6;
 
-    default:
-        return 0;
-    }
+    case MONS_ORC:
+    case MONS_ORC_PRIEST:
+        return 7;
 
-    return (mlev);
-}                               // end mons_dis_level()
+    case MONS_FUNGUS:
+    case MONS_GIANT_ANT:
+    case MONS_GIANT_EYEBALL:
+    case MONS_HOUND:
+    case MONS_GIANT_IGUANA:
+    case MONS_OGRE:
+    case MONS_ORC_WIZARD:
+    case MONS_PHANTOM:
+    case MONS_SCORPION:
+        return 8;
 
-int mons_dis_rare(int mcls)
-{
-    switch (mcls)
-    {
+    case MONS_BROWN_SNAKE:
+    case MONS_CENTAUR:
+    case MONS_ICE_BEAST:
     case MONS_IMP:
-    case MONS_IRON_DEVIL:
-    case MONS_ZOMBIE_LARGE:
+    case MONS_JELLY:
+    case MONS_NECROPHAGE:
+    case MONS_QUASIT:
     case MONS_ZOMBIE_SMALL:
-        return 99;
+        return 9;
 
-    case MONS_REAPER:
-        return 77;
+    case MONS_DEEP_ELF_SOLDIER:
+    case MONS_GIANT_BEETLE:
+    case MONS_GIANT_FROG:
+    case MONS_GIANT_SPORE:
+    case MONS_MUMMY:
+    case MONS_ORC_WARRIOR:
+    case MONS_STEAM_DRAGON:
+    case MONS_WIGHT:
+        return 10;
 
-    case MONS_TORMENTOR:
-        return 66;
+    case MONS_GIANT_LIZARD:
+    case MONS_HIPPOGRIFF:
+    case MONS_HUNGRY_GHOST:
+    case MONS_KILLER_BEE:
+    case MONS_SHADOW:
+    case MONS_YELLOW_WASP:
+        return 11;
 
-    case MONS_RED_DEVIL:
-    case MONS_SKELETAL_WARRIOR:
-        return 50;
+    case MONS_EYE_OF_DRAINING:
+    case MONS_GILA_MONSTER:
+    case MONS_MANTICORE:
+    case MONS_PLANT:
+    case MONS_WYVERN:
+        return 12;
 
-    case MONS_WRAITH:
-        return 48;
+    case MONS_BIG_KOBOLD:
+    case MONS_GIANT_BROWN_FROG:
+    case MONS_GIANT_CENTIPEDE:
+    case MONS_OKLOB_PLANT:
+    case MONS_TROLL:
+    case MONS_TWO_HEADED_OGRE:
+    case MONS_WOOD_GOLEM:
+    case MONS_YAK:
+        return 13;
 
-    case MONS_SHADOW:
-        return 56;
+    case MONS_HILL_GIANT:
+    case MONS_KOMODO_DRAGON:
+    case MONS_SOLDIER_ANT:
+    case MONS_WOLF_SPIDER:
+    case MONS_WRAITH:
+    case MONS_UNSEEN_HORROR:
+    case MONS_TRAPDOOR_SPIDER:
+        return 14;
 
-    case MONS_HELL_HOUND:
-        return 46;
+    case MONS_ARMOUR_MIMIC:
+    case MONS_BRAIN_WORM:
+    case MONS_CYCLOPS:
+    case MONS_EFREET:
+    case MONS_ETTIN:
+    case MONS_EYE_OF_DEVASTATION:
+    case MONS_GOLD_MIMIC:
+    case MONS_HYDRA:
+    case MONS_MOTTLED_DRAGON:
+    case MONS_POTION_MIMIC:
+    case MONS_SCROLL_MIMIC:
+    case MONS_SKELETAL_WARRIOR:
+    case MONS_WEAPON_MIMIC:
+        return 15;
 
-    case MONS_MUMMY:
-    case MONS_WIGHT:
-        return 45;
+    case MONS_BLINK_FROG:
+    case MONS_BUTTERFLY:
+    case MONS_GIANT_BLOWFLY:
+    case MONS_GUARDIAN_NAGA:
+    case MONS_RAKSHASA:
+    case MONS_SLIME_CREATURE:
+    case MONS_STONE_GOLEM:
+    case MONS_VAMPIRE:
+    case MONS_WANDERING_MUSHROOM:
+    case MONS_ZOMBIE_LARGE:
+        return 16;
 
-    case MONS_HELLION:
-    case MONS_BLUE_DEVIL:
-        return 40;
+    case MONS_BOGGART:
+    case MONS_CENTAUR_WARRIOR:
+    case MONS_CLAY_GOLEM:
+    case MONS_GRIFFON:
+    case MONS_SHAPESHIFTER:
+    case MONS_UGLY_THING:
+    case MONS_WIZARD:
+    case MONS_SIMULACRUM_SMALL:
+    case MONS_SIMULACRUM_LARGE:
+        return 17;
 
-    case MONS_FLYING_SKULL:
-        return 35;
+    case MONS_DRAGON:
+    case MONS_GARGOYLE:
+    case MONS_GIANT_AMOEBA:
+    case MONS_KOBOLD_DEMONOLOGIST:
+        return 18;
 
-    case MONS_FREEZING_WRAITH:
-    case MONS_ICE_DEVIL:
-        return 30;
+    case MONS_GIANT_SLUG:
+    case MONS_IRON_GOLEM:
+    case MONS_OGRE_MAGE:
+    case MONS_ROCK_TROLL:
+    case MONS_TOENAIL_GOLEM:
+    case MONS_YAKTAUR:
+        return 19;
 
-    case MONS_FLAMING_CORPSE:
-    case MONS_FLAYED_GHOST:
+    case MONS_AIR_ELEMENTAL:
+    case MONS_DEEP_ELF_FIGHTER:
+    case MONS_DEEP_ELF_KNIGHT:
+    case MONS_DEEP_ELF_MAGE:
+    case MONS_DEEP_ELF_SUMMONER:
+    case MONS_EARTH_ELEMENTAL:
+    case MONS_FIRE_ELEMENTAL:
+    case MONS_GIANT_ORANGE_BRAIN:
+    case MONS_GIANT_SNAIL:
+    case MONS_GREAT_ORB_OF_EYES:
+    case MONS_ICE_DRAGON:
     case MONS_SKELETON_LARGE:
-    case MONS_NECROPHAGE:
+    case MONS_NAGA_MAGE:
+    case MONS_NAGA_WARRIOR:
+    case MONS_NECROMANCER:
+    case MONS_ORC_KNIGHT:
+    case MONS_QUEEN_BEE:
+    case MONS_RED_WASP:
+    case MONS_SHADOW_WRAITH:
     case MONS_SKELETON_SMALL:
-        return 25;
-
-    case MONS_HELL_HOG:
-    case MONS_SKELETAL_DRAGON:
+    case MONS_SPINY_WORM:
+    case MONS_VERY_UGLY_THING:
         return 20;
 
-    case MONS_VAMPIRE:
-        return 19;
+    case MONS_BOULDER_BEETLE:
+    case MONS_ORC_HIGH_PRIEST:
+    case MONS_PULSATING_LUMP:
+        return 21;
 
-    case MONS_PHANTOM:
-        return 17;
+    case MONS_BORING_BEETLE:
+    case MONS_CRYSTAL_GOLEM:
+    case MONS_FLAYED_GHOST:
+    case MONS_FREEZING_WRAITH:
+    case MONS_REDBACK:
+    case MONS_SPHINX:
+    case MONS_VAPOUR:
+        return 22;
 
-    case MONS_HAIRY_DEVIL:
-        return 15;
+    case MONS_ORC_SORCERER:
+    case MONS_SHINING_EYE:
+        return 23;
+
+    case MONS_BUMBLEBEE:
+    case MONS_ORC_WARLORD:
+    case MONS_IRON_TROLL:
+    case MONS_YAKTAUR_CAPTAIN:
+        return 24;
 
-    case MONS_CLAY_GOLEM:
     case MONS_DANCING_WEAPON:
-    case MONS_EFREET:
+    case MONS_DEEP_TROLL:
+    case MONS_FIRE_GIANT:
+    case MONS_FROST_GIANT:
     case MONS_HELL_KNIGHT:
-    case MONS_IRON_GOLEM:
+    case MONS_INSUBSTANTIAL_WISP:
     case MONS_LICH:
-    case MONS_ROTTING_DEVIL:
-    case MONS_SOUL_EATER:
+    case MONS_STONE_GIANT:
+        return 25;
+
+    case MONS_DEEP_ELF_CONJURER:
     case MONS_SPECTRAL_WARRIOR:
-    case MONS_STONE_GOLEM:
-        return 10;
+    case MONS_STORM_DRAGON:
+        return 26;
 
-    case MONS_IRON_DRAGON:
-        return 5;
+    case MONS_DEEP_ELF_PRIEST:
+    case MONS_GLOWING_SHAPESHIFTER:
+    case MONS_TENTACLED_MONSTROSITY:
+        return 27;
 
     case MONS_ANCIENT_LICH:
-    case MONS_FIEND:
-        return 3;
+    case MONS_DEEP_ELF_ANNIHILATOR:
+    case MONS_DEEP_ELF_DEATH_MAGE:
+    case MONS_DEEP_ELF_DEMONOLOGIST:
+    case MONS_DEEP_ELF_HIGH_PRIEST:
+    case MONS_DEEP_ELF_SORCERER:
+    case MONS_GOLDEN_DRAGON:
+    case MONS_IRON_DRAGON:
+    case MONS_QUICKSILVER_DRAGON:
+    case MONS_SHADOW_DRAGON:
+    case MONS_SKELETAL_DRAGON:
+    case MONS_TITAN:
+        return 30;
+
+    case MONS_DEEP_ELF_BLADEMASTER:
+    case MONS_DEEP_ELF_MASTER_ARCHER:
+        return 33;
+
+    case MONS_BIG_FISH:
+    case MONS_ELECTRICAL_EEL:
+    case MONS_GIANT_GOLDFISH:
+    case MONS_JELLYFISH:
+    case MONS_LAVA_FISH:
+    case MONS_LAVA_SNAKE:
+    case MONS_LAVA_WORM:
+    case MONS_SWAMP_WORM:
+    case MONS_WATER_ELEMENTAL:
+        return 500;
 
     default:
-        return 0;
+        return 99;
     }
-}                               // end mons_dis_rare()
+}
 
-int mons_gehenna_level(int mcls)
+int mons_standard_rare(int mcls)
 {
-    int mlev = 26;
-
     switch (mcls)
     {
-    case MONS_CLAY_GOLEM:
+    case MONS_BIG_FISH:
+    case MONS_ELECTRICAL_EEL:
+    case MONS_GIANT_GOLDFISH:
+    case MONS_JELLYFISH:
+    case MONS_LAVA_FISH:
+    case MONS_LAVA_SNAKE:
+    case MONS_LAVA_WORM:
+    case MONS_SWAMP_WORM:
+    case MONS_WATER_ELEMENTAL:
+    case MONS_SALAMANDER:
+        return 500;
+
+    case MONS_GIANT_BAT:
+    case MONS_GIANT_FROG:
+    case MONS_GOBLIN:
+    case MONS_HILL_GIANT:
+    case MONS_HOBGOBLIN:
+    case MONS_IMP:
+    case MONS_KOBOLD:
     case MONS_SKELETON_LARGE:
+    case MONS_ORC:
+    case MONS_RAT:
     case MONS_RED_DEVIL:
     case MONS_SKELETON_SMALL:
+    case MONS_UGLY_THING:
     case MONS_ZOMBIE_LARGE:
     case MONS_ZOMBIE_SMALL:
-        mlev++;
-        break;
+        return 99;
 
-    case MONS_HELL_HOG:
-    case MONS_HELL_HOUND:
-    case MONS_IMP:
-    case MONS_NECROPHAGE:
-    case MONS_STONE_GOLEM:
-        mlev += 2;
-        break;
+    case MONS_CENTAUR_WARRIOR:
+    case MONS_GIANT_ANT:
+    case MONS_SNAKE:
+        return 80;
 
+    case MONS_MERFOLK:
+    case MONS_MERMAID:
     case MONS_FLYING_SKULL:
-    case MONS_IRON_GOLEM:
-    case MONS_MUMMY:
-    case MONS_PHANTOM:
-    case MONS_ROTTING_DEVIL:
-    case MONS_SHADOW:
-    case MONS_WIGHT:
-        mlev += 3;
-        break;
+    case MONS_SLIME_CREATURE:
+        return 75;
 
-    case MONS_HAIRY_DEVIL:
-    case MONS_HELL_KNIGHT:
-    case MONS_VAMPIRE:
-    case MONS_WRAITH:
-        mlev += 4;
-        break;
+    case MONS_HELL_HOUND:
+        return 71;
 
-    case MONS_EFREET:
-    case MONS_FLAMING_CORPSE:
-    case MONS_FLAYED_GHOST:
+    case MONS_CENTAUR:
+    case MONS_CYCLOPS:
+    case MONS_GIANT_BROWN_FROG:
     case MONS_HELLION:
-    case MONS_TORMENTOR:
-        mlev += 5;
-        break;
-
-    case MONS_ANCIENT_LICH:
-    case MONS_FIEND:
-    case MONS_LICH:
-    case MONS_PIT_FIEND:
-    case MONS_REAPER:
-    case MONS_SERPENT_OF_HELL:
-    case MONS_SKELETAL_DRAGON:
-    case MONS_SOUL_EATER:
-    case MONS_SPECTRAL_WARRIOR:
-        mlev += 6;
-        break;
-
-    default:
-        return 0;
-    }
-
-    return (mlev);
-}                               // end mons_gehenna_level()
-
-int mons_gehenna_rare(int mcls)
-{
-    switch (mcls)
-    {
-    case MONS_SKELETON_LARGE:
-    case MONS_SKELETON_SMALL:
-    case MONS_ZOMBIE_LARGE:
-    case MONS_ZOMBIE_SMALL:
-        return 99;
-
-    case MONS_MUMMY:
+    case MONS_HOUND:
+    case MONS_OGRE:
+    case MONS_ORC_WARRIOR:
+    case MONS_TROLL:
+    case MONS_YAK:
+    case MONS_YAKTAUR_CAPTAIN:
         return 70;
 
-    case MONS_SHADOW:
-        return 61;
-
-    case MONS_RED_DEVIL:
-    case MONS_WIGHT:
+    case MONS_JELLY:
+    case MONS_ORC_KNIGHT:
+    case MONS_ROTTING_DEVIL:
         return 60;
 
-    case MONS_HELLION:
-        return 54;
+    case MONS_SHAPESHIFTER:
+        return 59;
 
-    case MONS_WRAITH:
+    case MONS_STONE_GIANT:
         return 53;
 
-    case MONS_NECROPHAGE:
-    case MONS_ROTTING_DEVIL:
+    case MONS_BIG_KOBOLD:
+    case MONS_GIANT_BEETLE:
+    case MONS_GIANT_BLOWFLY:
+    case MONS_GIANT_COCKROACH:
+    case MONS_GIANT_GECKO:
+    case MONS_GIANT_IGUANA:
+    case MONS_GIANT_NEWT:
+    case MONS_HIPPOGRIFF:
+    case MONS_HYDRA:
+    case MONS_ICE_BEAST:
+    case MONS_KILLER_BEE:
+    case MONS_ORC_WIZARD:
+    case MONS_QUOKKA:
+    case MONS_SCORPION:
+    case MONS_TORMENTOR:
+    case MONS_UNSEEN_HORROR:
+    case MONS_WORM:
         return 50;
 
-    case MONS_VAMPIRE:
-        return 44;
-
-    case MONS_FLYING_SKULL:
-    case MONS_REAPER:
-        return 43;
+    case MONS_ROCK_TROLL:
+        return 48;
 
-    case MONS_TORMENTOR:
-        return 42;
+    case MONS_MANTICORE:
+    case MONS_OGRE_MAGE:
+        return 45;
 
-    case MONS_HELL_HOUND:
+    case MONS_HUNGRY_GHOST:
+    case MONS_SHADOW:
         return 41;
 
-    case MONS_FLAMING_CORPSE:
-    case MONS_FLAYED_GHOST:
-    case MONS_PHANTOM:
-        return 32;
-
-    case MONS_HELL_HOG:
-    case MONS_IMP:
-    case MONS_IRON_DEVIL:
-        return 30;
-
-    case MONS_LICH:
-        return 25;
-
-    case MONS_HELL_KNIGHT:
-        return 21;
-
+    case MONS_GIANT_CENTIPEDE:
+    case MONS_GIANT_EYEBALL:
+    case MONS_GIANT_SPORE:
+    case MONS_GRIFFON:
     case MONS_HAIRY_DEVIL:
-    case MONS_SPECTRAL_WARRIOR:
-        return 20;
-
-    case MONS_CLAY_GOLEM:
-    case MONS_SKELETAL_DRAGON:
-        return 10;
-
-    case MONS_STONE_GOLEM:
-        return 8;
-
-    case MONS_PIT_FIEND:
-        return 7;
-
-    case MONS_EFREET:
-    case MONS_FIEND:
-    case MONS_IRON_GOLEM:
-    case MONS_SOUL_EATER:
-        return 5;
-
-    case MONS_ANCIENT_LICH:
-    case MONS_SERPENT_OF_HELL:
-        return 4;
-
-    default:
-        return 0;
-    }
-}                               // end mons_gehenna_rare()
-
-int mons_cocytus_level(int mcls)
-{
-    int mlev = 26;
-
-    switch (mcls)
-    {
-    case MONS_SKELETON_LARGE:
-    case MONS_NECROPHAGE:
-    case MONS_SKELETAL_WARRIOR:
-    case MONS_SKELETON_SMALL:
-    case MONS_ZOMBIE_LARGE:
-    case MONS_ZOMBIE_SMALL:
-    case MONS_SIMULACRUM_LARGE:
-    case MONS_SIMULACRUM_SMALL:
-        mlev++;
-        break;
-
-    case MONS_BLUE_DEVIL:
-    case MONS_ICE_BEAST:
+    case MONS_JACKAL:
+    case MONS_MOTTLED_DRAGON:
     case MONS_PHANTOM:
-    case MONS_SHADOW:
-        mlev += 2;
-        break;
-
-    case MONS_FLYING_SKULL:
-    case MONS_ROTTING_DEVIL:
-    case MONS_VAMPIRE:
+    case MONS_REAPER:
+    case MONS_TWO_HEADED_OGRE:
     case MONS_WIGHT:
-        mlev += 3;
-        break;
-
-    case MONS_FREEZING_WRAITH:
-    case MONS_HAIRY_DEVIL:
-    case MONS_HUNGRY_GHOST:
-    case MONS_MUMMY:
-    case MONS_SPECTRAL_WARRIOR:
     case MONS_WRAITH:
-        mlev += 4;
-        break;
-
-    case MONS_ICE_DEVIL:
-    case MONS_ICE_DRAGON:
-    case MONS_TORMENTOR:
-        mlev += 5;
-        break;
-
-    case MONS_ANCIENT_LICH:
-    case MONS_LICH:
-    case MONS_REAPER:
-    case MONS_SKELETAL_DRAGON:
-    case MONS_SOUL_EATER:
-        mlev += 6;
-        break;
-
-    default:
-        return 0;
-    }
+    case MONS_WYVERN:
+    case MONS_YAKTAUR:
+        return 40;
 
-    return (mlev);
-}                               // end mons_cocytus_level()
+    case MONS_WOLF_SPIDER:
+        return 36;
 
-int mons_cocytus_rare(int mcls)
-{
-    switch (mcls)
-    {
     case MONS_FREEZING_WRAITH:
-        return 87;
-
-    case MONS_ICE_BEAST:
-    case MONS_SKELETON_LARGE:
-    case MONS_SKELETON_SMALL:
-    case MONS_ZOMBIE_LARGE:
-    case MONS_ZOMBIE_SMALL:
-        return 85;
-
-    case MONS_BLUE_DEVIL:
-    case MONS_ICE_DEVIL:
-        return 76;
-
-    case MONS_FLYING_SKULL:
-        return 57;
-
-    case MONS_SHADOW:
-        return 56;
-
-    case MONS_SKELETAL_WARRIOR:
-        return 50;
-
-    case MONS_REAPER:
-        return 47;
+    case MONS_GIANT_AMOEBA:
+    case MONS_GILA_MONSTER:
+    case MONS_GLOWING_SHAPESHIFTER:
+    case MONS_SOLDIER_ANT:
+        return 35;
 
-    case MONS_WIGHT:
-    case MONS_WRAITH:
-        return 45;
+    case MONS_BOULDER_BEETLE:
+        return 34;
 
-    case MONS_ICE_DRAGON:
-        return 38;
+    case MONS_EYE_OF_DRAINING:
+    case MONS_TRAPDOOR_SPIDER:
+        return 33;
 
-    case MONS_ROTTING_DEVIL:
-    case MONS_TORMENTOR:
-        return 37;
+    case MONS_GIANT_SLUG:
+        return 32;
 
+    case MONS_ARMOUR_MIMIC:
+    case MONS_BROWN_SNAKE:
+    case MONS_DRAGON:
+    case MONS_ETTIN:
+    case MONS_FIRE_VORTEX:
+    case MONS_GIANT_LIZARD:
+    case MONS_GIANT_MITE:
+    case MONS_GNOLL:
+    case MONS_GOLD_MIMIC:
+    case MONS_KOMODO_DRAGON:
     case MONS_MUMMY:
-        return 35;
-
+    case MONS_NECROPHAGE:
+    case MONS_POTION_MIMIC:
+    case MONS_SCROLL_MIMIC:
+    case MONS_QUASIT:
+    case MONS_SKELETAL_WARRIOR:
+    case MONS_SMALL_SNAKE:
+    case MONS_SOUL_EATER:
+    case MONS_SPINY_WORM:
     case MONS_VAMPIRE:
-        return 34;
+    case MONS_WEAPON_MIMIC:
+    case MONS_YELLOW_WASP:
+        return 30;
 
-    case MONS_HAIRY_DEVIL:
-    case MONS_HUNGRY_GHOST:
+    case MONS_FLAYED_GHOST:
+        return 29;
+
+    case MONS_BRAIN_WORM:
         return 26;
 
-    case MONS_NECROPHAGE:
-    case MONS_PHANTOM:
+    case MONS_BOGGART:
+    case MONS_DEEP_ELF_FIGHTER:
+    case MONS_DEEP_ELF_KNIGHT:
+    case MONS_DEEP_TROLL:
+    case MONS_FIRE_GIANT:
+    case MONS_FROST_GIANT:
+    case MONS_GREAT_ORB_OF_EYES:
+    case MONS_IRON_TROLL:
+    case MONS_OOZE:
+    case MONS_ORC_PRIEST:
+    case MONS_PLANT:
+    case MONS_RED_WASP:
+    case MONS_SIMULACRUM_SMALL:
+    case MONS_SIMULACRUM_LARGE:
         return 25;
 
+    case MONS_BUTTERFLY:
+    case MONS_FUNGUS:
+    case MONS_GIANT_SNAIL:
+    case MONS_ICE_DRAGON:
+    case MONS_INSUBSTANTIAL_WISP:
+    case MONS_RAKSHASA:
+    case MONS_REDBACK:
+    case MONS_SHADOW_DRAGON:
     case MONS_SPECTRAL_WARRIOR:
+    case MONS_SPHINX:
+    case MONS_STEAM_DRAGON:
+    case MONS_STORM_DRAGON:
+    case MONS_VERY_UGLY_THING:
+    case MONS_WIZARD:
         return 20;
 
-    case MONS_SOUL_EATER:
-        return 19;
-
+    case MONS_BORING_BEETLE:
     case MONS_LICH:
-    case MONS_SKELETAL_DRAGON:
-    case MONS_SIMULACRUM_LARGE:
-    case MONS_SIMULACRUM_SMALL:
-        return 12;
-
-    case MONS_ANCIENT_LICH:
-        return 5;
-
-    default:
-        return 0;
-    }
-}                               // end mons_cocytus_rare()
-
-int mons_tartarus_level(int mcls)
-{
-    int mlev = 26;
-
-    switch (mcls)
-    {
-    case MONS_IMP:
-    case MONS_SKELETON_LARGE:
-    case MONS_RED_DEVIL:
-    case MONS_SHADOW_IMP:
-    case MONS_SKELETAL_WARRIOR:
-    case MONS_SKELETON_SMALL:
-        mlev++;
-        break;
-
-    case MONS_HELL_KNIGHT:
-    case MONS_NECROPHAGE:
-    case MONS_PHANTOM:
-    case MONS_WIGHT:
-    case MONS_ZOMBIE_LARGE:
-    case MONS_ZOMBIE_SMALL:
-        mlev += 2;
-        break;
+    case MONS_TENTACLED_MONSTROSITY:
+        return 17;
 
-    case MONS_FREEZING_WRAITH:
-    case MONS_HELL_HOUND:
+    case MONS_BLINK_FROG:
+    case MONS_CLAY_GOLEM:
+    case MONS_EFREET:
+    case MONS_EYE_OF_DEVASTATION:
     case MONS_NECROMANCER:
-    case MONS_SHADOW:
-    case MONS_SHADOW_DEMON:
-    case MONS_WRAITH:
-        mlev += 3;
-        break;
-
-    case MONS_BLUE_DEVIL:
-    case MONS_FLAYED_GHOST:
-    case MONS_HUNGRY_GHOST:
-    case MONS_ICE_DEVIL:
-    case MONS_MUMMY:
-    case MONS_SKELETAL_DRAGON:
-    case MONS_SPECTRAL_WARRIOR:
-    case MONS_TORMENTOR:
-    case MONS_SIMULACRUM_LARGE:
-    case MONS_SIMULACRUM_SMALL:
-        mlev += 4;
-        break;
-
-    case MONS_FLYING_SKULL:
-    case MONS_HELLION:
-    case MONS_REAPER:
-    case MONS_ROTTING_DEVIL:
-    case MONS_SHADOW_DRAGON:
-    case MONS_VAMPIRE:
-        mlev += 5;
-        break;
-
-    case MONS_ANCIENT_LICH:
-    case MONS_HAIRY_DEVIL:
-    case MONS_LICH:
-    case MONS_SOUL_EATER:
-        mlev += 6;
-        break;
-
-    default:
-        return 0;
-    }
-
-    return (mlev);
-}                               // end mons_tartarus_level()
-
-int mons_tartarus_rare(int mcls)
-{
-    switch (mcls)
-    {
-    case MONS_SKELETON_LARGE:
-    case MONS_SHADOW_IMP:
-    case MONS_SKELETAL_WARRIOR:
-    case MONS_SKELETON_SMALL:
-    case MONS_ZOMBIE_LARGE:
-    case MONS_ZOMBIE_SMALL:
-        return 99;
-
-    case MONS_SHADOW:
-        return 92;
-
-    case MONS_REAPER:
-        return 73;
-
-    case MONS_NECROPHAGE:
-        return 72;
-
-    case MONS_WIGHT:
-        return 71;
-
-    case MONS_ROTTING_DEVIL:
-        return 62;
-
-    case MONS_FREEZING_WRAITH:
-        return 60;
-
-    case MONS_FLYING_SKULL:
-        return 53;
+    case MONS_WOOD_GOLEM:
+        return 15;
 
-    case MONS_HELL_HOUND:
-    case MONS_PHANTOM:
-    case MONS_WRAITH:
-        return 52;
+    case MONS_KOBOLD_DEMONOLOGIST:
+        return 13;
 
-    case MONS_SHADOW_DEMON:
-        return 50;
+    case MONS_BUMBLEBEE:
+    case MONS_ORC_HIGH_PRIEST:
+        return 12;
 
-    case MONS_SPECTRAL_WARRIOR:
-        return 45;
+    case MONS_DEEP_ELF_SOLDIER:
+    case MONS_GIANT_ORANGE_BRAIN:
+    case MONS_HELL_KNIGHT:
+    case MONS_IRON_GOLEM:
+    case MONS_OKLOB_PLANT:
+    case MONS_ORC_SORCERER:
+    case MONS_SHADOW_WRAITH:
+    case MONS_STONE_GOLEM:
+    case MONS_TITAN:
+    case MONS_WANDERING_MUSHROOM:
+        return 10;
 
-    case MONS_VAMPIRE:
-        return 44;
+    case MONS_GOLDEN_DRAGON:
+    case MONS_ORC_WARLORD:
+        return 7;
 
-    case MONS_HELLION:
-    case MONS_TORMENTOR:
-        return 42;
+    case MONS_GARGOYLE:
+        return 6;
 
+    case MONS_CRYSTAL_GOLEM:
+    case MONS_DANCING_WEAPON:
+    case MONS_DEEP_ELF_HIGH_PRIEST:
+    case MONS_DEEP_ELF_MAGE:
+    case MONS_DEEP_ELF_SUMMONER:
+    case MONS_IRON_DRAGON:
+    case MONS_NAGA_MAGE:
+    case MONS_NAGA_WARRIOR:
     case MONS_SKELETAL_DRAGON:
-        return 40;
-
-    case MONS_SOUL_EATER:
-        return 35;
-
-    case MONS_ICE_DEVIL:        // not really appropriate for a fiery hell
-        return 34;
-
-    case MONS_MUMMY:
-        return 33;
-
-    case MONS_BLUE_DEVIL:
-    case MONS_HUNGRY_GHOST:
-        return 32;
-
-    case MONS_FLAYED_GHOST:
-    case MONS_HAIRY_DEVIL:
-        return 30;
-
-    case MONS_LICH:
-        return 24;
-
-    case MONS_IMP:
-    case MONS_SHADOW_DRAGON:
-    case MONS_DEATH_DRAKE:
-        return 20;
-
-    case MONS_RED_DEVIL:
-        return 13;
-
-    case MONS_HELL_KNIGHT:
-        return 14;
+    case MONS_QUICKSILVER_DRAGON:
+    case MONS_VAPOUR:
+        return 5;
 
-    case MONS_NECROMANCER:
-    case MONS_SIMULACRUM_LARGE:
-    case MONS_SIMULACRUM_SMALL:
-        return 12;
+    case MONS_AIR_ELEMENTAL:
+    case MONS_DEEP_ELF_CONJURER:
+    case MONS_EARTH_ELEMENTAL:
+    case MONS_FIRE_ELEMENTAL:
+        return 4;
 
     case MONS_ANCIENT_LICH:
-        return 6;
+    case MONS_DEEP_ELF_ANNIHILATOR:
+    case MONS_DEEP_ELF_DEATH_MAGE:
+    case MONS_DEEP_ELF_DEMONOLOGIST:
+    case MONS_DEEP_ELF_PRIEST:
+    case MONS_DEEP_ELF_SORCERER:
+    case MONS_GUARDIAN_NAGA:
+        return 3;
+
+    case MONS_PULSATING_LUMP:
+    case MONS_SHINING_EYE:
+    case MONS_TOENAIL_GOLEM:
+        return 2;
 
     default:
         return 0;
     }
 }
 
+// The Orcish Mines
 int mons_mineorc_level(int mcls)
 {
     int mlev = absdungeon_depth(BRANCH_ORCISH_MINES, 1);
@@ -1207,7 +1135,7 @@ int mons_mineorc_level(int mcls)
     }
 
     return (mlev);
-}                               // end mons_mineorc_level()
+}
 
 int mons_mineorc_rare(int mcls)
 {
@@ -1256,48 +1184,130 @@ int mons_mineorc_rare(int mcls)
     default:
         return 0;
     }
-}                               // end mons_mineorc_rare()
+}
 
-int mons_hive_level(int mcls)
+// The Elven Halls
+int mons_hallelf_level(int mcls)
 {
-    int mlev = absdungeon_depth(BRANCH_HIVE, 1);
+    int mlev = absdungeon_depth(BRANCH_ELVEN_HALLS, 1);
 
     switch (mcls)
     {
-    case MONS_PLANT:
-    case MONS_KILLER_BEE:
-        mlev += 0;
+    case MONS_DEEP_ELF_SOLDIER:
+    case MONS_DEEP_ELF_FIGHTER:
+    case MONS_ORC:
+    case MONS_ORC_WARRIOR:
+        mlev++;
         break;
 
-    case MONS_KILLER_BEE_LARVA:
+    case MONS_ORC_WIZARD:
+    case MONS_DEEP_ELF_MAGE:
+    case MONS_DEEP_ELF_SUMMONER:
         mlev += 2;
         break;
 
+    case MONS_FUNGUS:
+    case MONS_DEEP_ELF_CONJURER:
+    case MONS_SHAPESHIFTER:
+    case MONS_ORC_KNIGHT:
+        mlev += 3;
+        break;
+
+    case MONS_ORC_SORCERER:
+    case MONS_DEEP_ELF_PRIEST:
+    case MONS_GLOWING_SHAPESHIFTER:
+    case MONS_DEEP_ELF_KNIGHT:
+        mlev += 4;
+        break;
+
+    case MONS_ORC_PRIEST:
+    case MONS_ORC_HIGH_PRIEST:
+        mlev += 5;
+        break;
+
+    case MONS_DEEP_ELF_HIGH_PRIEST:
+    case MONS_DEEP_ELF_DEMONOLOGIST:
+    case MONS_DEEP_ELF_ANNIHILATOR:
+    case MONS_DEEP_ELF_SORCERER:
+    case MONS_DEEP_ELF_DEATH_MAGE:
+        mlev += 7;
+        break;
+
+    case MONS_DEEP_ELF_BLADEMASTER:
+    case MONS_DEEP_ELF_MASTER_ARCHER:
+        mlev += 10;
+        break;
+
     default:
-        return 99;
+        mlev += 99;
+        break;
     }
 
     return (mlev);
-}                               // end mons_hive_level()
+}
 
-int mons_hive_rare(int mcls)
+int mons_hallelf_rare(int mcls)
 {
     switch (mcls)
     {
-    case MONS_KILLER_BEE:
+    case MONS_FUNGUS:
         return 300;
 
-    case MONS_PLANT:
+    case MONS_DEEP_ELF_SOLDIER:
+    case MONS_DEEP_ELF_FIGHTER:
+    case MONS_DEEP_ELF_MAGE:
         return 100;
 
-    case MONS_KILLER_BEE_LARVA:
-        return 50;
+    case MONS_DEEP_ELF_KNIGHT:
+        return 80;
+
+    case MONS_DEEP_ELF_SUMMONER:
+        return 72;
+
+    case MONS_DEEP_ELF_CONJURER:
+        return 63;
+
+    case MONS_DEEP_ELF_PRIEST:
+        return 44;
+
+    case MONS_SHAPESHIFTER:
+        return 25;
+
+    case MONS_ORC:
+        return 20;
+
+    case MONS_DEEP_ELF_DEMONOLOGIST:
+    case MONS_DEEP_ELF_SORCERER:
+        return 17;
+
+    case MONS_DEEP_ELF_ANNIHILATOR:
+    case MONS_DEEP_ELF_DEATH_MAGE:
+    case MONS_ORC_WIZARD:
+        return 13;
+
+    case MONS_ORC_WARRIOR:
+        return 11;
+
+    case MONS_DEEP_ELF_HIGH_PRIEST:
+    case MONS_ORC_SORCERER:
+    case MONS_GLOWING_SHAPESHIFTER:
+        return 10;
+
+    case MONS_ORC_KNIGHT:
+    case MONS_ORC_PRIEST:
+    case MONS_ORC_HIGH_PRIEST:
+        return 5;
+
+    case MONS_DEEP_ELF_BLADEMASTER:
+    case MONS_DEEP_ELF_MASTER_ARCHER:
+        return 1;
 
     default:
         return 0;
     }
-}                               // end mons_hive_rare()
+}
 
+// The Lair
 int mons_lair_level(int mcls)
 {
     int mlev = absdungeon_depth(BRANCH_LAIR, 1);
@@ -1374,6 +1384,7 @@ int mons_lair_level(int mcls)
     case MONS_HYDRA:
     case MONS_OKLOB_PLANT:
     case MONS_WYVERN:
+    case MONS_TRAPDOOR_SPIDER:
         mlev += 7;
         break;
 
@@ -1398,7 +1409,7 @@ int mons_lair_level(int mcls)
     }
 
     return (mlev);
-}                               // end mons_lair_level()
+}
 
 int mons_lair_rare(int mcls)
 {
@@ -1510,6 +1521,7 @@ int mons_lair_rare(int mcls)
 
     case MONS_YELLOW_WASP:
     case MONS_BUTTERFLY:
+    case MONS_TRAPDOOR_SPIDER:
         return 5;
 
     case MONS_GIANT_SPORE:
@@ -1518,13 +1530,320 @@ int mons_lair_rare(int mcls)
     default:
         return 0;
     }
-}                               // end mons_lair_rare()
+}
+
+// The Swamp
+int mons_swamp_level(int mcls)
+{
+    int mlev = absdungeon_depth(BRANCH_SWAMP, 1);
+
+    switch (mcls)
+    {
+    case MONS_GIANT_BAT:
+    case MONS_GIANT_BLOWFLY:
+    case MONS_GIANT_FROG:
+    case MONS_GIANT_AMOEBA:
+    case MONS_GIANT_SLUG:
+    case MONS_GIANT_NEWT:
+    case MONS_GIANT_GECKO:
+    case MONS_RAT:
+    case MONS_SWAMP_DRAKE:
+    case MONS_WORM:
+    case MONS_SWAMP_WORM:
+        mlev++;
+        break;
+
+    case MONS_GIANT_BROWN_FROG:
+    case MONS_FUNGUS:
+    case MONS_NECROPHAGE:
+    case MONS_PLANT:
+    case MONS_SNAKE:
+    case MONS_BUTTERFLY:
+    case MONS_GIANT_LIZARD:
+    case MONS_GIANT_MOSQUITO:
+    case MONS_GIANT_SNAIL:
+    case MONS_HYDRA:
+        mlev += 2;
+        break;
+
+    case MONS_BROWN_SNAKE:
+    case MONS_HUNGRY_GHOST:
+    case MONS_INSUBSTANTIAL_WISP:
+    case MONS_JELLY:
+    case MONS_KOMODO_DRAGON:
+    case MONS_PHANTOM:
+    case MONS_RED_WASP:
+    case MONS_SPINY_FROG:
+    case MONS_SWAMP_DRAGON:
+    case MONS_UGLY_THING:
+        mlev += 3;
+        break;
+
+    case MONS_BLINK_FROG:
+    case MONS_SLIME_CREATURE:
+    case MONS_VERY_UGLY_THING:
+    case MONS_VAPOUR:
+    case MONS_TENTACLED_MONSTROSITY:
+        mlev += 4;
+        break;
+
+    default:
+        mlev += 99;
+    }
+
+    return (mlev);
+}
+
+int mons_swamp_rare(int mcls)
+{
+    switch (mcls)
+    {
+    case MONS_GIANT_MOSQUITO:
+        return 250;
+
+    case MONS_PLANT:
+        return 200;
+
+    case MONS_GIANT_FROG:
+        return 150;
+
+    case MONS_GIANT_BLOWFLY:
+        return 100;
+
+    case MONS_GIANT_BAT:
+    case MONS_FUNGUS:
+        return 99;
+
+    case MONS_GIANT_BROWN_FROG:
+        return 90;
+
+    case MONS_SWAMP_DRAKE:
+        return 80;
+
+    case MONS_HYDRA:
+        return 70;
+
+    case MONS_RAT:
+        return 61;
+
+    case MONS_SLIME_CREATURE:
+        return 54;
+
+    case MONS_SNAKE:
+        return 52;
+
+    case MONS_INSUBSTANTIAL_WISP:
+        return 43;
+
+    case MONS_BROWN_SNAKE:
+        return 33;
+
+    case MONS_RED_WASP:
+    case MONS_SWAMP_DRAGON:
+    case MONS_SPINY_FROG:
+        return 30;
+
+    case MONS_JELLY:
+    case MONS_BUTTERFLY:
+    case MONS_GIANT_LIZARD:
+        return 25;
+
+    case MONS_WORM:
+        return 20;
+
+    case MONS_KOMODO_DRAGON:
+    case MONS_VERY_UGLY_THING:
+    case MONS_VAPOUR:
+    case MONS_MERMAID:
+        return 15;
+
+    case MONS_PHANTOM:
+    case MONS_UGLY_THING:
+    case MONS_HUNGRY_GHOST:
+        return 13;
+
+    case MONS_NECROPHAGE:
+        return 12;
+
+    case MONS_SIREN:
+    case MONS_BLINK_FROG:
+    case MONS_GIANT_AMOEBA:
+    case MONS_GIANT_GECKO:
+    case MONS_GIANT_NEWT:
+    case MONS_GIANT_SLUG:
+    case MONS_GIANT_SNAIL:
+        return 10;
+
+    case MONS_TENTACLED_MONSTROSITY:
+        return 5;
+
+    default:
+        return 0;
+    }
+}
 
+// The Shoals
+int mons_shoals_level(int mcls)
+{
+    int mlev = absdungeon_depth(BRANCH_SHOALS, 1);
+    switch (mcls)
+    {
+    case MONS_BUTTERFLY:
+    case MONS_PLANT:
+    case MONS_GIANT_BAT:
+        break;
+
+    case MONS_MERFOLK:
+    case MONS_MERMAID:
+    case MONS_CENTAUR:
+    case MONS_ETTIN:
+    case MONS_SHEEP:
+    case MONS_HIPPOGRIFF:
+        mlev++;
+        break;
+
+    case MONS_SIREN:
+    case MONS_YAKTAUR:
+        mlev += 2;
+        break;
+
+    case MONS_CENTAUR_WARRIOR:
+    case MONS_CYCLOPS:          // will have a sheep band
+        mlev += 3;
+        break;
+
+    case MONS_STONE_GIANT:
+    case MONS_OKLOB_PLANT:
+        mlev += 4;
+        break;
+
+    case MONS_YAKTAUR_CAPTAIN:
+        mlev += 5;
+        break;
+
+    default:
+        mlev += 99;
+    }
+    return mlev;
+}
+
+int mons_shoals_rare(int mcls)
+{
+    switch (mcls)
+    {
+    case MONS_PLANT:
+        return 150;
+
+    case MONS_ETTIN:
+    case MONS_SHEEP:
+    case MONS_MERFOLK:
+        return 50;
+
+    case MONS_MERMAID:
+        return 40;
+
+    case MONS_HIPPOGRIFF:
+    case MONS_GIANT_BAT:
+    case MONS_BUTTERFLY:
+    case MONS_CENTAUR:
+        return 35;
+
+    case MONS_SIREN:
+    case MONS_YAKTAUR:
+        return 25;
+
+    case MONS_CYCLOPS:
+    case MONS_CENTAUR_WARRIOR:
+        return 20;
+
+    case MONS_STONE_GIANT:
+    case MONS_YAKTAUR_CAPTAIN:
+        return 10;
+
+    case MONS_OKLOB_PLANT:
+        return 5;
+    default:
+        return 0;
+    }
+}
+
+// The Snake Pit
+int mons_pitsnake_level(int mcls)
+{
+    int mlev = absdungeon_depth(BRANCH_SNAKE_PIT, 1);
+
+    switch (mcls)
+    {
+    case MONS_SMALL_SNAKE:
+    case MONS_SNAKE:
+        mlev++;
+        break;
+
+    case MONS_BROWN_SNAKE:
+    case MONS_BLACK_SNAKE:
+    case MONS_YELLOW_SNAKE:
+    case MONS_GREY_SNAKE:
+    case MONS_NAGA:
+        mlev += 2;
+        break;
+
+    case MONS_NAGA_WARRIOR:
+    case MONS_NAGA_MAGE:
+        mlev += 3;
+        break;
+
+    case MONS_GUARDIAN_NAGA:
+        mlev += 4;
+        break;
+
+    case MONS_GREATER_NAGA:
+        mlev += 5;
+        break;
+
+    default:
+        mlev += 99;
+    }
+
+    return (mlev);
+}
+
+int mons_pitsnake_rare(int mcls)
+{
+    switch (mcls)
+    {
+    case MONS_SNAKE:
+    case MONS_BROWN_SNAKE:
+        return 99;
+
+    case MONS_BLACK_SNAKE:
+        return 72;
+
+    case MONS_NAGA:
+        return 53;
+
+    case MONS_NAGA_WARRIOR:
+    case MONS_NAGA_MAGE:
+        return 34;
+
+    case MONS_YELLOW_SNAKE:
+    case MONS_GREY_SNAKE:
+        return 32;
+
+    case MONS_GREATER_NAGA:
+    case MONS_GUARDIAN_NAGA:
+    case MONS_SMALL_SNAKE:
+        return 15;
+
+    default:
+        return 0;
+    }
+}
+
+// The Slime Pits
 int mons_pitslime_level(int mcls)
 {
     int mlev = absdungeon_depth(BRANCH_SLIME_PITS, 1);
 
-
     switch (mcls)
     {
     case MONS_JELLY:
@@ -1568,7 +1887,7 @@ int mons_pitslime_level(int mcls)
     }
 
     return (mlev);
-}                               // end mons_pitslime_level()
+}
 
 int mons_pitslime_rare(int mcls)
 {
@@ -1610,8 +1929,64 @@ int mons_pitslime_rare(int mcls)
     default:
         return 0;
     }
-}                               // end mons_pitslime_rare()
+}
+
+// The Hive
+int mons_hive_level(int mcls)
+{
+    int mlev = absdungeon_depth(BRANCH_HIVE, 1);
+
+    switch (mcls)
+    {
+    case MONS_PLANT:
+    case MONS_KILLER_BEE:
+        mlev += 0;
+        break;
+
+    case MONS_KILLER_BEE_LARVA:
+        mlev += 2;
+        break;
+
+    default:
+        return 99;
+    }
+
+    return (mlev);
+}
+
+int mons_hive_rare(int mcls)
+{
+    switch (mcls)
+    {
+    case MONS_KILLER_BEE:
+        return 300;
+
+    case MONS_PLANT:
+        return 100;
+
+    case MONS_KILLER_BEE_LARVA:
+        return 50;
+
+    default:
+        return 0;
+    }
+}
+
+// The Hall of Blades
+int mons_hallblade_level(int mcls)
+{
+    if (mcls == MONS_DANCING_WEAPON)
+        return absdungeon_depth(BRANCH_HALL_OF_BLADES, 1);
+    else
+        return 0;
+}
+
+int mons_hallblade_rare(int mcls)
+{
+    return ((mcls == MONS_DANCING_WEAPON) ? 1000 : 0);
+}
 
+// The Crypt
 int mons_crypt_level(int mcls)
 {
     int mlev = absdungeon_depth(BRANCH_CRYPT, 1);
@@ -1675,7 +2050,7 @@ int mons_crypt_level(int mcls)
     }
 
     return (mlev);
-}                               // end mons_crypt_level()
+}
 
 int mons_crypt_rare(int mcls)
 {
@@ -1757,199 +2132,9 @@ int mons_crypt_rare(int mcls)
     default:
         return 0;
     }
-}                               // end mons_crypt_rare()
-
-int mons_pitsnake_level(int mcls)
-{
-    int mlev = absdungeon_depth(BRANCH_SNAKE_PIT, 1);
-
-    switch (mcls)
-    {
-    case MONS_SMALL_SNAKE:
-    case MONS_SNAKE:
-        mlev++;
-        break;
-
-    case MONS_BROWN_SNAKE:
-    case MONS_BLACK_SNAKE:
-    case MONS_YELLOW_SNAKE:
-    case MONS_GREY_SNAKE:
-    case MONS_NAGA:
-        mlev += 2;
-        break;
-
-    case MONS_NAGA_WARRIOR:
-    case MONS_NAGA_MAGE:
-        mlev += 3;
-        break;
-
-    case MONS_GUARDIAN_NAGA:
-        mlev += 4;
-        break;
-
-    case MONS_GREATER_NAGA:
-        mlev += 5;
-        break;
-
-    default:
-        mlev += 99;
-    }
-
-    return (mlev);
-}                               // end mons_pitsnake_level()
-
-int mons_pitsnake_rare(int mcls)
-{
-    switch (mcls)
-    {
-    case MONS_SNAKE:
-    case MONS_BROWN_SNAKE:
-        return 99;
-
-    case MONS_BLACK_SNAKE:
-        return 72;
-
-    case MONS_NAGA:
-        return 53;
-
-    case MONS_NAGA_WARRIOR:
-    case MONS_NAGA_MAGE:
-        return 34;
-
-    case MONS_YELLOW_SNAKE:
-    case MONS_GREY_SNAKE:
-        return 32;
-
-    case MONS_GREATER_NAGA:
-    case MONS_GUARDIAN_NAGA:
-    case MONS_SMALL_SNAKE:
-        return 15;
-
-    default:
-        return 0;
-    }
-}                               // end mons_pitsnake_rare()
-
-int mons_hallelf_level(int mcls)
-{
-    int mlev = absdungeon_depth(BRANCH_ELVEN_HALLS, 1);
-
-    switch (mcls)
-    {
-    case MONS_DEEP_ELF_SOLDIER:
-    case MONS_DEEP_ELF_FIGHTER:
-    case MONS_ORC:
-    case MONS_ORC_WARRIOR:
-        mlev++;
-        break;
-
-    case MONS_ORC_WIZARD:
-    case MONS_DEEP_ELF_MAGE:
-    case MONS_DEEP_ELF_SUMMONER:
-        mlev += 2;
-        break;
-
-    case MONS_FUNGUS:
-    case MONS_DEEP_ELF_CONJURER:
-    case MONS_SHAPESHIFTER:
-    case MONS_ORC_KNIGHT:
-        mlev += 3;
-        break;
-
-    case MONS_ORC_SORCERER:
-    case MONS_DEEP_ELF_PRIEST:
-    case MONS_GLOWING_SHAPESHIFTER:
-    case MONS_DEEP_ELF_KNIGHT:
-        mlev += 4;
-        break;
-
-    case MONS_ORC_PRIEST:
-    case MONS_ORC_HIGH_PRIEST:
-        mlev += 5;
-        break;
-
-    case MONS_DEEP_ELF_HIGH_PRIEST:
-    case MONS_DEEP_ELF_DEMONOLOGIST:
-    case MONS_DEEP_ELF_ANNIHILATOR:
-    case MONS_DEEP_ELF_SORCERER:
-    case MONS_DEEP_ELF_DEATH_MAGE:
-        mlev += 7;
-        break;
-
-    case MONS_DEEP_ELF_BLADEMASTER:
-    case MONS_DEEP_ELF_MASTER_ARCHER:
-        mlev += 10;
-        break;
-
-    default:
-        mlev += 99;
-        break;
-    }
-
-    return (mlev);
-}                               // end mons_hallelf_level()
-
-int mons_hallelf_rare(int mcls)
-{
-    switch (mcls)
-    {
-    case MONS_FUNGUS:
-        return 300;
-
-    case MONS_DEEP_ELF_SOLDIER:
-    case MONS_DEEP_ELF_FIGHTER:
-    case MONS_DEEP_ELF_MAGE:
-        return 100;
-
-    case MONS_DEEP_ELF_KNIGHT:
-        return 80;
-
-    case MONS_DEEP_ELF_SUMMONER:
-        return 72;
-
-    case MONS_DEEP_ELF_CONJURER:
-        return 63;
-
-    case MONS_DEEP_ELF_PRIEST:
-        return 44;
-
-    case MONS_SHAPESHIFTER:
-        return 25;
-
-    case MONS_ORC:
-        return 20;
-
-    case MONS_DEEP_ELF_DEMONOLOGIST:
-    case MONS_DEEP_ELF_SORCERER:
-        return 17;
-
-    case MONS_DEEP_ELF_ANNIHILATOR:
-    case MONS_DEEP_ELF_DEATH_MAGE:
-    case MONS_ORC_WIZARD:
-        return 13;
-
-    case MONS_ORC_WARRIOR:
-        return 11;
-
-    case MONS_DEEP_ELF_HIGH_PRIEST:
-    case MONS_ORC_SORCERER:
-    case MONS_GLOWING_SHAPESHIFTER:
-        return 10;
-
-    case MONS_ORC_KNIGHT:
-    case MONS_ORC_PRIEST:
-    case MONS_ORC_HIGH_PRIEST:
-        return 5;
-
-    case MONS_DEEP_ELF_BLADEMASTER:
-    case MONS_DEEP_ELF_MASTER_ARCHER:
-        return 1;
-
-    default:
-        return 0;
-    }
-}                               // end mons_hallelf_rare()
+}
 
+// The Tomb
 int mons_tomb_level(int mcls)
 {
     int mlev = absdungeon_depth(BRANCH_TOMB, 1);
@@ -1964,6 +2149,7 @@ int mons_tomb_level(int mcls)
     case MONS_ZOMBIE_LARGE:
     case MONS_SKELETON_SMALL:
     case MONS_SKELETON_LARGE:
+    case MONS_TRAPDOOR_SPIDER:
         mlev++;
         break;
 
@@ -1989,7 +2175,7 @@ int mons_tomb_level(int mcls)
     }
 
     return (mlev);
-}                               // end mons_tomb_level()
+}
 
 int mons_tomb_rare(int mcls)
 {
@@ -2025,265 +2211,16 @@ int mons_tomb_rare(int mcls)
     case MONS_ANCIENT_LICH:
         return 2;
 
-    default:
-        return 0;
-    }
-}                               // end mons_tomb_rare()
-
-int mons_shoals_level(int mcls)
-{
-    int mlev = absdungeon_depth(BRANCH_SHOALS, 1);
-    switch (mcls)
-    {
-    case MONS_BUTTERFLY:
-    case MONS_PLANT:
-    case MONS_GIANT_BAT:
-        break;
-
-    case MONS_MERFOLK:
-    case MONS_MERMAID:
-    case MONS_CENTAUR:
-    case MONS_ETTIN:
-    case MONS_SHEEP:
-    case MONS_HIPPOGRIFF:
-        mlev++;
-        break;
-
-    case MONS_SIREN:
-    case MONS_YAKTAUR:
-        mlev += 2;
-        break;
-
-    case MONS_CENTAUR_WARRIOR:
-    case MONS_CYCLOPS:          // will have a sheep band
-        mlev += 3;
-        break;
-
-    case MONS_STONE_GIANT:
-    case MONS_OKLOB_PLANT:
-        mlev += 4;
-        break;
-
-    case MONS_YAKTAUR_CAPTAIN:
-        mlev += 5;
-        break;
-
-    default:
-        mlev += 99;
-    }
-    return mlev;
-}
-
-int mons_shoals_rare(int mcls)
-{
-    switch (mcls)
-    {
-    case MONS_PLANT:
-        return 150;
-
-    case MONS_ETTIN:
-    case MONS_SHEEP:
-    case MONS_MERFOLK:
-        return 50;
-
-    case MONS_MERMAID:
-        return 40;
-
-    case MONS_SIREN:
-    case MONS_HIPPOGRIFF:
-    case MONS_GIANT_BAT:
-    case MONS_BUTTERFLY:
-    case MONS_CENTAUR:
-        return 35;
-
-    case MONS_YAKTAUR:
-        return 25;
-
-    case MONS_CYCLOPS:
-    case MONS_CENTAUR_WARRIOR:
-        return 20;
-
-    case MONS_STONE_GIANT:
-    case MONS_YAKTAUR_CAPTAIN:
-        return 10;
+    // A nod to the fabled pyramid traps, these should be really rare.
+    case MONS_TRAPDOOR_SPIDER:
+        return 1;
 
-    case MONS_OKLOB_PLANT:
-        return 5;
     default:
         return 0;
     }
 }
 
-int mons_swamp_level(int mcls)
-{
-    int mlev = absdungeon_depth(BRANCH_SWAMP, 1);
-
-    switch (mcls)
-    {
-    case MONS_GIANT_BAT:
-    case MONS_GIANT_BLOWFLY:
-    case MONS_GIANT_FROG:
-    case MONS_GIANT_AMOEBA:
-    case MONS_GIANT_SLUG:
-    case MONS_GIANT_NEWT:
-    case MONS_GIANT_GECKO:
-    case MONS_RAT:
-    case MONS_SWAMP_DRAKE:
-    case MONS_WORM:
-    case MONS_SWAMP_WORM:
-        mlev++;
-        break;
-
-    case MONS_GIANT_BROWN_FROG:
-    case MONS_FUNGUS:
-    case MONS_NECROPHAGE:
-    case MONS_PLANT:
-    case MONS_SNAKE:
-    case MONS_BUTTERFLY:
-    case MONS_GIANT_LIZARD:
-    case MONS_GIANT_MOSQUITO:
-    case MONS_GIANT_SNAIL:
-    case MONS_HYDRA:
-        mlev += 2;
-        break;
-
-    case MONS_BROWN_SNAKE:
-    case MONS_HUNGRY_GHOST:
-    case MONS_INSUBSTANTIAL_WISP:
-    case MONS_JELLY:
-    case MONS_KOMODO_DRAGON:
-    case MONS_PHANTOM:
-    case MONS_RED_WASP:
-    case MONS_SPINY_FROG:
-    case MONS_SWAMP_DRAGON:
-    case MONS_UGLY_THING:
-        mlev += 3;
-        break;
-
-    case MONS_BLINK_FROG:
-    case MONS_SLIME_CREATURE:
-    case MONS_VERY_UGLY_THING:
-    case MONS_VAPOUR:
-    case MONS_TENTACLED_MONSTROSITY:
-        mlev += 4;
-        break;
-
-    default:
-        mlev += 99;
-    }
-
-    return (mlev);
-}                               // end mons_swamp_level()
-
-int mons_swamp_rare(int mcls)
-{
-    switch (mcls)
-    {
-    case MONS_GIANT_MOSQUITO:
-        return 250;
-
-    case MONS_PLANT:
-        return 200;
-
-    case MONS_GIANT_FROG:
-        return 150;
-
-    case MONS_GIANT_BLOWFLY:
-        return 100;
-
-    case MONS_GIANT_BAT:
-    case MONS_FUNGUS:
-        return 99;
-
-    case MONS_GIANT_BROWN_FROG:
-        return 90;
-
-    case MONS_SWAMP_DRAKE:
-        return 80;
-
-    case MONS_HYDRA:
-        return 70;
-
-    case MONS_RAT:
-        return 61;
-
-    case MONS_SLIME_CREATURE:
-        return 54;
-
-    case MONS_SNAKE:
-        return 52;
-
-    case MONS_INSUBSTANTIAL_WISP:
-        return 43;
-
-    case MONS_BROWN_SNAKE:
-        return 33;
-
-    case MONS_RED_WASP:
-    case MONS_SWAMP_DRAGON:
-    case MONS_SPINY_FROG:
-        return 30;
-
-    case MONS_JELLY:
-    case MONS_BUTTERFLY:
-    case MONS_GIANT_LIZARD:
-        return 25;
-
-    case MONS_WORM:
-        return 20;
-
-    case MONS_KOMODO_DRAGON:
-    case MONS_VERY_UGLY_THING:
-    case MONS_VAPOUR:
-    case MONS_MERMAID:
-        return 15;
-
-    case MONS_PHANTOM:
-    case MONS_UGLY_THING:
-    case MONS_HUNGRY_GHOST:
-        return 13;
-
-    case MONS_NECROPHAGE:
-        return 12;
-
-    case MONS_SIREN:
-    case MONS_BLINK_FROG:
-    case MONS_GIANT_AMOEBA:
-    case MONS_GIANT_GECKO:
-    case MONS_GIANT_NEWT:
-    case MONS_GIANT_SLUG:
-    case MONS_GIANT_SNAIL:
-        return 10;
-
-    case MONS_TENTACLED_MONSTROSITY:
-        return 5;
-
-    default:
-        return 0;
-    }
-}                               // end mons_swamp_rare()
-
-int mons_hallblade_level(int mcls)
-{
-    if (mcls == MONS_DANCING_WEAPON)
-        return absdungeon_depth(BRANCH_HALL_OF_BLADES, 1);
-    else
-        return 0;
-}                               // end mons_hallblade_level
-
-int mons_hallblade_rare(int mcls)
-{
-    return ((mcls == MONS_DANCING_WEAPON) ? 1000 : 0);
-}                               // end mons_hallblade_rare()
-
-//    New branch must be added in:
-//    - new_game stair location
-//    - down/up stairs (to and back) misc.cc
-//    - new_level (2 places) (misc.cc)
-//    - item_check items.cc
-//    - ouch ouch.cc (death message)
-//    - and here...
-
+// The Halls of Zot
 int mons_hallzot_level(int mcls)
 {
     int mlev = absdungeon_depth(BRANCH_HALL_OF_ZOT, 0);
@@ -2338,7 +2275,7 @@ int mons_hallzot_level(int mcls)
     }
 
     return (mlev);
-}                               // end mons_hallzot_level()
+}
 
 int mons_hallzot_rare(int mcls)
 {
@@ -2389,11 +2326,11 @@ int mons_hallzot_rare(int mcls)
     default:
         return 0;
     }
-}                               // end mons_hallzot_rare()
+}
 
+// The Caverns (unused)
 int mons_caverns_level( int mcls )
 {
-
     int mlev = absdungeon_depth(BRANCH_CAVERNS, 1);
 
     switch (mcls)
@@ -2453,529 +2390,628 @@ int mons_caverns_rare( int mcls )
     }
 }
 
-int mons_standard_level(int mcls)
+// The Hells
+
+// The Iron City of Dis
+int mons_dis_level(int mcls)
 {
+    int mlev = 26;
+
     switch (mcls)
     {
-    case MONS_GOBLIN:
-    case MONS_GIANT_NEWT:
-        return 1;
+    case MONS_CLAY_GOLEM:
+    case MONS_IMP:
+    case MONS_NECROPHAGE:
+    case MONS_RED_DEVIL:
+    case MONS_SKELETAL_WARRIOR:
+    case MONS_ZOMBIE_LARGE:
+        mlev++;
+        break;
 
-    case MONS_GIANT_COCKROACH:
-    case MONS_OOZE:
-    case MONS_SMALL_SNAKE:
-        return 2;
+    case MONS_HELL_HOUND:
+    case MONS_HELL_KNIGHT:
+    case MONS_SKELETON_LARGE:
+    case MONS_PHANTOM:
+    case MONS_ROTTING_DEVIL:
+    case MONS_SHADOW:
+    case MONS_SKELETON_SMALL:
+    case MONS_STONE_GOLEM:
+    case MONS_TORMENTOR:
+    case MONS_WIGHT:
+    case MONS_ZOMBIE_SMALL:
+        mlev += 2;
+        break;
 
-    case MONS_GIANT_BAT:
-    case MONS_KOBOLD:
-    case MONS_RAT:
-        return 4;
+    case MONS_EFREET:
+    case MONS_FLYING_SKULL:
+    case MONS_HELLION:
+    case MONS_HELL_HOG:
+    case MONS_IRON_GOLEM:
+    case MONS_MUMMY:
+        mlev += 3;
+        break;
 
-    case MONS_GIANT_GECKO:
-    case MONS_GIANT_MITE:
-    case MONS_GNOLL:
-    case MONS_HOBGOBLIN:
-    case MONS_JACKAL:
-    case MONS_KILLER_BEE_LARVA:
-        return 5;
+    case MONS_FLAYED_GHOST:
+    case MONS_FREEZING_WRAITH:
+    case MONS_DEATH_DRAKE:
+    case MONS_HAIRY_DEVIL:
+    case MONS_IRON_DEVIL:
+    case MONS_VAMPIRE:
+    case MONS_WRAITH:
+        mlev += 3;
+        break;
 
-    case MONS_WORM:
-    case MONS_SNAKE:
-    case MONS_QUOKKA:
-        return 6;
+    case MONS_BLUE_DEVIL:
+    case MONS_DANCING_WEAPON:
+    case MONS_FLAMING_CORPSE:
+    case MONS_ICE_DEVIL:
+    case MONS_ICE_DRAGON:
+    case MONS_LICH:
+    case MONS_REAPER:
+    case MONS_SOUL_EATER:
+    case MONS_SPECTRAL_WARRIOR:
+        mlev += 5;
+        break;
 
-    case MONS_ORC:
-    case MONS_ORC_PRIEST:
-        return 7;
+    case MONS_ANCIENT_LICH:
+    case MONS_FIEND:
+    case MONS_IRON_DRAGON:
+    case MONS_SKELETAL_DRAGON:
+        mlev += 6;
+        break;
 
-    case MONS_FUNGUS:
-    case MONS_GIANT_ANT:
-    case MONS_GIANT_EYEBALL:
-    case MONS_HOUND:
-    case MONS_GIANT_IGUANA:
-    case MONS_OGRE:
-    case MONS_ORC_WIZARD:
-    case MONS_PHANTOM:
-    case MONS_SCORPION:
-        return 8;
+    default:
+        return 0;
+    }
 
-    case MONS_BROWN_SNAKE:
-    case MONS_CENTAUR:
-    case MONS_ICE_BEAST:
+    return (mlev);
+}
+
+int mons_dis_rare(int mcls)
+{
+    switch (mcls)
+    {
     case MONS_IMP:
-    case MONS_JELLY:
-    case MONS_NECROPHAGE:
-    case MONS_QUASIT:
+    case MONS_IRON_DEVIL:
+    case MONS_ZOMBIE_LARGE:
     case MONS_ZOMBIE_SMALL:
-        return 9;
-
-    case MONS_DEEP_ELF_SOLDIER:
-    case MONS_GIANT_BEETLE:
-    case MONS_GIANT_FROG:
-    case MONS_GIANT_SPORE:
-    case MONS_MUMMY:
-    case MONS_ORC_WARRIOR:
-    case MONS_STEAM_DRAGON:
-    case MONS_WIGHT:
-        return 10;
+        return 99;
 
-    case MONS_GIANT_LIZARD:
-    case MONS_HIPPOGRIFF:
-    case MONS_HUNGRY_GHOST:
-    case MONS_KILLER_BEE:
-    case MONS_SHADOW:
-    case MONS_YELLOW_WASP:
-        return 11;
+    case MONS_REAPER:
+        return 77;
 
-    case MONS_EYE_OF_DRAINING:
-    case MONS_GILA_MONSTER:
-    case MONS_MANTICORE:
-    case MONS_PLANT:
-    case MONS_WYVERN:
-        return 12;
+    case MONS_TORMENTOR:
+        return 66;
 
-    case MONS_BIG_KOBOLD:
-    case MONS_GIANT_BROWN_FROG:
-    case MONS_GIANT_CENTIPEDE:
-    case MONS_OKLOB_PLANT:
-    case MONS_TROLL:
-    case MONS_TWO_HEADED_OGRE:
-    case MONS_WOOD_GOLEM:
-    case MONS_YAK:
-        return 13;
+    case MONS_RED_DEVIL:
+    case MONS_SKELETAL_WARRIOR:
+        return 50;
 
-    case MONS_HILL_GIANT:
-    case MONS_KOMODO_DRAGON:
-    case MONS_SOLDIER_ANT:
-    case MONS_WOLF_SPIDER:
     case MONS_WRAITH:
-    case MONS_UNSEEN_HORROR:
-        return 14;
+        return 48;
 
-    case MONS_ARMOUR_MIMIC:
-    case MONS_BRAIN_WORM:
-    case MONS_CYCLOPS:
-    case MONS_EFREET:
-    case MONS_ETTIN:
-    case MONS_EYE_OF_DEVASTATION:
-    case MONS_GOLD_MIMIC:
-    case MONS_HYDRA:
-    case MONS_MOTTLED_DRAGON:
-    case MONS_POTION_MIMIC:
-    case MONS_SCROLL_MIMIC:
-    case MONS_SKELETAL_WARRIOR:
-    case MONS_WEAPON_MIMIC:
-        return 15;
+    case MONS_SHADOW:
+        return 56;
 
-    case MONS_BLINK_FROG:
-    case MONS_BUTTERFLY:
-    case MONS_GIANT_BLOWFLY:
-    case MONS_GUARDIAN_NAGA:
-    case MONS_RAKSHASA:
-    case MONS_SLIME_CREATURE:
-    case MONS_STONE_GOLEM:
-    case MONS_VAMPIRE:
-    case MONS_WANDERING_MUSHROOM:
-    case MONS_ZOMBIE_LARGE:
-        return 16;
+    case MONS_HELL_HOUND:
+        return 46;
 
-    case MONS_BOGGART:
-    case MONS_CENTAUR_WARRIOR:
-    case MONS_CLAY_GOLEM:
-    case MONS_GRIFFON:
-    case MONS_SHAPESHIFTER:
-    case MONS_UGLY_THING:
-    case MONS_WIZARD:
-    case MONS_SIMULACRUM_SMALL:
-    case MONS_SIMULACRUM_LARGE:
-        return 17;
+    case MONS_MUMMY:
+    case MONS_WIGHT:
+        return 45;
 
-    case MONS_DRAGON:
-    case MONS_GARGOYLE:
-    case MONS_GIANT_AMOEBA:
-    case MONS_KOBOLD_DEMONOLOGIST:
-        return 18;
+    case MONS_HELLION:
+    case MONS_BLUE_DEVIL:
+        return 40;
 
-    case MONS_GIANT_SLUG:
-    case MONS_IRON_GOLEM:
-    case MONS_OGRE_MAGE:
-    case MONS_ROCK_TROLL:
-    case MONS_TOENAIL_GOLEM:
-    case MONS_YAKTAUR:
-        return 19;
+    case MONS_FLYING_SKULL:
+        return 35;
 
-    case MONS_AIR_ELEMENTAL:
-    case MONS_DEEP_ELF_FIGHTER:
-    case MONS_DEEP_ELF_KNIGHT:
-    case MONS_DEEP_ELF_MAGE:
-    case MONS_DEEP_ELF_SUMMONER:
-    case MONS_EARTH_ELEMENTAL:
-    case MONS_FIRE_ELEMENTAL:
-    case MONS_GIANT_ORANGE_BRAIN:
-    case MONS_GIANT_SNAIL:
-    case MONS_GREAT_ORB_OF_EYES:
-    case MONS_ICE_DRAGON:
+    case MONS_FREEZING_WRAITH:
+    case MONS_ICE_DEVIL:
+        return 30;
+
+    case MONS_FLAMING_CORPSE:
+    case MONS_FLAYED_GHOST:
     case MONS_SKELETON_LARGE:
-    case MONS_NAGA_MAGE:
-    case MONS_NAGA_WARRIOR:
-    case MONS_NECROMANCER:
-    case MONS_ORC_KNIGHT:
-    case MONS_QUEEN_BEE:
-    case MONS_RED_WASP:
-    case MONS_SHADOW_WRAITH:
+    case MONS_NECROPHAGE:
     case MONS_SKELETON_SMALL:
-    case MONS_SPINY_WORM:
-    case MONS_VERY_UGLY_THING:
-        return 20;
+        return 25;
 
-    case MONS_BOULDER_BEETLE:
-    case MONS_ORC_HIGH_PRIEST:
-    case MONS_PULSATING_LUMP:
-        return 21;
+    case MONS_HELL_HOG:
+    case MONS_SKELETAL_DRAGON:
+        return 20;
 
-    case MONS_BORING_BEETLE:
-    case MONS_CRYSTAL_GOLEM:
-    case MONS_FLAYED_GHOST:
-    case MONS_FREEZING_WRAITH:
-    case MONS_REDBACK:
-    case MONS_SPHINX:
-    case MONS_VAPOUR:
-        return 22;
+    case MONS_VAMPIRE:
+        return 19;
 
-    case MONS_ORC_SORCERER:
-    case MONS_SHINING_EYE:
-        return 23;
+    case MONS_PHANTOM:
+        return 17;
 
-    case MONS_BUMBLEBEE:
-    case MONS_ORC_WARLORD:
-    case MONS_IRON_TROLL:
-    case MONS_YAKTAUR_CAPTAIN:
-        return 24;
+    case MONS_HAIRY_DEVIL:
+        return 15;
 
+    case MONS_CLAY_GOLEM:
     case MONS_DANCING_WEAPON:
-    case MONS_DEEP_TROLL:
-    case MONS_FIRE_GIANT:
-    case MONS_FROST_GIANT:
+    case MONS_EFREET:
     case MONS_HELL_KNIGHT:
-    case MONS_INSUBSTANTIAL_WISP:
+    case MONS_IRON_GOLEM:
     case MONS_LICH:
-    case MONS_STONE_GIANT:
-        return 25;
-
-    case MONS_DEEP_ELF_CONJURER:
+    case MONS_ROTTING_DEVIL:
+    case MONS_SOUL_EATER:
     case MONS_SPECTRAL_WARRIOR:
-    case MONS_STORM_DRAGON:
-        return 26;
-
-    case MONS_DEEP_ELF_PRIEST:
-    case MONS_GLOWING_SHAPESHIFTER:
-    case MONS_TENTACLED_MONSTROSITY:
-        return 27;
+    case MONS_STONE_GOLEM:
+        return 10;
 
-    case MONS_ANCIENT_LICH:
-    case MONS_DEEP_ELF_ANNIHILATOR:
-    case MONS_DEEP_ELF_DEATH_MAGE:
-    case MONS_DEEP_ELF_DEMONOLOGIST:
-    case MONS_DEEP_ELF_HIGH_PRIEST:
-    case MONS_DEEP_ELF_SORCERER:
-    case MONS_GOLDEN_DRAGON:
     case MONS_IRON_DRAGON:
-    case MONS_QUICKSILVER_DRAGON:
-    case MONS_SHADOW_DRAGON:
-    case MONS_SKELETAL_DRAGON:
-    case MONS_TITAN:
-        return 30;
-
-    case MONS_DEEP_ELF_BLADEMASTER:
-    case MONS_DEEP_ELF_MASTER_ARCHER:
-        return 33;
+        return 5;
 
-    case MONS_BIG_FISH:
-    case MONS_ELECTRICAL_EEL:
-    case MONS_GIANT_GOLDFISH:
-    case MONS_JELLYFISH:
-    case MONS_LAVA_FISH:
-    case MONS_LAVA_SNAKE:
-    case MONS_LAVA_WORM:
-    case MONS_SWAMP_WORM:
-    case MONS_WATER_ELEMENTAL:
-        return 500;
+    case MONS_ANCIENT_LICH:
+    case MONS_FIEND:
+        return 3;
 
     default:
-        return 99;
+        return 0;
     }
-}                               // end mons_standard_level()
+}
 
-int mons_standard_rare(int mcls)
+// Gehenna - the fire hell
+int mons_gehenna_level(int mcls)
 {
+    int mlev = 26;
+
     switch (mcls)
     {
-    case MONS_BIG_FISH:
-    case MONS_ELECTRICAL_EEL:
-    case MONS_GIANT_GOLDFISH:
-    case MONS_JELLYFISH:
-    case MONS_LAVA_FISH:
-    case MONS_LAVA_SNAKE:
-    case MONS_LAVA_WORM:
-    case MONS_SWAMP_WORM:
-    case MONS_WATER_ELEMENTAL:
-    case MONS_SALAMANDER:
-        return 500;
-
-    case MONS_GIANT_BAT:
-    case MONS_GIANT_FROG:
-    case MONS_GOBLIN:
-    case MONS_HILL_GIANT:
-    case MONS_HOBGOBLIN:
-    case MONS_IMP:
-    case MONS_KOBOLD:
+    case MONS_CLAY_GOLEM:
     case MONS_SKELETON_LARGE:
-    case MONS_ORC:
-    case MONS_RAT:
     case MONS_RED_DEVIL:
     case MONS_SKELETON_SMALL:
-    case MONS_UGLY_THING:
     case MONS_ZOMBIE_LARGE:
     case MONS_ZOMBIE_SMALL:
-        return 99;
+        mlev++;
+        break;
 
-    case MONS_CENTAUR_WARRIOR:
-    case MONS_GIANT_ANT:
-    case MONS_SNAKE:
-        return 80;
+    case MONS_HELL_HOG:
+    case MONS_HELL_HOUND:
+    case MONS_IMP:
+    case MONS_NECROPHAGE:
+    case MONS_STONE_GOLEM:
+        mlev += 2;
+        break;
 
-    case MONS_MERFOLK:
-    case MONS_MERMAID:
     case MONS_FLYING_SKULL:
-    case MONS_SLIME_CREATURE:
-        return 75;
+    case MONS_IRON_GOLEM:
+    case MONS_MUMMY:
+    case MONS_PHANTOM:
+    case MONS_ROTTING_DEVIL:
+    case MONS_SHADOW:
+    case MONS_WIGHT:
+        mlev += 3;
+        break;
 
-    case MONS_HELL_HOUND:
-        return 71;
+    case MONS_HAIRY_DEVIL:
+    case MONS_HELL_KNIGHT:
+    case MONS_VAMPIRE:
+    case MONS_WRAITH:
+        mlev += 4;
+        break;
 
-    case MONS_CENTAUR:
-    case MONS_CYCLOPS:
-    case MONS_GIANT_BROWN_FROG:
+    case MONS_EFREET:
+    case MONS_FLAMING_CORPSE:
+    case MONS_FLAYED_GHOST:
     case MONS_HELLION:
-    case MONS_HOUND:
-    case MONS_OGRE:
-    case MONS_ORC_WARRIOR:
-    case MONS_TROLL:
-    case MONS_YAK:
-    case MONS_YAKTAUR_CAPTAIN:
+    case MONS_TORMENTOR:
+        mlev += 5;
+        break;
+
+    case MONS_ANCIENT_LICH:
+    case MONS_FIEND:
+    case MONS_LICH:
+    case MONS_PIT_FIEND:
+    case MONS_REAPER:
+    case MONS_SERPENT_OF_HELL:
+    case MONS_SKELETAL_DRAGON:
+    case MONS_SOUL_EATER:
+    case MONS_SPECTRAL_WARRIOR:
+        mlev += 6;
+        break;
+
+    default:
+        return 0;
+    }
+
+    return (mlev);
+}
+
+int mons_gehenna_rare(int mcls)
+{
+    switch (mcls)
+    {
+    case MONS_SKELETON_LARGE:
+    case MONS_SKELETON_SMALL:
+    case MONS_ZOMBIE_LARGE:
+    case MONS_ZOMBIE_SMALL:
+        return 99;
+
+    case MONS_MUMMY:
         return 70;
 
-    case MONS_JELLY:
-    case MONS_ORC_KNIGHT:
-    case MONS_ROTTING_DEVIL:
+    case MONS_SHADOW:
+        return 61;
+
+    case MONS_RED_DEVIL:
+    case MONS_WIGHT:
         return 60;
 
-    case MONS_SHAPESHIFTER:
-        return 59;
+    case MONS_HELLION:
+        return 54;
 
-    case MONS_STONE_GIANT:
+    case MONS_WRAITH:
         return 53;
 
-    case MONS_BIG_KOBOLD:
-    case MONS_GIANT_BEETLE:
-    case MONS_GIANT_BLOWFLY:
-    case MONS_GIANT_COCKROACH:
-    case MONS_GIANT_GECKO:
-    case MONS_GIANT_IGUANA:
-    case MONS_GIANT_NEWT:
-    case MONS_HIPPOGRIFF:
-    case MONS_HYDRA:
-    case MONS_ICE_BEAST:
-    case MONS_KILLER_BEE:
-    case MONS_ORC_WIZARD:
-    case MONS_QUOKKA:
-    case MONS_SCORPION:
-    case MONS_TORMENTOR:
-    case MONS_UNSEEN_HORROR:
-    case MONS_WORM:
+    case MONS_NECROPHAGE:
+    case MONS_ROTTING_DEVIL:
         return 50;
 
-    case MONS_ROCK_TROLL:
-        return 48;
+    case MONS_VAMPIRE:
+        return 44;
 
-    case MONS_MANTICORE:
-    case MONS_OGRE_MAGE:
-        return 45;
+    case MONS_FLYING_SKULL:
+    case MONS_REAPER:
+        return 43;
 
-    case MONS_HUNGRY_GHOST:
-    case MONS_SHADOW:
+    case MONS_TORMENTOR:
+        return 42;
+
+    case MONS_HELL_HOUND:
         return 41;
 
-    case MONS_GIANT_CENTIPEDE:
-    case MONS_GIANT_EYEBALL:
-    case MONS_GIANT_SPORE:
-    case MONS_GRIFFON:
+    case MONS_FLAMING_CORPSE:
+    case MONS_FLAYED_GHOST:
+    case MONS_PHANTOM:
+        return 32;
+
+    case MONS_HELL_HOG:
+    case MONS_IMP:
+    case MONS_IRON_DEVIL:
+        return 30;
+
+    case MONS_LICH:
+        return 25;
+
+    case MONS_HELL_KNIGHT:
+        return 21;
+
     case MONS_HAIRY_DEVIL:
-    case MONS_JACKAL:
-    case MONS_MOTTLED_DRAGON:
+    case MONS_SPECTRAL_WARRIOR:
+        return 20;
+
+    case MONS_CLAY_GOLEM:
+    case MONS_SKELETAL_DRAGON:
+        return 10;
+
+    case MONS_STONE_GOLEM:
+        return 8;
+
+    case MONS_PIT_FIEND:
+        return 7;
+
+    case MONS_EFREET:
+    case MONS_FIEND:
+    case MONS_IRON_GOLEM:
+    case MONS_SOUL_EATER:
+        return 5;
+
+    case MONS_ANCIENT_LICH:
+    case MONS_SERPENT_OF_HELL:
+        return 4;
+
+    default:
+        return 0;
+    }
+}
+
+// Cocytus - the ice hell
+int mons_cocytus_level(int mcls)
+{
+    int mlev = 26;
+
+    switch (mcls)
+    {
+    case MONS_SKELETON_LARGE:
+    case MONS_NECROPHAGE:
+    case MONS_SKELETAL_WARRIOR:
+    case MONS_SKELETON_SMALL:
+    case MONS_ZOMBIE_LARGE:
+    case MONS_ZOMBIE_SMALL:
+    case MONS_SIMULACRUM_LARGE:
+    case MONS_SIMULACRUM_SMALL:
+        mlev++;
+        break;
+
+    case MONS_BLUE_DEVIL:
+    case MONS_ICE_BEAST:
     case MONS_PHANTOM:
-    case MONS_REAPER:
-    case MONS_TWO_HEADED_OGRE:
+    case MONS_SHADOW:
+        mlev += 2;
+        break;
+
+    case MONS_FLYING_SKULL:
+    case MONS_ROTTING_DEVIL:
+    case MONS_VAMPIRE:
     case MONS_WIGHT:
+        mlev += 3;
+        break;
+
+    case MONS_FREEZING_WRAITH:
+    case MONS_HAIRY_DEVIL:
+    case MONS_HUNGRY_GHOST:
+    case MONS_MUMMY:
+    case MONS_SPECTRAL_WARRIOR:
     case MONS_WRAITH:
-    case MONS_WYVERN:
-    case MONS_YAKTAUR:
-        return 40;
+        mlev += 4;
+        break;
 
-    case MONS_WOLF_SPIDER:
-        return 36;
+    case MONS_ICE_DEVIL:
+    case MONS_ICE_DRAGON:
+    case MONS_TORMENTOR:
+        mlev += 5;
+        break;
+
+    case MONS_ANCIENT_LICH:
+    case MONS_LICH:
+    case MONS_REAPER:
+    case MONS_SKELETAL_DRAGON:
+    case MONS_SOUL_EATER:
+        mlev += 6;
+        break;
+
+    default:
+        return 0;
+    }
+
+    return (mlev);
+}
 
+int mons_cocytus_rare(int mcls)
+{
+    switch (mcls)
+    {
     case MONS_FREEZING_WRAITH:
-    case MONS_GIANT_AMOEBA:
-    case MONS_GILA_MONSTER:
-    case MONS_GLOWING_SHAPESHIFTER:
-    case MONS_SOLDIER_ANT:
-        return 35;
+        return 87;
 
-    case MONS_BOULDER_BEETLE:
-        return 34;
+    case MONS_ICE_BEAST:
+    case MONS_SKELETON_LARGE:
+    case MONS_SKELETON_SMALL:
+    case MONS_ZOMBIE_LARGE:
+    case MONS_ZOMBIE_SMALL:
+        return 85;
 
-    case MONS_EYE_OF_DRAINING:
-        return 33;
+    case MONS_BLUE_DEVIL:
+    case MONS_ICE_DEVIL:
+        return 76;
 
-    case MONS_GIANT_SLUG:
-        return 32;
+    case MONS_FLYING_SKULL:
+        return 57;
+
+    case MONS_SHADOW:
+        return 56;
 
-    case MONS_ARMOUR_MIMIC:
-    case MONS_BROWN_SNAKE:
-    case MONS_DRAGON:
-    case MONS_ETTIN:
-    case MONS_FIRE_VORTEX:
-    case MONS_GIANT_LIZARD:
-    case MONS_GIANT_MITE:
-    case MONS_GNOLL:
-    case MONS_GOLD_MIMIC:
-    case MONS_KOMODO_DRAGON:
-    case MONS_MUMMY:
-    case MONS_NECROPHAGE:
-    case MONS_POTION_MIMIC:
-    case MONS_SCROLL_MIMIC:
-    case MONS_QUASIT:
     case MONS_SKELETAL_WARRIOR:
-    case MONS_SMALL_SNAKE:
-    case MONS_SOUL_EATER:
-    case MONS_SPINY_WORM:
-    case MONS_VAMPIRE:
-    case MONS_WEAPON_MIMIC:
-    case MONS_YELLOW_WASP:
-        return 30;
+        return 50;
 
-    case MONS_FLAYED_GHOST:
-        return 29;
+    case MONS_REAPER:
+        return 47;
 
-    case MONS_BRAIN_WORM:
+    case MONS_WIGHT:
+    case MONS_WRAITH:
+        return 45;
+
+    case MONS_ICE_DRAGON:
+        return 38;
+
+    case MONS_ROTTING_DEVIL:
+    case MONS_TORMENTOR:
+        return 37;
+
+    case MONS_MUMMY:
+        return 35;
+
+    case MONS_VAMPIRE:
+        return 34;
+
+    case MONS_HAIRY_DEVIL:
+    case MONS_HUNGRY_GHOST:
         return 26;
 
-    case MONS_BOGGART:
-    case MONS_DEEP_ELF_FIGHTER:
-    case MONS_DEEP_ELF_KNIGHT:
-    case MONS_DEEP_TROLL:
-    case MONS_FIRE_GIANT:
-    case MONS_FROST_GIANT:
-    case MONS_GREAT_ORB_OF_EYES:
-    case MONS_IRON_TROLL:
-    case MONS_OOZE:
-    case MONS_ORC_PRIEST:
-    case MONS_PLANT:
-    case MONS_RED_WASP:
-    case MONS_SIMULACRUM_SMALL:
-    case MONS_SIMULACRUM_LARGE:
+    case MONS_NECROPHAGE:
+    case MONS_PHANTOM:
         return 25;
 
-    case MONS_BUTTERFLY:
-    case MONS_FUNGUS:
-    case MONS_GIANT_SNAIL:
-    case MONS_ICE_DRAGON:
-    case MONS_INSUBSTANTIAL_WISP:
-    case MONS_RAKSHASA:
-    case MONS_REDBACK:
-    case MONS_SHADOW_DRAGON:
     case MONS_SPECTRAL_WARRIOR:
-    case MONS_SPHINX:
-    case MONS_STEAM_DRAGON:
-    case MONS_STORM_DRAGON:
-    case MONS_VERY_UGLY_THING:
-    case MONS_WIZARD:
         return 20;
 
-    case MONS_BORING_BEETLE:
+    case MONS_SOUL_EATER:
+        return 19;
+
     case MONS_LICH:
-    case MONS_TENTACLED_MONSTROSITY:
-        return 17;
+    case MONS_SKELETAL_DRAGON:
+    case MONS_SIMULACRUM_LARGE:
+    case MONS_SIMULACRUM_SMALL:
+        return 12;
 
-    case MONS_BLINK_FROG:
-    case MONS_CLAY_GOLEM:
-    case MONS_EFREET:
-    case MONS_EYE_OF_DEVASTATION:
-    case MONS_NECROMANCER:
-    case MONS_WOOD_GOLEM:
-        return 15;
+    case MONS_ANCIENT_LICH:
+        return 5;
 
-    case MONS_KOBOLD_DEMONOLOGIST:
-        return 13;
+    default:
+        return 0;
+    }
+}
 
-    case MONS_BUMBLEBEE:
-    case MONS_ORC_HIGH_PRIEST:
-        return 12;
+// Tartarus - the undead hell
+int mons_tartarus_level(int mcls)
+{
+    int mlev = 26;
 
-    case MONS_DEEP_ELF_SOLDIER:
-    case MONS_GIANT_ORANGE_BRAIN:
-    case MONS_HELL_KNIGHT:
-    case MONS_IRON_GOLEM:
-    case MONS_OKLOB_PLANT:
-    case MONS_ORC_SORCERER:
-    case MONS_SHADOW_WRAITH:
-    case MONS_STONE_GOLEM:
-    case MONS_TITAN:
-    case MONS_WANDERING_MUSHROOM:
-        return 10;
+    switch (mcls)
+    {
+    case MONS_IMP:
+    case MONS_SKELETON_LARGE:
+    case MONS_RED_DEVIL:
+    case MONS_SHADOW_IMP:
+    case MONS_SKELETAL_WARRIOR:
+    case MONS_SKELETON_SMALL:
+        mlev++;
+        break;
 
-    case MONS_GOLDEN_DRAGON:
-    case MONS_ORC_WARLORD:
-        return 7;
+    case MONS_HELL_KNIGHT:
+    case MONS_NECROPHAGE:
+    case MONS_PHANTOM:
+    case MONS_WIGHT:
+    case MONS_ZOMBIE_LARGE:
+    case MONS_ZOMBIE_SMALL:
+        mlev += 2;
+        break;
 
-    case MONS_GARGOYLE:
-        return 6;
+    case MONS_FREEZING_WRAITH:
+    case MONS_HELL_HOUND:
+    case MONS_NECROMANCER:
+    case MONS_SHADOW:
+    case MONS_SHADOW_DEMON:
+    case MONS_WRAITH:
+        mlev += 3;
+        break;
 
-    case MONS_CRYSTAL_GOLEM:
-    case MONS_DANCING_WEAPON:
-    case MONS_DEEP_ELF_HIGH_PRIEST:
-    case MONS_DEEP_ELF_MAGE:
-    case MONS_DEEP_ELF_SUMMONER:
-    case MONS_IRON_DRAGON:
-    case MONS_NAGA_MAGE:
-    case MONS_NAGA_WARRIOR:
+    case MONS_BLUE_DEVIL:
+    case MONS_FLAYED_GHOST:
+    case MONS_HUNGRY_GHOST:
+    case MONS_ICE_DEVIL:
+    case MONS_MUMMY:
     case MONS_SKELETAL_DRAGON:
-    case MONS_QUICKSILVER_DRAGON:
-    case MONS_VAPOUR:
-        return 5;
+    case MONS_SPECTRAL_WARRIOR:
+    case MONS_TORMENTOR:
+    case MONS_SIMULACRUM_LARGE:
+    case MONS_SIMULACRUM_SMALL:
+        mlev += 4;
+        break;
 
-    case MONS_AIR_ELEMENTAL:
-    case MONS_DEEP_ELF_CONJURER:
-    case MONS_EARTH_ELEMENTAL:
-    case MONS_FIRE_ELEMENTAL:
-        return 4;
+    case MONS_FLYING_SKULL:
+    case MONS_HELLION:
+    case MONS_REAPER:
+    case MONS_ROTTING_DEVIL:
+    case MONS_SHADOW_DRAGON:
+    case MONS_VAMPIRE:
+        mlev += 5;
+        break;
 
     case MONS_ANCIENT_LICH:
-    case MONS_DEEP_ELF_ANNIHILATOR:
-    case MONS_DEEP_ELF_DEATH_MAGE:
-    case MONS_DEEP_ELF_DEMONOLOGIST:
-    case MONS_DEEP_ELF_PRIEST:
-    case MONS_DEEP_ELF_SORCERER:
-    case MONS_GUARDIAN_NAGA:
-        return 3;
+    case MONS_HAIRY_DEVIL:
+    case MONS_LICH:
+    case MONS_SOUL_EATER:
+        mlev += 6;
+        break;
 
-    case MONS_PULSATING_LUMP:
-    case MONS_SHINING_EYE:
-    case MONS_TOENAIL_GOLEM:
-        return 2;
+    default:
+        return 0;
+    }
+
+    return (mlev);
+}
+
+int mons_tartarus_rare(int mcls)
+{
+    switch (mcls)
+    {
+    case MONS_SKELETON_LARGE:
+    case MONS_SHADOW_IMP:
+    case MONS_SKELETAL_WARRIOR:
+    case MONS_SKELETON_SMALL:
+    case MONS_ZOMBIE_LARGE:
+    case MONS_ZOMBIE_SMALL:
+        return 99;
+
+    case MONS_SHADOW:
+        return 92;
+
+    case MONS_REAPER:
+        return 73;
+
+    case MONS_NECROPHAGE:
+        return 72;
+
+    case MONS_WIGHT:
+        return 71;
+
+    case MONS_ROTTING_DEVIL:
+        return 62;
+
+    case MONS_FREEZING_WRAITH:
+        return 60;
+
+    case MONS_FLYING_SKULL:
+        return 53;
+
+    case MONS_HELL_HOUND:
+    case MONS_PHANTOM:
+    case MONS_WRAITH:
+        return 52;
+
+    case MONS_SHADOW_DEMON:
+        return 50;
+
+    case MONS_SPECTRAL_WARRIOR:
+        return 45;
+
+    case MONS_VAMPIRE:
+        return 44;
+
+    case MONS_HELLION:
+    case MONS_TORMENTOR:
+        return 42;
+
+    case MONS_SKELETAL_DRAGON:
+        return 40;
+
+    case MONS_SOUL_EATER:
+        return 35;
+
+    case MONS_ICE_DEVIL:        // not really appropriate for a fiery hell
+        return 34;
+
+    case MONS_MUMMY:
+        return 33;
+
+    case MONS_BLUE_DEVIL:
+    case MONS_HUNGRY_GHOST:
+        return 32;
+
+    case MONS_FLAYED_GHOST:
+    case MONS_HAIRY_DEVIL:
+        return 30;
+
+    case MONS_LICH:
+        return 24;
+
+    case MONS_IMP:
+    case MONS_SHADOW_DRAGON:
+    case MONS_DEATH_DRAKE:
+        return 20;
+
+    case MONS_RED_DEVIL:
+        return 13;
+
+    case MONS_HELL_KNIGHT:
+        return 14;
+
+    case MONS_NECROMANCER:
+    case MONS_SIMULACRUM_LARGE:
+    case MONS_SIMULACRUM_SMALL:
+        return 12;
+
+    case MONS_ANCIENT_LICH:
+        return 6;
 
     default:
         return 0;
     }
-}                               // end mons_standard_rare()
+}
diff --git a/crawl-ref/source/monplace.cc b/crawl-ref/source/monplace.cc
index e92d9434da..754b4cb5e1 100644
--- a/crawl-ref/source/monplace.cc
+++ b/crawl-ref/source/monplace.cc
@@ -2679,7 +2679,7 @@ std::vector<coord_def> monster_pathfind::calc_waypoints()
     // whether a tracked enemy has moved too much, in case we have to update
     // the path.
     if (pos != path[path.size() - 1])
-        waypoints.push_back(pos);
+        waypoints.push_back(path[path.size() - 1]);
 
     return (waypoints);
 }
diff --git a/crawl-ref/source/monstuff.cc b/crawl-ref/source/monstuff.cc
index f603049d0e..885502f2c5 100644
--- a/crawl-ref/source/monstuff.cc
+++ b/crawl-ref/source/monstuff.cc
@@ -2847,73 +2847,131 @@ static bool _pacified_leave_level(monsters *mon, std::vector<level_exit> e,
     return (false);
 }
 
+// Counts deep water twice.
 static int _count_water_neighbours(coord_def p)
 {
-    int deep_water_count = 0;
+    int water_count = 0;
     for (adjacent_iterator ai(p); ai; ++ai)
-        if (grd(p) == DNGN_DEEP_WATER)
-            deep_water_count++;
-
-    return (deep_water_count);
+    {
+        if (grd(*ai) == DNGN_SHALLOW_WATER)
+            water_count++;
+        else if (grd(*ai) == DNGN_DEEP_WATER)
+            water_count += 2;
+    }
+    return (water_count);
 }
 
+// Pick the nearest water grid that is surrounded by the most
+// water squares within LoS.
 static bool _find_siren_water_target(monsters *mon)
 {
-    mpr("in _find_siren_water_target");
     ASSERT(mon->type == MONS_SIREN);
+
+    // Moving away could break the entrancement, so don't do this.
+    if ((mon->pos() - you.pos()).rdist() > 6)
+        return (false);
+
+    // Already completely surrounded by deep water.
+    if (_count_water_neighbours(mon->pos()) >= 16)
+        return (true);
+
     if (mon->travel_target == MTRAV_SIREN)
     {
-        coord_def targ_pos(mon->travel_path[mon->travel_path.size()-1]);
+        coord_def targ_pos(mon->travel_path[mon->travel_path.size() - 1]);
+#ifdef DEBUG_PATHFIND
+        mprf("siren target is (%d, %d), dist = %d",
+             targ_pos.x, targ_pos.y, (int) (mon->pos() - targ_pos).rdist());
+#endif
         if ((mon->pos() - targ_pos).rdist() > 2)
             return (true);
     }
 
-    int water_count;
+    monster_los lm;
+    lm.set_monster(mon);
+    lm.set_los_range(LOS_RADIUS);
+    lm.fill_los_field();
+
     int best_water_count = 0;
     coord_def best_target;
-    int best_num;
+    bool first = true;
 
-    for (int k = 1; k <= LOS_RADIUS; k++)
-        for (int x = -1; x <= 1; x++)
-            for (int y = -1; y <= 1; y++)
-            {
-                if (x == 0 && y == 0)
-                    continue;
+    while (true)
+    {
+        int best_num = 0;
+        for (radius_iterator ri(mon->pos(), LOS_RADIUS, true, false);
+             ri; ++ri)
+        {
+            if (!grid_is_water(grd(*ri)))
+                continue;
 
-                const coord_def c(mon->pos() + coord_def(k*x, k*y));
-                if (!grid_is_water(grd(c)))
-                    continue;
+            // In the first iteration only count water grids that are
+            // not closer to the player than to the siren.
+            if (first && (mon->pos() - *ri).rdist() > (you.pos() - *ri).rdist())
+                continue;
 
-                water_count = _count_water_neighbours(c);
-                if (water_count <= best_water_count)
+            // Counts deep water twice.
+            const int water_count = _count_water_neighbours(*ri);
+            if (water_count < best_water_count)
+                continue;
+
+            if (water_count > best_water_count)
+            {
+                best_water_count = water_count;
+                best_target = *ri;
+                best_num = 1;
+            }
+            else // water_count == best_water_count
+            {
+                const int old_dist = (mon->pos() - best_target).rdist();
+                const int new_dist = (mon->pos() - *ri).rdist();
+                if (new_dist > old_dist)
                     continue;
 
-                if (water_count > best_water_count)
+                if (new_dist < old_dist)
                 {
-                    best_water_count = water_count;
-                    best_target = c;
+                    best_target = *ri;
                     best_num = 1;
                 }
-                else // if (water_count == best_water_count)
-                {
-                    best_num++;
-                    if (one_chance_in(best_num))
-                        best_target = c;
-                }
+                else if (one_chance_in(++best_num))
+                    best_target = *ri;
             }
+        }
 
-    if (best_water_count == 0)
+        if (!first || best_water_count > 0)
+            break;
+
+        // Else start the second iteration.
+        first = false;
+    }
+
+    if (!best_water_count)
         return (false);
 
+    // We're already optimally placed.
+    if (best_target == mon->pos())
+        return (true);
+
     monster_pathfind mp;
+#ifdef WIZARD
+    // Remove old highlighted areas to make place for the new ones.
+    for (rectangle_iterator ri(1); ri; ++ri)
+        env.map(*ri).property &= ~(FPROP_HIGHLIGHT);
+#endif
+
     if (mp.init_pathfind(mon, best_target))
     {
         mon->travel_path = mp.calc_waypoints();
+
         if (!mon->travel_path.empty())
         {
+#ifdef WIZARD
+            for (unsigned int i = 0; i < mon->travel_path.size(); i++)
+                env.map(mon->travel_path[i]).property |= FPROP_HIGHLIGHT;
+#endif
+#ifdef DEBUG_PATHFIND
             mprf("Found a path to (%d, %d) with %d surrounding water squares",
                  best_target.x, best_target.y, best_water_count);
-
+#endif
             // Okay then, we found a path.  Let's use it!
             mon->target = mon->travel_path[0];
             mon->travel_target = MTRAV_SIREN;
@@ -2930,7 +2988,7 @@ static bool _handle_monster_travelling(monsters *mon,
 {
 #ifdef DEBUG_PATHFIND
     mprf("Monster %s reached target (%d, %d)",
-         mon->name(DESC_PLAIN).c_str(), mon->target_x, mon->target_y);
+         mon->name(DESC_PLAIN).c_str(), mon->target.x, mon->target.y);
 #endif
 
     // Hey, we reached our first waypoint!
@@ -3110,7 +3168,7 @@ static bool _handle_monster_patrolling(monsters *mon)
         mprf("Monster %s (pp: %d, %d) is now patrolling to (%d, %d)",
              mon->name(DESC_PLAIN).c_str(),
              mon->patrol_point.x, mon->patrol_point.y,
-             mon->target_x, mon->target_y);
+             mon->target.x, mon->target.y);
 #endif
     }
 
@@ -3414,7 +3472,6 @@ static void _handle_behaviour(monsters *mon)
                 if (mon->type == MONS_SIREN)
                 {
                     if (player_mesmerised_by(mon)
-                        && (mon->pos() - you.pos()).rdist() < 6
                         && _find_siren_water_target(mon))
                     {
                         break;
@@ -4667,7 +4724,7 @@ static bool _handle_special_ability(monsters *monster, bolt & beem)
                 || delay.type == DELAY_DESCENDING_STAIRS)
             {
 #ifdef DEBUG_DIAGNOSTICS
-                mpr("Taking stairs, don't behold.", MSGCH_DIAGNOSTICS);
+                mpr("Taking stairs, don't mesmerise.", MSGCH_DIAGNOSTICS);
 #endif
                 break;
             }
@@ -6843,7 +6900,6 @@ static bool _do_move_monster(monsters *monster, const coord_def& delta)
     if (grd(monster->pos()) == DNGN_DEEP_WATER && grd(f) != DNGN_DEEP_WATER
         && !monster_habitable_grid(monster, DNGN_DEEP_WATER))
     {
-        mpr("set seen_context...");
         monster->seen_context = "emerges from the water";
     }
     mgrd(monster->pos()) = NON_MONSTER;
diff --git a/crawl-ref/source/view.cc b/crawl-ref/source/view.cc
index 9da30c2414..6ec000adf0 100644
--- a/crawl-ref/source/view.cc
+++ b/crawl-ref/source/view.cc
@@ -1582,7 +1582,7 @@ bool noisy(int loudness, const coord_def& where, const char *msg, bool mermaid)
     const int dist = loudness * loudness;
     const int player_distance = distance( you.pos(), where );
 
-    // message the player
+    // Message the player.
     if (player_distance <= dist && player_can_hear( where ))
     {
         if (msg)
@@ -1619,7 +1619,7 @@ bool noisy(int loudness, const coord_def& where, const char *msg, bool mermaid)
             else if (mermaid && mons_primary_habitat(monster) == HT_WATER
                      && !mons_friendly(monster))
             {
-                // Mermaids call (hostile) aquatic monsters.
+                // Mermaids/sirens call (hostile) aquatic monsters.
                 behaviour_event( monster, ME_ALERT, MHITNOT, where );
             }
             else