* Repurpose program bug tile for chaos spawns (using error tile for

  program bugs instead).
* Add sirens (don't really work yet).
* Reorder monsters in tile code.


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

11 files changed, 838 insertions, 586 deletions

diff --git a/crawl-ref/source/dat/lab.des b/crawl-ref/source/dat/lab.des
index 30b5de2144..3655a3f9b4 100644
--- a/crawl-ref/source/dat/lab.des
+++ b/crawl-ref/source/dat/lab.des
@@ -366,7 +366,7 @@ ENDMAP
 # Death by starvation?
 NAME:   labyrinth_hungry_ghost
 TAGS:   lab allow_dup generate_awake
-WEIGHT: 5
+WEIGHT: 2
 KFEAT:  x = .
 KMONS:  x = hungry ghost
 MAP
diff --git a/crawl-ref/source/dungeon.cc b/crawl-ref/source/dungeon.cc
index 86466e54ab..459853da53 100644
--- a/crawl-ref/source/dungeon.cc
+++ b/crawl-ref/source/dungeon.cc
@@ -3327,6 +3327,8 @@ static void _place_aquatic_monsters(int level_number, char level_type)
                     swimming_things[i] = MONS_MERFOLK;
                 else if (one_chance_in(5))
                     swimming_things[i] = MONS_MERMAID;
+                else if (one_chance_in(8))
+                    swimming_things[i] = MONS_SIREN;
             }
         }
 
diff --git a/crawl-ref/source/enum.h b/crawl-ref/source/enum.h
index 4019dffced..0cfadf8153 100644
--- a/crawl-ref/source/enum.h
+++ b/crawl-ref/source/enum.h
@@ -1736,7 +1736,8 @@ enum monster_type                      // (int) menv[].type
     MONS_SIMULACRUM_LARGE,
     MONS_MERFOLK,
     MONS_MERMAID,
-    MONS_FLAMING_CORPSE,               //  195
+    MONS_SIREN,                        //  195
+    MONS_FLAMING_CORPSE,
     //jmf: end new monsters
     MONS_WHITE_IMP = 220,              //  220
     MONS_LEMURE,
@@ -2998,6 +2999,7 @@ enum montravel_target_type
     MTRAV_NONE = 0,
     MTRAV_PLAYER,      // Travelling to reach the player.
     MTRAV_PATROL,      // Travelling to reach the patrol point.
+    MTRAV_SIREN,       // Sirens travelling towards deep water.
     MTRAV_UNREACHABLE  // Not travelling because target is unreachable.
 };
 
diff --git a/crawl-ref/source/mon-data.h b/crawl-ref/source/mon-data.h
index a40cff23a1..f0014fcaf6 100644
--- a/crawl-ref/source/mon-data.h
+++ b/crawl-ref/source/mon-data.h
@@ -73,6 +73,14 @@
    hp_dice [4]
    - hit dice, min hp per HD, extra random hp per HD, fixed HP (unique mons)
 
+    Further explanations copied from mon-util.h:
+        hpdice[4]: [0]=HD [1]=min_hp [2]=rand_hp [3]=add_hp
+        min hp = [0]*[1]+[3] & max hp = [0]*([1]+[2])+[3])
+        example: the Iron Golem, hpdice={15,7,4,0}
+           15*7 < hp < 15*(7+4),
+           105 < hp < 165
+        hp will be around 135 each time.
+
    corpse_thingy
    - err, bad name. Describes effects of eating corpses.
      CE_NOCORPSE,        leaves no corpse (mass == 0)
@@ -971,18 +979,29 @@ static monsterentry mondata[] = {
     MR_RES_POISON | MR_RES_COLD,
     500, 10, MONS_MERFOLK, MONS_MERFOLK, MH_NATURAL, -3,
     { {AT_HIT, AF_PLAIN, 14}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
-    { 8, 2, 4, 0 },
+    { 9, 2, 4, 0 },
     4, 12, MST_NO_SPELLS, CE_CONTAMINATED, Z_SMALL, S_SHOUT, I_NORMAL,
     HT_AMPHIBIOUS_WATER, 10, DEFAULT_ENERGY, MONUSE_WEAPONS_ARMOUR, SIZE_MEDIUM
 },
 
 {
-    MONS_MERMAID, 'm', LIGHTCYAN, "mermaid",
+    MONS_MERMAID, 'm', LIGHTCYAN, "cyan",
     M_SPELLCASTER | M_WARM_BLOOD | M_SPEAKS,
     MR_RES_POISON | MR_RES_COLD,
     500, 10, MONS_MERMAID, MONS_MERMAID, MH_NATURAL, -5,
     { {AT_HIT, AF_PLAIN, 10}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
-    { 8, 2, 4, 0 },
+    { 8, 2, 3, 0 },
+    4, 12, MST_NO_SPELLS, CE_CONTAMINATED, Z_SMALL, S_SHOUT, I_NORMAL,
+    HT_AMPHIBIOUS_WATER, 10, DEFAULT_ENERGY, MONUSE_WEAPONS_ARMOUR, SIZE_MEDIUM
+},
+
+{
+    MONS_SIREN, 'm', LIGHTCYAN, "siren",
+    M_SPELLCASTER | M_WARM_BLOOD | M_SPEAKS,
+    MR_RES_POISON | MR_RES_COLD,
+    500, 12, MONS_MERMAID, MONS_SIREN, MH_NATURAL, -7,
+    { {AT_HIT, AF_PLAIN, 10}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
+    { 8, 2, 3, 0 },
     4, 12, MST_NO_SPELLS, CE_CONTAMINATED, Z_SMALL, S_SHOUT, I_NORMAL,
     HT_AMPHIBIOUS_WATER, 10, DEFAULT_ENERGY, MONUSE_WEAPONS_ARMOUR, SIZE_MEDIUM
 },
@@ -1173,7 +1192,7 @@ static monsterentry mondata[] = {
     HT_LAND, 10, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_TINY
 },
 
-// rats ('r')
+// rodents ('r')
 {
     MONS_RAT, 'r', BROWN, "rat",
     M_WARM_BLOOD,
@@ -1445,6 +1464,17 @@ static monsterentry mondata[] = {
 },
 
 {
+    MONS_SWAMP_WORM, 'w', BROWN, "swamp worm",
+    M_NO_FLAGS,
+    MR_NO_FLAGS,
+    0, 10, MONS_WORM, MONS_SWAMP_WORM, MH_NATURAL, -3,
+    { {AT_BITE, AF_PLAIN, 20}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
+    { 5, 5, 5, 0 },
+    3, 12, MST_NO_SPELLS, CE_NOCORPSE, Z_NOZOMBIE, S_SILENT, I_PLANT,
+    HT_WATER, 12, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_LARGE
+},
+
+{
     MONS_SPINY_WORM, 'w', LIGHTGREEN, "spiny worm",
     M_NO_FLAGS,
     MR_VUL_POISON | MR_RES_ACID,
@@ -1478,7 +1508,7 @@ static monsterentry mondata[] = {
     HT_LAND, 0, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_LARGE
 },
 
-// wasps ('y')
+// flying insects ('y')
 {
     MONS_YELLOW_WASP, 'y', YELLOW, "yellow wasp",
     M_FLIES,
@@ -1592,6 +1622,17 @@ static monsterentry mondata[] = {
     HT_LAND, 15, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_TINY
 },
 
+{
+    MONS_FLAMING_CORPSE, 'z', LIGHTRED, "flaming corpse",
+    M_SENSE_INVIS | M_EVIL | M_GLOWS,
+    MR_RES_POISON | MR_VUL_COLD | mrd(MR_RES_FIRE, 3) | MR_RES_STICKY_FLAME,
+    0, 17, MONS_FLAMING_CORPSE, MONS_FLAMING_CORPSE, MH_UNDEAD, -4,
+    { {AT_HIT, AF_NAPALM, 20}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
+    { 8, 3, 5, 0 },
+    12, 13, MST_NO_SPELLS, CE_NOCORPSE, Z_NOZOMBIE, S_SCREAM, I_NORMAL,
+    HT_LAND, 12, DEFAULT_ENERGY, MONUSE_OPEN_DOORS, SIZE_MEDIUM
+},
+
 // These nasties are never randomly generated, only sometimes specially
 // placed in the Crypt.
 {
@@ -1618,17 +1659,6 @@ static monsterentry mondata[] = {
     HT_LAND, 12, MOVE_ENERGY(20), MONUSE_NOTHING, SIZE_TINY
 },
 
-{
-    MONS_FLAMING_CORPSE, 'z', LIGHTRED, "flaming corpse",
-    M_SENSE_INVIS | M_EVIL | M_GLOWS,
-    MR_RES_POISON | MR_VUL_COLD | mrd(MR_RES_FIRE, 3) | MR_RES_STICKY_FLAME,
-    0, 17, MONS_FLAMING_CORPSE, MONS_FLAMING_CORPSE, MH_UNDEAD, -4,
-    { {AT_HIT, AF_NAPALM, 20}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
-    { 8, 3, 5, 0 },
-    12, 13, MST_NO_SPELLS, CE_NOCORPSE, Z_NOZOMBIE, S_SCREAM, I_NORMAL,
-    HT_LAND, 12, DEFAULT_ENERGY, MONUSE_OPEN_DOORS, SIZE_MEDIUM
-},
-
 // angelic beings ('A')
 {
     MONS_ANGEL, 'A', WHITE, "Angel",
@@ -2928,17 +2958,6 @@ static monsterentry mondata[] = {
     HT_WATER, 10, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_LITTLE
 },
 
-{
-    MONS_SWAMP_WORM, 'w', BROWN, "swamp worm",
-    M_NO_FLAGS,
-    MR_NO_FLAGS,
-    0, 10, MONS_WORM, MONS_SWAMP_WORM, MH_NATURAL, -3,
-    { {AT_BITE, AF_PLAIN, 20}, AT_NO_ATK, AT_NO_ATK, AT_NO_ATK },
-    { 5, 5, 5, 0 },
-    3, 12, MST_NO_SPELLS, CE_NOCORPSE, Z_NOZOMBIE, S_SILENT, I_PLANT,
-    HT_WATER, 12, DEFAULT_ENERGY, MONUSE_NOTHING, SIZE_LARGE
-},
-
 // lava monsters
 {
     MONS_LAVA_WORM, 'w', RED, "lava worm",
diff --git a/crawl-ref/source/mon-pick.cc b/crawl-ref/source/mon-pick.cc
index d608352219..6b4b2635ab 100644
--- a/crawl-ref/source/mon-pick.cc
+++ b/crawl-ref/source/mon-pick.cc
@@ -2049,6 +2049,7 @@ int mons_shoals_level(int mcls)
         mlev++;
         break;
 
+    case MONS_SIREN:
     case MONS_YAKTAUR:
         mlev += 2;
         break;
@@ -2088,6 +2089,7 @@ int mons_shoals_rare(int mcls)
     case MONS_MERMAID:
         return 40;
 
+    case MONS_SIREN:
     case MONS_HIPPOGRIFF:
     case MONS_GIANT_BAT:
     case MONS_BUTTERFLY:
@@ -2244,6 +2246,7 @@ int mons_swamp_rare(int mcls)
     case MONS_NECROPHAGE:
         return 12;
 
+    case MONS_SIREN:
     case MONS_BLINK_FROG:
     case MONS_GIANT_AMOEBA:
     case MONS_GIANT_GECKO:
diff --git a/crawl-ref/source/mon-util.cc b/crawl-ref/source/mon-util.cc
index 4f0a100bd6..841ba05762 100644
--- a/crawl-ref/source/mon-util.cc
+++ b/crawl-ref/source/mon-util.cc
@@ -537,7 +537,7 @@ bool mons_is_native_in_branch(const monsters *monster,
     case BRANCH_SHOALS:
         return (mons_species(monster->type) == MONS_CYCLOPS
                 || mons_species(monster->type) == MONS_MERFOLK
-                || mons_species(monster->type) == MONS_MERMAID);
+                || mons_genus(monster->type) == MONS_MERMAID);
 
     case BRANCH_SLIME_PITS:
         return (mons_species(monster->type) == MONS_JELLY);
@@ -2709,16 +2709,16 @@ bool ms_waste_of_time( const monsters *mon, spell_type monspell )
         // life-protected if he has triple life protection.
         const mon_holy_type holiness = foe->holiness();
         ret = ((holiness == MH_UNDEAD
-                  // If the claimed undead is the player, it must be
-                  // a non-vampire, or a bloodless vampire.
-                  && (foe != &you || you.is_undead != US_SEMI_UNDEAD ||
-                      you.hunger_state == HS_STARVING))
-                  // Demons, but not demonspawn - demonspawn will show
-                  // up as demonic for purposes of things like holy
-                  // wrath, but are still (usually) susceptible to
-                  // torment and draining.
-                  || (holiness == MH_DEMONIC && foe != &you)
-                  || holiness == MH_NONLIVING || holiness == MH_PLANT);
+                   // If the claimed undead is the player, it must be
+                   // a non-vampire, or a bloodless vampire.
+                   && (foe != &you || you.is_undead != US_SEMI_UNDEAD
+                       || you.hunger_state == HS_STARVING))
+                // Demons, but not demonspawn - demonspawn will show
+                // up as demonic for purposes of things like holy
+                // wrath, but are still (usually) susceptible to
+                // torment and draining.
+                || holiness == MH_DEMONIC && foe != &you
+                || holiness == MH_NONLIVING || holiness == MH_PLANT);
         break;
     }
 
@@ -2895,7 +2895,7 @@ bool mons_has_los_ability( int mclass )
         return (true);
 
     // Beholding just needs LOS.
-    if (mclass == MONS_MERMAID)
+    if (mons_genus(mclass) == MONS_MERMAID)
         return (true);
 
     return (false);
@@ -2952,8 +2952,9 @@ const char *mons_pronoun(monster_type mon_type, pronoun_type variant,
 {
     gender_type gender = GENDER_NEUTER;
 
-    if (mons_is_unique(mon_type) && mon_type != MONS_PLAYER_GHOST
-        || mon_type == MONS_MERMAID)
+    if (mons_genus(mon_type) == MONS_MERMAID)
+        gender = GENDER_FEMALE;
+    else if (mons_is_unique(mon_type) && mon_type != MONS_PLAYER_GHOST)
     {
         switch (mon_type)
         {
@@ -2969,7 +2970,6 @@ const char *mons_pronoun(monster_type mon_type, pronoun_type variant,
         case MONS_ERICA:
         case MONS_TIAMAT:
         case MONS_ERESHKIGAL:
-        case MONS_MERMAID:
             gender = GENDER_FEMALE;
             break;
         default:
@@ -3226,10 +3226,10 @@ bool monsters::wants_submerge() const
         return (true);
     }
 
-    const bool has_ranged_attack =
-        type == MONS_ELECTRICAL_EEL
-        || type == MONS_LAVA_SNAKE
-        || (type == MONS_MERMAID && you.species != SP_MERFOLK);
+    const bool has_ranged_attack = (type == MONS_ELECTRICAL_EEL
+                                    || type == MONS_LAVA_SNAKE
+                                    || mons_genus(type) == MONS_MERMAID
+                                       && you.species != SP_MERFOLK);
 
     int roll = 8;
     // Shallow water takes a little more effort to submerge in, so we're
@@ -4808,7 +4808,8 @@ std::string monsters::foot_name(bool plural, bool *can_plural) const
     case MON_SHAPE_HUMANOID_WINGED_TAILED:
         if (type == MONS_MINOTAUR)
             str = "hoof";
-        else if (swimming() && (type == MONS_MERFOLK || type == MONS_MERMAID))
+        else if (swimming()
+                 && (type == MONS_MERFOLK || mons_genus(type) == MONS_MERMAID))
         {
             str         = "tail";
             *can_plural = false;
diff --git a/crawl-ref/source/monstuff.cc b/crawl-ref/source/monstuff.cc
index 6dacc24f2b..02d7a29157 100644
--- a/crawl-ref/source/monstuff.cc
+++ b/crawl-ref/source/monstuff.cc
@@ -1635,7 +1635,6 @@ static bool _valid_morph( monsters *monster, int new_mclass )
 
         // Monsters still under development
         || new_mclass == MONS_ROCK_WORM
-        || new_mclass == MONS_TRAPDOOR_SPIDER
 
         // Other poly-unsuitable things.
         || new_mclass == MONS_ROYAL_JELLY
@@ -1652,11 +1651,8 @@ static bool _valid_morph( monsters *monster, int new_mclass )
     return (monster_habitable_grid(new_mclass, current_tile));
 }
 
-static bool _is_poly_power_unsuitable(
-    poly_power_type power,
-    int src_pow,
-    int tgt_pow,
-    int relax)
+static bool _is_poly_power_unsuitable( poly_power_type power,
+                                       int src_pow, int tgt_pow, int relax )
 {
     switch (power)
     {
@@ -1756,7 +1752,7 @@ bool monster_polymorph(monsters *monster, monster_type targetc,
     // player into a different type which can also behold the player,
     // the polymorph disrupts the beholding process.  Do this before
     // changing monster->type, since unbeholding can only happen while
-    // the monster is still a mermaid.
+    // the monster is still a mermaid/siren.
     update_beholders(monster, true);
 
     // the actual polymorphing:
@@ -2851,6 +2847,79 @@ static bool _pacified_leave_level(monsters *mon, std::vector<level_exit> e,
     return (false);
 }
 
+static int _count_water_neighbours(coord_def p)
+{
+    int deep_water_count = 0;
+    for (adjacent_iterator ai(p); ai; ++ai)
+        if (grd(p) == DNGN_DEEP_WATER)
+            deep_water_count++;
+
+    return (deep_water_count);
+}
+
+static bool _find_siren_water_target(monsters *mon)
+{
+    mpr("in _find_siren_water_target");
+    ASSERT(mon->type == MONS_SIREN);
+    if (mon->travel_target == MTRAV_SIREN && !one_chance_in(8))
+        return (true);
+
+    int water_count;
+    int best_water_count = 0;
+    coord_def best_target;
+    int best_num;
+
+    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;
+
+                const coord_def c(mon->pos() + coord_def(k*x, k*y));
+                if (!grid_is_water(grd(c)))
+                    continue;
+
+                water_count = _count_water_neighbours(c);
+                if (water_count <= best_water_count)
+                    continue;
+
+                if (water_count > best_water_count)
+                {
+                    best_water_count = water_count;
+                    best_target = c;
+                    best_num = 1;
+                }
+                else // if (water_count == best_water_count)
+                {
+                    best_num++;
+                    if (one_chance_in(best_num))
+                        best_target = c;
+                }
+            }
+
+    if (best_water_count == 0)
+        return (false);
+
+    monster_pathfind mp;
+    if (mp.init_pathfind(mon, best_target))
+    {
+        mon->travel_path = mp.calc_waypoints();
+        if (!mon->travel_path.empty())
+        {
+            mprf("Found a path to (%d, %d) with %d surrounding water squares",
+                 best_target.x, best_target.y, best_water_count);
+
+            // Okay then, we found a path.  Let's use it!
+            mon->target = mon->travel_path[0];
+            mon->travel_target = MTRAV_SIREN;
+            return (true);
+        }
+    }
+
+    return (false);
+}
+
 // Returns true if further handling neeeded.
 static bool _handle_monster_travelling(monsters *mon,
                                        const dungeon_feature_type can_move)
@@ -3245,6 +3314,9 @@ static void _handle_behaviour(monsters *mon)
             // Foe gone out of LOS?
             if (!proxFoe)
             {
+                if (mon->travel_target == MTRAV_SIREN)
+                    mon->travel_target = MTRAV_NONE;
+
                 if (mon->foe == MHITYOU && mon->is_travelling()
                     && mon->travel_target == MTRAV_PLAYER)
                 {
@@ -3334,6 +3406,17 @@ static void _handle_behaviour(monsters *mon)
             // by updating target x,y.
             if (mon->foe == MHITYOU)
             {
+                // The foe is the player.
+                if (mon->type == MONS_SIREN)
+                {
+                    if (player_beheld_by(mon)
+                        && (mon->pos() - you.pos()).rdist() < 6
+                        && _find_siren_water_target(mon))
+                    {
+                        break;
+                    }
+                }
+
                 if (_try_pathfind(mon, can_move, trans_wall_block))
                     break;
 
@@ -4569,6 +4652,7 @@ static bool _handle_special_ability(monsters *monster, bolt & beem)
         break;
 
     case MONS_MERMAID:
+    case MONS_SIREN:
     {
         // Don't behold player already half down or up the stairs.
         if (!you.delay_queue.empty())
diff --git a/crawl-ref/source/player.cc b/crawl-ref/source/player.cc
index 3e1d8450fa..e6b32d5e37 100644
--- a/crawl-ref/source/player.cc
+++ b/crawl-ref/source/player.cc
@@ -2624,7 +2624,7 @@ bool player_beheld_by( const monsters *mon )
         return (false);
 
     // Can this monster even behold you?
-    if (mon->type != MONS_MERMAID)
+    if (mons_genus(mon->type) != MONS_MERMAID)
         return (false);
 
 #ifdef DEBUG_DIAGNOSTICS
@@ -2684,14 +2684,16 @@ void check_beholders()
     for (int i = you.beheld_by.size() - 1; i >= 0; i--)
     {
         const monsters* mon = &menv[you.beheld_by[i]];
-        if (!mon->alive() || mon->type != MONS_MERMAID)
+        if (!mon->alive() || mons_genus(mon->type) != MONS_MERMAID)
         {
 #if DEBUG
             if (!mon->alive())
                 mpr("Dead mermaid still beholding?", MSGCH_DIAGNOSTICS);
-            else if (mon->type != MONS_MERMAID)
+            else
+            {
                 mprf(MSGCH_DIAGNOSTICS, "Non-mermaid '%s' beholding?",
                      mon->name(DESC_PLAIN, true).c_str());
+            }
 #endif
 
             you.beheld_by.erase(you.beheld_by.begin() + i);
diff --git a/crawl-ref/source/rltiles/dc-mon.txt b/crawl-ref/source/rltiles/dc-mon.txt
index 27c19b6e05..70ae82d0ef 100644
--- a/crawl-ref/source/rltiles/dc-mon.txt
+++ b/crawl-ref/source/rltiles/dc-mon.txt
@@ -1,3 +1,5 @@
+dc-misc/error MONS_PROGRAM_BUG

+

 %sdir dc-mon

 %rim 0

 shadow MONS_SHADOW /*' '*/

@@ -51,12 +53,14 @@ orange_demon MONS_ORANGE_DEMON /*'3'*/
 shadow_demon MONS_SHADOW_DEMON /*'3'*/

 tormentor MONS_TORMENTOR /*'3'*/

 ynoxinul MONS_YNOXINUL /*'3'*/

+chaos_spawn MONS_CHAOS_SPAWN /*'3'*/

 beast MONS_BEAST /*'4'*/

 hairy_devil MONS_HAIRY_DEVIL /*'4'*/

 red_devil MONS_RED_DEVIL /*'4'*/

 rotting_devil MONS_ROTTING_DEVIL /*'4'*/

 smoke_demon MONS_SMOKE_DEMON /*'4'*/

 imp MONS_IMP /*'5'*/

+quasit MONS_QUASIT /*'5'*/

 lemure MONS_LEMURE /*'5'*/

 manes MONS_MANES /*'5'*/

 midge MONS_MIDGE /*'5'*/

@@ -127,7 +131,6 @@ daeva MONS_DAEVA /*'A'*/
 boring_beetle MONS_BORING_BEETLE /*'B'*/

 boulder_beetle MONS_BOULDER_BEETLE /*'B'*/

 giant_beetle MONS_GIANT_BEETLE /*'B'*/

-program_bug MONS_PROGRAM_BUG /*'B'*/

 

 ## Giants

 %sdir dc-mon/unique

@@ -408,8 +411,6 @@ phantom MONS_PHANTOM /*'p'*/
 ghost MONS_PLAYER_GHOST /*'p'*/

 %rim 1

 

-quasit MONS_QUASIT /*'q'*/

-

 green_rat MONS_GREEN_RAT /*'r'*/

 grey_rat MONS_GREY_RAT /*'r'*/

 orange_rat MONS_ORANGE_RAT /*'r'*/

@@ -418,10 +419,10 @@ rat MONS_RAT /*'r'*/
 

 giant_centipede MONS_GIANT_CENTIPEDE /*'s'*/

 giant_mite MONS_GIANT_MITE /*'s'*/

-redback MONS_REDBACK /*'s'*/

 scorpion MONS_SCORPION /*'s'*/

 wolf_spider MONS_WOLF_SPIDER /*'s'*/

 trapdoor_spider MONS_TRAPDOOR_SPIDER /*'s'*/

+redback MONS_REDBACK /*'s'*/

 

 ugly_thing MONS_UGLY_THING /*'u'*/

 very_ugly_thing MONS_VERY_UGLY_THING /*'u'*/

@@ -437,6 +438,7 @@ lava_worm MONS_LAVA_WORM /*'w'*/
 spiny_worm MONS_SPINY_WORM /*'w'*/

 swamp_worm MONS_SWAMP_WORM /*'w'*/

 worm MONS_WORM /*'w'*/

+rock_worm MONS_ROCK_WORM /*'w' currently unused*/

 

 abomination_small MONS_ABOMINATION_SMALL /*'x'*/

 unseen_horror MONS_UNSEEN_HORROR /*'x'*/

@@ -465,7 +467,8 @@ merfolk_fighter MONS_MERFOLK_FIGHTER
 merfolk_fighter_water MONS_MERFOLK_FIGHTER_WATER

 mermaid MONS_MERMAID

 mermaid_water MONS_MERMAID_WATER

-rock_worm MONS_ROCK_WORM

+siren MONS_SIREN

+siren_water MONS_SIREN_WATER

 

 %sdir dc-dngn

 dngn_orange_crystal_statue ORANGE_CRYSTAL_STATUE

diff --git a/crawl-ref/source/rltiles/dc-mon/program_bug.png b/crawl-ref/source/rltiles/dc-mon/chaos_spawn.png
index 200da65905..200da65905 100644
--- a/crawl-ref/source/rltiles/dc-mon/program_bug.png
+++ b/crawl-ref/source/rltiles/dc-mon/chaos_spawn.png
diff --git a/crawl-ref/source/tilepick.cc b/crawl-ref/source/tilepick.cc
index 42806e3c7a..037d956f4d 100644
--- a/crawl-ref/source/tilepick.cc
+++ b/crawl-ref/source/tilepick.cc
@@ -142,281 +142,618 @@ static int _tileidx_monster_base(const monsters *mon, bool detected)
 
     switch (type)
     {
+    // program bug
+    case MONS_PROGRAM_BUG:
+        return TILEP_MONS_PROGRAM_BUG;
+
+    // insects ('a')
+    case MONS_GIANT_COCKROACH:
+        return TILEP_MONS_GIANT_COCKROACH;
     case MONS_GIANT_ANT:
         return TILEP_MONS_GIANT_ANT;
+    case MONS_SOLDIER_ANT:
+        return TILEP_MONS_SOLDIER_ANT;
+
+    // batty monsters ('b')
     case MONS_GIANT_BAT:
         return TILEP_MONS_GIANT_BAT;
+    case MONS_BUTTERFLY:
+        return TILEP_MONS_BUTTERFLY + ((mon->colour)%7);
+
+    // centaurs ('c')
     case MONS_CENTAUR:
         return TILEP_MONS_CENTAUR + _bow_offset(mon);
-    case MONS_RED_DEVIL:
-        return TILEP_MONS_RED_DEVIL;
-    case MONS_ETTIN:
-        return TILEP_MONS_ETTIN;
+    case MONS_CENTAUR_WARRIOR:
+        return TILEP_MONS_CENTAUR_WARRIOR + _bow_offset(mon);
+    case MONS_YAKTAUR:
+        return TILEP_MONS_YAKTAUR + _bow_offset(mon);
+    case MONS_YAKTAUR_CAPTAIN:
+        return TILEP_MONS_YAKTAUR_CAPTAIN + _bow_offset(mon);
+
+    // elves ('e')
+    case MONS_ELF:
+        return TILEP_MONS_ELF;
+    case MONS_DEEP_ELF_SOLDIER:
+        return TILEP_MONS_DEEP_ELF_SOLDIER;
+    case MONS_DEEP_ELF_FIGHTER:
+        return TILEP_MONS_DEEP_ELF_FIGHTER;
+    case MONS_DEEP_ELF_KNIGHT:
+        return TILEP_MONS_DEEP_ELF_KNIGHT;
+    case MONS_DEEP_ELF_MAGE:
+        return TILEP_MONS_DEEP_ELF_MAGE;
+    case MONS_DEEP_ELF_SUMMONER:
+        return TILEP_MONS_DEEP_ELF_SUMMONER;
+    case MONS_DEEP_ELF_CONJURER:
+        return TILEP_MONS_DEEP_ELF_CONJURER;
+    case MONS_DEEP_ELF_PRIEST:
+        return TILEP_MONS_DEEP_ELF_PRIEST;
+    case MONS_DEEP_ELF_HIGH_PRIEST:
+        return TILEP_MONS_DEEP_ELF_HIGH_PRIEST;
+    case MONS_DEEP_ELF_DEMONOLOGIST:
+        return TILEP_MONS_DEEP_ELF_DEMONOLOGIST;
+    case MONS_DEEP_ELF_ANNIHILATOR:
+        return TILEP_MONS_DEEP_ELF_ANNIHILATOR;
+    case MONS_DEEP_ELF_SORCERER:
+        return TILEP_MONS_DEEP_ELF_SORCERER;
+    case MONS_DEEP_ELF_DEATH_MAGE:
+        return TILEP_MONS_DEEP_ELF_DEATH_MAGE;
+    case MONS_DEEP_ELF_BLADEMASTER:
+        return TILEP_MONS_DEEP_ELF_BLADEMASTER;
+    case MONS_DEEP_ELF_MASTER_ARCHER:
+        return TILEP_MONS_DEEP_ELF_MASTER_ARCHER;
+
+    // fungi ('f')
     case MONS_FUNGUS:
         return TILEP_MONS_FUNGUS;
+    case MONS_WANDERING_MUSHROOM:
+        return TILEP_MONS_WANDERING_MUSHROOM;
+
+    // goblins ('g')
     case MONS_GOBLIN:
         return TILEP_MONS_GOBLIN;
-    case MONS_HOUND:
-        return TILEP_MONS_HOUND;
-    case MONS_IMP:
-        return TILEP_MONS_IMP;
+    case MONS_HOBGOBLIN:
+        return TILEP_MONS_HOBGOBLIN;
+    case MONS_GNOLL:
+        return TILEP_MONS_GNOLL;
+    case MONS_BOGGART:
+        return TILEP_MONS_BOGGART;
+
+    // hounds ('h')
     case MONS_JACKAL:
         return TILEP_MONS_JACKAL;
+    case MONS_HOUND:
+        return TILEP_MONS_HOUND;
+    case MONS_WARG:
+        return TILEP_MONS_WARG;
+    case MONS_WOLF:
+        return TILEP_MONS_WOLF;
+    case MONS_WAR_DOG:
+        return TILEP_MONS_WAR_DOG;
+    case MONS_HOG:
+        return TILEP_MONS_HOG;
+    case MONS_HELL_HOUND:
+        return TILEP_MONS_HELL_HOUND;
+    case MONS_HELL_HOG:
+        return TILEP_MONS_HELL_HOG;
+
+    // slugs ('j')
+    case MONS_ELEPHANT_SLUG:
+        return TILEP_MONS_ELEPHANT_SLUG;
+    case MONS_GIANT_SLUG:
+        return TILEP_MONS_GIANT_SLUG;
+    case MONS_GIANT_SNAIL:
+        return TILEP_MONS_GIANT_SNAIL;
+
+    // killer bees ('k')
     case MONS_KILLER_BEE:
         return TILEP_MONS_KILLER_BEE;
-    case MONS_KILLER_BEE_LARVA:
-        return TILEP_MONS_KILLER_BEE_LARVA;
-    case MONS_MANTICORE:
-        return TILEP_MONS_MANTICORE;
+    case MONS_BUMBLEBEE:
+        return TILEP_MONS_BUMBLEBEE;
+
+    // lizards ('l')
+    case MONS_GIANT_NEWT:
+        return TILEP_MONS_GIANT_NEWT;
+    case MONS_GIANT_GECKO:
+        return TILEP_MONS_GIANT_GECKO;
+    case MONS_GIANT_IGUANA:
+        return TILEP_MONS_GIANT_IGUANA;
+    case MONS_GIANT_LIZARD:
+        return TILEP_MONS_GIANT_LIZARD;
+    case MONS_GILA_MONSTER:
+        return TILEP_MONS_GILA_MONSTER;
+    case MONS_KOMODO_DRAGON:
+        return TILEP_MONS_KOMODO_DRAGON;
+
+    // drakes (also 'l', but dragon type)
+    case MONS_SWAMP_DRAKE:
+        return TILEP_MONS_SWAMP_DRAKE;
+    case MONS_FIREDRAKE:
+        return TILEP_MONS_FIREDRAKE;
+    case MONS_LINDWURM:
+        return TILEP_MONS_LINDWURM;
+    case MONS_DEATH_DRAKE:
+        return TILEP_MONS_DEATH_DRAKE;
+
+    // merfolk ('m')
+    case MONS_MERFOLK:
+        if (in_water)
+            return TILEP_MONS_MERFOLK_FIGHTER_WATER;
+        else
+            return TILEP_MONS_MERFOLK_FIGHTER;
+    case MONS_MERMAID:
+        if (in_water)
+            return TILEP_MONS_MERMAID_WATER;
+        else
+            return TILEP_MONS_MERMAID;
+    case MONS_SIREN:
+        if (in_water)
+            return TILEP_MONS_SIREN_WATER;
+        else
+            return TILEP_MONS_SIREN;
+
+    // rotting monsters ('n')
     case MONS_NECROPHAGE:
         return TILEP_MONS_NECROPHAGE;
+    case MONS_GHOUL:
+        return TILEP_MONS_GHOUL;
+    case MONS_ROTTING_HULK:
+        return TILEP_MONS_ROTTING_HULK;
+
+    // orcs ('o')
     case MONS_ORC:
         return TILEP_MONS_ORC;
+    case MONS_ORC_WIZARD:
+        return TILEP_MONS_ORC_WIZARD;
+    case MONS_ORC_PRIEST:
+        return TILEP_MONS_ORC_PRIEST;
+    case MONS_ORC_WARRIOR:
+        return TILEP_MONS_ORC_WARRIOR;
+    case MONS_ORC_KNIGHT:
+        return TILEP_MONS_ORC_KNIGHT;
+    case MONS_ORC_WARLORD:
+        return TILEP_MONS_ORC_WARLORD;
+    case MONS_ORC_SORCERER:
+        return TILEP_MONS_ORC_SORCERER;
+    case MONS_ORC_HIGH_PRIEST:
+        return TILEP_MONS_ORC_HIGH_PRIEST;
+
+    // phantoms and ghosts ('p')
     case MONS_PHANTOM:
         return TILEP_MONS_PHANTOM;
-    case MONS_QUASIT:
-        return TILEP_MONS_QUASIT;
+    case MONS_HUNGRY_GHOST:
+        return TILEP_MONS_HUNGRY_GHOST;
+    case MONS_FLAYED_GHOST:
+        return TILEP_MONS_FLAYED_GHOST;
+    case MONS_PLAYER_GHOST:
+        return TILEP_MONS_PLAYER_GHOST;
+    case MONS_INSUBSTANTIAL_WISP:
+        return TILEP_MONS_INSUBSTANTIAL_WISP;
+
+    // rodents ('r')
     case MONS_RAT:
         return TILEP_MONS_RAT;
+    case MONS_QUOKKA:
+        return TILEP_MONS_QUOKKA;
+    case MONS_GREY_RAT:
+        return TILEP_MONS_GREY_RAT;
+    case MONS_GREEN_RAT:
+        return TILEP_MONS_GREEN_RAT;
+    case MONS_ORANGE_RAT:
+        return TILEP_MONS_ORANGE_RAT;
+
+    // spiders ('s')
+    case MONS_GIANT_MITE:
+        return TILEP_MONS_GIANT_MITE;
+    case MONS_GIANT_CENTIPEDE:
+        return TILEP_MONS_GIANT_CENTIPEDE;
     case MONS_SCORPION:
         return TILEP_MONS_SCORPION;
+    case MONS_WOLF_SPIDER:
+        return TILEP_MONS_WOLF_SPIDER;
+    case MONS_TRAPDOOR_SPIDER:
+        return TILEP_MONS_TRAPDOOR_SPIDER;
+    case MONS_REDBACK:
+        return TILEP_MONS_REDBACK;
+
+    // minotaur ('t')
+    case MONS_MINOTAUR:
+        return TILEP_MONS_MINOTAUR;
+
+    // ugly things ('u')
     case MONS_UGLY_THING :
         return TILEP_MONS_UGLY_THING ;
+    case MONS_VERY_UGLY_THING:
+        return TILEP_MONS_VERY_UGLY_THING;
+
+    // vortices ('v')
     case MONS_FIRE_VORTEX:
         return TILEP_MONS_FIRE_VORTEX;
+    case MONS_SPATIAL_VORTEX:
+        return TILEP_MONS_SPATIAL_VORTEX;
+
+    // elementals (different symbols)
+    case MONS_AIR_ELEMENTAL:
+        return TILEP_MONS_AIR_ELEMENTAL;
+    case MONS_EARTH_ELEMENTAL:
+        return TILEP_MONS_EARTH_ELEMENTAL;
+    case MONS_FIRE_ELEMENTAL:
+        return TILEP_MONS_FIRE_ELEMENTAL;
+    case MONS_WATER_ELEMENTAL:
+        return TILEP_MONS_WATER_ELEMENTAL;
+
+    // worms and larvae ('w')
+    case MONS_KILLER_BEE_LARVA:
+        return TILEP_MONS_KILLER_BEE_LARVA;
     case MONS_WORM:
         return TILEP_MONS_WORM;
+    case MONS_ANT_LARVA:
+        return TILEP_MONS_ANT_LARVA;
+    case MONS_BRAIN_WORM:
+        return TILEP_MONS_BRAIN_WORM;
+    case MONS_SWAMP_WORM:
+        return TILEP_MONS_SWAMP_WORM;
+    case MONS_SPINY_WORM:
+        return TILEP_MONS_SPINY_WORM;
+
+    // small abominations ('x')
+    case MONS_UNSEEN_HORROR:
+        return TILEP_MONS_UNSEEN_HORROR;
     case MONS_ABOMINATION_SMALL:
         return TILEP_MONS_ABOMINATION_SMALL;
+
+    // flying insects ('y')
     case MONS_YELLOW_WASP:
         return TILEP_MONS_YELLOW_WASP;
+    case MONS_GIANT_MOSQUITO:
+        return TILEP_MONS_GIANT_MOSQUITO;
+    case MONS_GIANT_BLOWFLY:
+        return TILEP_MONS_GIANT_BLOWFLY;
+    case MONS_RED_WASP:
+        return TILEP_MONS_RED_WASP;
+    case MONS_MOTH_OF_WRATH:
+        return TILEP_MONS_MOTH_OF_WRATH;
+
+    // small zombies etc. ('z')
     case MONS_ZOMBIE_SMALL:
         return TILEP_MONS_ZOMBIE_SMALL;
+    case MONS_SIMULACRUM_SMALL:
+        return TILEP_MONS_SIMULACRUM_SMALL;
+    case MONS_SKELETON_SMALL:
+        return TILEP_MONS_SKELETON_SMALL;
+    case MONS_SKELETAL_WARRIOR:
+        return TILEP_MONS_SKELETAL_WARRIOR;
+    case MONS_FLYING_SKULL:
+        return TILEP_MONS_FLYING_SKULL;
+    case MONS_FLAMING_CORPSE:
+        return TILEP_MONS_FLAMING_CORPSE;
+    case MONS_CURSE_SKULL:
+        return TILEP_MONS_CURSE_SKULL;
+    case MONS_CURSE_TOE:
+        return TILEP_MONS_CURSE_TOE;
+
+    // angelic beings ('A')
     case MONS_ANGEL:
         return TILEP_MONS_ANGEL;
+    case MONS_DAEVA:
+        return TILEP_MONS_DAEVA;
+
+    // beetles ('B')
     case MONS_GIANT_BEETLE:
         return TILEP_MONS_GIANT_BEETLE;
+    case MONS_BOULDER_BEETLE:
+        return TILEP_MONS_BOULDER_BEETLE;
+    case MONS_BORING_BEETLE:
+        return TILEP_MONS_BORING_BEETLE;
+
+    // cyclops and giants ('C')
+    case MONS_HILL_GIANT:
+        return TILEP_MONS_HILL_GIANT;
+    case MONS_ETTIN:
+        return TILEP_MONS_ETTIN;
     case MONS_CYCLOPS:
         return TILEP_MONS_CYCLOPS;
+    case MONS_FIRE_GIANT:
+        return TILEP_MONS_FIRE_GIANT;
+    case MONS_FROST_GIANT:
+        return TILEP_MONS_FROST_GIANT;
+    case MONS_STONE_GIANT:
+        return TILEP_MONS_STONE_GIANT;
+    case MONS_TITAN:
+        return TILEP_MONS_TITAN;
+
+    // dragons ('D')
+    case MONS_WYVERN:
+        return TILEP_MONS_WYVERN;
     case MONS_DRAGON:
         return TILEP_MONS_DRAGON;
-    case MONS_TWO_HEADED_OGRE:
-        return TILEP_MONS_TWO_HEADED_OGRE;
-    case MONS_FIEND:
-        return TILEP_MONS_FIEND;
+    case MONS_HYDRA:
+        // Number of heads
+        return TILEP_MONS_HYDRA + std::min((int)mon->number, 7) - 1;
+    case MONS_ICE_DRAGON:
+        return TILEP_MONS_ICE_DRAGON;
+    case MONS_STEAM_DRAGON:
+        return TILEP_MONS_STEAM_DRAGON;
+    case MONS_SWAMP_DRAGON:
+        return TILEP_MONS_SWAMP_DRAGON;
+    case MONS_MOTTLED_DRAGON:
+        return TILEP_MONS_MOTTLED_DRAGON;
+    case MONS_QUICKSILVER_DRAGON:
+        return TILEP_MONS_QUICKSILVER_DRAGON;
+    case MONS_IRON_DRAGON:
+        return TILEP_MONS_IRON_DRAGON;
+    case MONS_STORM_DRAGON:
+        return TILEP_MONS_STORM_DRAGON;
+    case MONS_GOLDEN_DRAGON:
+        return TILEP_MONS_GOLDEN_DRAGON;
+    case MONS_SHADOW_DRAGON:
+        return TILEP_MONS_SHADOW_DRAGON;
+    case MONS_SKELETAL_DRAGON:
+        return TILEP_MONS_SKELETAL_DRAGON;
+    case MONS_SERPENT_OF_HELL:
+        return TILEP_MONS_SERPENT_OF_HELL;
+
+    // efreet ('E')
+    case MONS_EFREET:
+        return TILEP_MONS_EFREET;
+
+    // frogs ('F')
+    case MONS_GIANT_FROG:
+        return TILEP_MONS_GIANT_FROG;
+    case MONS_GIANT_BROWN_FROG:
+        return TILEP_MONS_GIANT_BROWN_FROG;
+    case MONS_SPINY_FROG:
+        return TILEP_MONS_SPINY_FROG;
+    case MONS_BLINK_FROG:
+        return TILEP_MONS_BLINK_FROG;
+
+    // eyes and spores ('G')
     case MONS_GIANT_SPORE:
         return TILEP_MONS_GIANT_SPORE;
-    case MONS_HOBGOBLIN:
-        return TILEP_MONS_HOBGOBLIN;
+    case MONS_GIANT_EYEBALL:
+        return TILEP_MONS_GIANT_EYEBALL;
+    case MONS_EYE_OF_DRAINING:
+        return TILEP_MONS_EYE_OF_DRAINING;
+    case MONS_GIANT_ORANGE_BRAIN:
+        return TILEP_MONS_GIANT_ORANGE_BRAIN;
+    case MONS_GREAT_ORB_OF_EYES:
+        return TILEP_MONS_GREAT_ORB_OF_EYES;
+    case MONS_SHINING_EYE:
+        return TILEP_MONS_SHINING_EYE;
+    case MONS_EYE_OF_DEVASTATION:
+        return TILEP_MONS_EYE_OF_DEVASTATION;
+
+    // half-breeds ('H')
+    case MONS_HIPPOGRIFF:
+        return TILEP_MONS_HIPPOGRIFF;
+    case MONS_MANTICORE:
+        return TILEP_MONS_MANTICORE;
+    case MONS_GRIFFON:
+        return TILEP_MONS_GRIFFON;
+    case MONS_SPHINX:
+        return TILEP_MONS_SPHINX;
+
+    // ice beast ('I')
     case MONS_ICE_BEAST:
         return TILEP_MONS_ICE_BEAST;
+
+    // jellies ('J')
+    case MONS_OOZE:
+        return TILEP_MONS_OOZE;
     case MONS_JELLY:
         return TILEP_MONS_JELLY;
+    case MONS_SLIME_CREATURE:
+        return TILEP_MONS_SLIME_CREATURE;
+    case MONS_PULSATING_LUMP:
+        return TILEP_MONS_PULSATING_LUMP;
+    case MONS_GIANT_AMOEBA:
+        return TILEP_MONS_GIANT_AMOEBA;
+    case MONS_BROWN_OOZE:
+        return TILEP_MONS_BROWN_OOZE;
+    case MONS_AZURE_JELLY:
+        return TILEP_MONS_AZURE_JELLY;
+    case MONS_DEATH_OOZE:
+        return TILEP_MONS_DEATH_OOZE;
+    case MONS_ACID_BLOB:
+        return TILEP_MONS_ACID_BLOB;
+    case MONS_ROYAL_JELLY:
+        return TILEP_MONS_ROYAL_JELLY;
+
+    // kobolds ('K')
     case MONS_KOBOLD:
         return TILEP_MONS_KOBOLD;
+    case MONS_BIG_KOBOLD:
+        return TILEP_MONS_BIG_KOBOLD;
+    case MONS_KOBOLD_DEMONOLOGIST:
+        return TILEP_MONS_KOBOLD_DEMONOLOGIST;
+
+    // liches ('L')
     case MONS_LICH:
         return TILEP_MONS_LICH;
+    case MONS_ANCIENT_LICH:
+        return TILEP_MONS_ANCIENT_LICH;
+
+    // mummies ('M')
     case MONS_MUMMY:
         return TILEP_MONS_MUMMY;
+    case MONS_GUARDIAN_MUMMY:
+        return TILEP_MONS_GUARDIAN_MUMMY;
+    case MONS_GREATER_MUMMY:
+        return TILEP_MONS_GREATER_MUMMY;
+    case MONS_MUMMY_PRIEST:
+        return TILEP_MONS_MUMMY_PRIEST;
+
+    // nagas ('N')
+    case MONS_NAGA:
+        return TILEP_MONS_NAGA;
     case MONS_GUARDIAN_NAGA:
         return TILEP_MONS_GUARDIAN_NAGA;
+    case MONS_NAGA_MAGE:
+        return TILEP_MONS_NAGA_MAGE;
+    case MONS_NAGA_WARRIOR:
+        return TILEP_MONS_NAGA_WARRIOR;
+    case MONS_GREATER_NAGA:
+        return TILEP_MONS_GREATER_NAGA;
+
+    // ogres ('O')
     case MONS_OGRE:
         return TILEP_MONS_OGRE;
+    case MONS_TWO_HEADED_OGRE:
+        return TILEP_MONS_TWO_HEADED_OGRE;
+    case MONS_OGRE_MAGE:
+        return TILEP_MONS_OGRE_MAGE;
+
+    // plants ('P')
     case MONS_PLANT:
         return TILEP_MONS_PLANT;
+    case MONS_OKLOB_PLANT:
+        return TILEP_MONS_OKLOB_PLANT;
+
+    // queen insects ('Q')
     case MONS_QUEEN_BEE:
         return TILEP_MONS_QUEEN_BEE;
+    case MONS_QUEEN_ANT:
+        return TILEP_MONS_QUEEN_ANT;
+
+    // rakshasa ('R')
     case MONS_RAKSHASA:
         return TILEP_MONS_RAKSHASA;
+    case MONS_RAKSHASA_FAKE:
+        return TILEP_MONS_RAKSHASA_FAKE;
+
+    // snakes ('S')
+    case MONS_SMALL_SNAKE:
+        return TILEP_MONS_SMALL_SNAKE;
     case MONS_SNAKE:
         return TILEP_MONS_SNAKE;
+    case MONS_BROWN_SNAKE:
+        return TILEP_MONS_BROWN_SNAKE;
+    case MONS_BLACK_SNAKE:
+        return TILEP_MONS_BLACK_SNAKE;
+    case MONS_YELLOW_SNAKE:
+        return TILEP_MONS_YELLOW_SNAKE;
+    case MONS_GREY_SNAKE:
+        return TILEP_MONS_GREY_SNAKE;
+
+    // trolls ('T')
     case MONS_TROLL:
         return TILEP_MONS_TROLL;
-    case MONS_UNSEEN_HORROR:
-        return TILEP_MONS_UNSEEN_HORROR;
+    case MONS_ROCK_TROLL:
+        return TILEP_MONS_ROCK_TROLL;
+    case MONS_IRON_TROLL:
+        return TILEP_MONS_IRON_TROLL;
+    case MONS_DEEP_TROLL:
+        return TILEP_MONS_DEEP_TROLL;
+
+    // bears ('U')
+    case MONS_BEAR:
+        return TILEP_MONS_BEAR;
+    case MONS_GRIZZLY_BEAR:
+        return TILEP_MONS_GRIZZLY_BEAR;
+    case MONS_POLAR_BEAR:
+        return TILEP_MONS_POLAR_BEAR;
+    case MONS_BLACK_BEAR:
+        return TILEP_MONS_BLACK_BEAR;
+
+    // vampires ('V')
     case MONS_VAMPIRE:
         return TILEP_MONS_VAMPIRE;
+    case MONS_VAMPIRE_KNIGHT:
+        return TILEP_MONS_VAMPIRE_KNIGHT;
+    case MONS_VAMPIRE_MAGE:
+        return TILEP_MONS_VAMPIRE_MAGE;
+
+    // wraiths ('W')
+    case MONS_WIGHT:
+        return TILEP_MONS_WIGHT;
     case MONS_WRAITH:
         return TILEP_MONS_WRAITH;
+    case MONS_SHADOW_WRAITH:
+        return TILEP_MONS_SHADOW_WRAITH;
+    case MONS_FREEZING_WRAITH:
+        return TILEP_MONS_FREEZING_WRAITH;
+    case MONS_SPECTRAL_WARRIOR:
+        return TILEP_MONS_SPECTRAL_WARRIOR;
+    case MONS_SPECTRAL_THING:
+        return TILEP_MONS_SPECTRAL_THING;
+
+    // large abominations ('X')
     case MONS_ABOMINATION_LARGE:
         return TILEP_MONS_ABOMINATION_LARGE + ((mon->colour)%7);
+    case MONS_TENTACLED_MONSTROSITY:
+        return TILEP_MONS_TENTACLED_MONSTROSITY;
+    case MONS_ORB_GUARDIAN:
+        return TILEP_MONS_ORB_GUARDIAN;
+
+    // yaks and sheep ('Y')
+    case MONS_SHEEP:
+        return TILEP_MONS_SHEEP;
     case MONS_YAK:
         return TILEP_MONS_YAK;
+    case MONS_DEATH_YAK:
+        return TILEP_MONS_DEATH_YAK;
+
+    // large zombies etc. ('Z')
     case MONS_ZOMBIE_LARGE:
         return TILEP_MONS_ZOMBIE_LARGE;
-    case MONS_ORC_WARRIOR:
-        return TILEP_MONS_ORC_WARRIOR;
-    case MONS_KOBOLD_DEMONOLOGIST:
-        return TILEP_MONS_KOBOLD_DEMONOLOGIST;
-    case MONS_ORC_WIZARD:
-        return TILEP_MONS_ORC_WIZARD;
-    case MONS_ORC_KNIGHT:
-        return TILEP_MONS_ORC_KNIGHT;
-    case MONS_WYVERN:
-        return TILEP_MONS_WYVERN;
-    case MONS_BIG_KOBOLD:
-        return TILEP_MONS_BIG_KOBOLD;
-    case MONS_GIANT_EYEBALL:
-        return TILEP_MONS_GIANT_EYEBALL;
-    case MONS_WIGHT:
-        return TILEP_MONS_WIGHT;
-    case MONS_OKLOB_PLANT:
-        return TILEP_MONS_OKLOB_PLANT;
-    case MONS_WOLF_SPIDER:
-        return TILEP_MONS_WOLF_SPIDER;
-    case MONS_TRAPDOOR_SPIDER:
-        return TILEP_MONS_TRAPDOOR_SPIDER;
-    case MONS_SHADOW:
-        return TILEP_MONS_SHADOW;
-    case MONS_HUNGRY_GHOST:
-        return TILEP_MONS_HUNGRY_GHOST;
-    case MONS_EYE_OF_DRAINING:
-        return TILEP_MONS_EYE_OF_DRAINING;
-    case MONS_BUTTERFLY:
-        return TILEP_MONS_BUTTERFLY + ((mon->colour)%7);
-    case MONS_WANDERING_MUSHROOM:
-        return TILEP_MONS_WANDERING_MUSHROOM;
-    case MONS_EFREET:
-        return TILEP_MONS_EFREET;
-    case MONS_BRAIN_WORM:
-        return TILEP_MONS_BRAIN_WORM;
-    case MONS_GIANT_ORANGE_BRAIN:
-        return TILEP_MONS_GIANT_ORANGE_BRAIN;
-    case MONS_BOULDER_BEETLE:
-        return TILEP_MONS_BOULDER_BEETLE;
-    case MONS_FLYING_SKULL:
-        return TILEP_MONS_FLYING_SKULL;
-    case MONS_HELL_HOUND:
-        return TILEP_MONS_HELL_HOUND;
-    case MONS_MINOTAUR:
-        return TILEP_MONS_MINOTAUR;
-    case MONS_ICE_DRAGON:
-        return TILEP_MONS_ICE_DRAGON;
-    case MONS_SLIME_CREATURE:
-        return TILEP_MONS_SLIME_CREATURE;
-    case MONS_FREEZING_WRAITH:
-        return TILEP_MONS_FREEZING_WRAITH;
-    case MONS_RAKSHASA_FAKE:
-        return TILEP_MONS_RAKSHASA_FAKE;
-    case MONS_GREAT_ORB_OF_EYES:
-        return TILEP_MONS_GREAT_ORB_OF_EYES;
-    case MONS_HELLION:
-        return TILEP_MONS_HELLION;
-    case MONS_ROTTING_DEVIL:
-        return TILEP_MONS_ROTTING_DEVIL;
-    case MONS_TORMENTOR:
-        return TILEP_MONS_TORMENTOR;
-    case MONS_REAPER:
-        return TILEP_MONS_REAPER;
-    case MONS_SOUL_EATER:
-        return TILEP_MONS_SOUL_EATER;
-    case MONS_HAIRY_DEVIL:
-        return TILEP_MONS_HAIRY_DEVIL;
-    case MONS_ICE_DEVIL:
-        return TILEP_MONS_ICE_DEVIL;
-    case MONS_BLUE_DEVIL:
-        return TILEP_MONS_BLUE_DEVIL;
-    case MONS_BEAST:
-        return TILEP_MONS_BEAST;
-    case MONS_IRON_DEVIL:
-        return TILEP_MONS_IRON_DEVIL;
-    case MONS_GLOWING_SHAPESHIFTER:
-        return TILEP_MONS_GLOWING_SHAPESHIFTER;
-    case MONS_SHAPESHIFTER:
-        return TILEP_MONS_SHAPESHIFTER;
-    case MONS_GIANT_MITE:
-        return TILEP_MONS_GIANT_MITE;
-    case MONS_STEAM_DRAGON:
-        return TILEP_MONS_STEAM_DRAGON;
-    case MONS_VERY_UGLY_THING:
-        return TILEP_MONS_VERY_UGLY_THING;
-    case MONS_ORC_SORCERER:
-        return TILEP_MONS_ORC_SORCERER;
-    case MONS_HIPPOGRIFF:
-        return TILEP_MONS_HIPPOGRIFF;
-    case MONS_GRIFFON:
-        return TILEP_MONS_GRIFFON;
-
-    case MONS_HYDRA:
-        // Number of heads
-        return TILEP_MONS_HYDRA + std::min((int)mon->number, 7) - 1;
-
-    case MONS_SKELETON_SMALL:
-        return TILEP_MONS_SKELETON_SMALL;
     case MONS_SKELETON_LARGE:
         return TILEP_MONS_SKELETON_LARGE;
+    case MONS_SIMULACRUM_LARGE:
+        return TILEP_MONS_SIMULACRUM_LARGE;
+
+    // water monsters
+    case MONS_BIG_FISH:
+        return TILEP_MONS_BIG_FISH;
+    case MONS_GIANT_GOLDFISH:
+        return TILEP_MONS_GIANT_GOLDFISH;
+    case MONS_ELECTRICAL_EEL:
+        return TILEP_MONS_ELECTRICAL_EEL;
+    case MONS_JELLYFISH:
+        return TILEP_MONS_JELLYFISH;
+
+    // lava monsters
+    case MONS_LAVA_WORM:
+        return TILEP_MONS_LAVA_WORM;
+    case MONS_LAVA_FISH:
+        return TILEP_MONS_LAVA_FISH;
+    case MONS_LAVA_SNAKE:
+        return TILEP_MONS_LAVA_SNAKE;
+    case MONS_SALAMANDER:
+        return TILEP_MONS_SALAMANDER;
+
+    // monsters moving through rock
+    case MONS_ROCK_WORM:
+        return TILEP_MONS_ROCK_WORM;
+
+    // humans ('@')
+    case MONS_HUMAN:
+        return TILEP_MONS_HUMAN;
     case MONS_HELL_KNIGHT:
         return TILEP_MONS_HELL_KNIGHT;
     case MONS_NECROMANCER:
         return TILEP_MONS_NECROMANCER;
     case MONS_WIZARD:
         return TILEP_MONS_WIZARD;
-    case MONS_ORC_PRIEST:
-        return TILEP_MONS_ORC_PRIEST;
-    case MONS_ORC_HIGH_PRIEST:
-        return TILEP_MONS_ORC_HIGH_PRIEST;
-    case MONS_HUMAN:
-        return TILEP_MONS_HUMAN;
-    case MONS_GNOLL:
-        return TILEP_MONS_GNOLL;
-    case MONS_CLAY_GOLEM:
-        return TILEP_MONS_CLAY_GOLEM;
-    case MONS_WOOD_GOLEM:
-        return TILEP_MONS_WOOD_GOLEM;
-    case MONS_STONE_GOLEM:
-        return TILEP_MONS_STONE_GOLEM;
-    case MONS_IRON_GOLEM:
-        return TILEP_MONS_IRON_GOLEM;
-    case MONS_CRYSTAL_GOLEM:
-        return TILEP_MONS_CRYSTAL_GOLEM;
-    case MONS_TOENAIL_GOLEM:
-        return TILEP_MONS_TOENAIL_GOLEM;
-    case MONS_MOTTLED_DRAGON:
-        return TILEP_MONS_MOTTLED_DRAGON;
-    case MONS_EARTH_ELEMENTAL:
-        return TILEP_MONS_EARTH_ELEMENTAL;
-    case MONS_FIRE_ELEMENTAL:
-        return TILEP_MONS_FIRE_ELEMENTAL;
-    case MONS_AIR_ELEMENTAL:
-        return TILEP_MONS_AIR_ELEMENTAL;
-    case MONS_ICE_FIEND:
-        return TILEP_MONS_ICE_FIEND;
-    case MONS_SHADOW_FIEND:
-        return TILEP_MONS_SHADOW_FIEND;
-    case MONS_BROWN_SNAKE:
-        return TILEP_MONS_BROWN_SNAKE;
-    case MONS_GIANT_LIZARD:
-        return TILEP_MONS_GIANT_LIZARD;
-    case MONS_SPECTRAL_WARRIOR:
-        return TILEP_MONS_SPECTRAL_WARRIOR;
-    case MONS_PULSATING_LUMP:
-        return TILEP_MONS_PULSATING_LUMP;
-    case MONS_STORM_DRAGON:
-        return TILEP_MONS_STORM_DRAGON;
-    case MONS_YAKTAUR:
-        return TILEP_MONS_YAKTAUR + _bow_offset(mon);
-    case MONS_DEATH_YAK:
-        return TILEP_MONS_DEATH_YAK;
-    case MONS_ROCK_TROLL:
-        return TILEP_MONS_ROCK_TROLL;
-    case MONS_STONE_GIANT:
-        return TILEP_MONS_STONE_GIANT;
-    case MONS_FLAYED_GHOST:
-        return TILEP_MONS_FLAYED_GHOST;
-    case MONS_FLAMING_CORPSE:
-        return TILEP_MONS_FLAMING_CORPSE;
-    case MONS_BUMBLEBEE:
-        return TILEP_MONS_BUMBLEBEE;
-    case MONS_REDBACK:
-        return TILEP_MONS_REDBACK;
-    case MONS_INSUBSTANTIAL_WISP:
-        return TILEP_MONS_INSUBSTANTIAL_WISP;
-    case MONS_VAPOUR:
-        return TILEP_MONS_VAPOUR;
-    case MONS_OGRE_MAGE:
-        return TILEP_MONS_OGRE_MAGE;
-    case MONS_SPINY_WORM:
-        return TILEP_MONS_SPINY_WORM;
+    case MONS_VAULT_GUARD:
+        return TILEP_MONS_VAULT_GUARD;
+    case MONS_SHAPESHIFTER:
+        return TILEP_MONS_SHAPESHIFTER;
+    case MONS_GLOWING_SHAPESHIFTER:
+        return TILEP_MONS_GLOWING_SHAPESHIFTER;
+    case MONS_KILLER_KLOWN:
+        return TILEP_MONS_KILLER_KLOWN;
+
+    // mimics
+    case MONS_GOLD_MIMIC:
+    case MONS_WEAPON_MIMIC:
+    case MONS_ARMOUR_MIMIC:
+    case MONS_SCROLL_MIMIC:
+    case MONS_POTION_MIMIC:
+    {
+      // Use item tile
+      item_def  item;
+      get_mimic_item( mon, item );
+      return tileidx_item(item);
+    }
 
     case MONS_DANCING_WEAPON:
     {
@@ -425,100 +762,11 @@ static int _tileidx_monster_base(const monsters *mon, bool detected)
         return tileidx_item(item) | TILE_FLAG_ANIM_WEP;
     }
 
-    case MONS_TITAN:
-        return TILEP_MONS_TITAN;
-    case MONS_GOLDEN_DRAGON:
-        return TILEP_MONS_GOLDEN_DRAGON;
-    case MONS_ELF:
-        return TILEP_MONS_ELF;
-    case MONS_LINDWURM:
-        return TILEP_MONS_LINDWURM;
-    case MONS_ELEPHANT_SLUG:
-        return TILEP_MONS_ELEPHANT_SLUG;
-    case MONS_WAR_DOG:
-        return TILEP_MONS_WAR_DOG;
-    case MONS_GREY_RAT:
-        return TILEP_MONS_GREY_RAT;
-    case MONS_GREEN_RAT:
-        return TILEP_MONS_GREEN_RAT;
-    case MONS_ORANGE_RAT:
-        return TILEP_MONS_ORANGE_RAT;
-    case MONS_BLACK_SNAKE:
-        return TILEP_MONS_BLACK_SNAKE;
-    case MONS_SHEEP:
-        return TILEP_MONS_SHEEP;
-    case MONS_GHOUL:
-        return TILEP_MONS_GHOUL;
-    case MONS_HOG:
-        return TILEP_MONS_HOG;
-    case MONS_GIANT_MOSQUITO:
-        return TILEP_MONS_GIANT_MOSQUITO;
-    case MONS_GIANT_CENTIPEDE:
-        return TILEP_MONS_GIANT_CENTIPEDE;
-    case MONS_IRON_TROLL:
-        return TILEP_MONS_IRON_TROLL;
-    case MONS_NAGA:
-        return TILEP_MONS_NAGA;
-    case MONS_FIRE_GIANT:
-        return TILEP_MONS_FIRE_GIANT;
-    case MONS_FROST_GIANT:
-        return TILEP_MONS_FROST_GIANT;
-    case MONS_FIREDRAKE:
-        return TILEP_MONS_FIREDRAKE;
-    case MONS_SHADOW_DRAGON:
-        return TILEP_MONS_SHADOW_DRAGON;
-    case MONS_YELLOW_SNAKE:
-        return TILEP_MONS_YELLOW_SNAKE;
-    case MONS_GREY_SNAKE:
-        return TILEP_MONS_GREY_SNAKE;
-    case MONS_DEEP_TROLL:
-        return TILEP_MONS_DEEP_TROLL;
-    case MONS_GIANT_BLOWFLY:
-        return TILEP_MONS_GIANT_BLOWFLY;
-    case MONS_RED_WASP:
-        return TILEP_MONS_RED_WASP;
-    case MONS_SWAMP_DRAGON:
-        return TILEP_MONS_SWAMP_DRAGON;
-    case MONS_SWAMP_DRAKE:
-        return TILEP_MONS_SWAMP_DRAKE;
-    case MONS_SOLDIER_ANT:
-        return TILEP_MONS_SOLDIER_ANT;
-    case MONS_HILL_GIANT:
-        return TILEP_MONS_HILL_GIANT;
-    case MONS_QUEEN_ANT:
-        return TILEP_MONS_QUEEN_ANT;
-    case MONS_ANT_LARVA:
-        return TILEP_MONS_ANT_LARVA;
-    case MONS_GIANT_FROG:
-        return TILEP_MONS_GIANT_FROG;
-    case MONS_GIANT_BROWN_FROG:
-        return TILEP_MONS_GIANT_BROWN_FROG;
-    case MONS_SPINY_FROG:
-        return TILEP_MONS_SPINY_FROG;
-    case MONS_BLINK_FROG:
-        return TILEP_MONS_BLINK_FROG;
-    case MONS_GIANT_COCKROACH:
-        return TILEP_MONS_GIANT_COCKROACH;
-    case MONS_SMALL_SNAKE:
-        return TILEP_MONS_SMALL_SNAKE;
-    case MONS_SHUGGOTH:
-        return TILE_TODO;
-    case MONS_WOLF:
-        return TILEP_MONS_WOLF;
-    case MONS_WARG:
-        return TILEP_MONS_WARG;
-    case MONS_BEAR:
-        return TILEP_MONS_BEAR;
-    case MONS_GRIZZLY_BEAR:
-        return TILEP_MONS_GRIZZLY_BEAR;
-    case MONS_POLAR_BEAR:
-        return TILEP_MONS_POLAR_BEAR;
-    case MONS_BLACK_BEAR:
-        return TILEP_MONS_BLACK_BEAR;
-    case MONS_SIMULACRUM_SMALL:
-        return TILEP_MONS_SIMULACRUM_SMALL;
-    case MONS_SIMULACRUM_LARGE:
-        return TILEP_MONS_SIMULACRUM_LARGE;
+    // '5' demons
+    case MONS_IMP:
+        return TILEP_MONS_IMP;
+    case MONS_QUASIT:
+        return TILEP_MONS_QUASIT;
     case MONS_WHITE_IMP:
         return TILEP_MONS_WHITE_IMP;
     case MONS_LEMURE:
@@ -529,16 +777,66 @@ static int _tileidx_monster_base(const monsters *mon, bool detected)
         return TILEP_MONS_MANES;
     case MONS_MIDGE:
         return TILEP_MONS_MIDGE;
+    case MONS_SHADOW_IMP:
+        return TILEP_MONS_SHADOW_IMP;
+
+    // '4' demons
+    case MONS_RED_DEVIL:
+        return TILEP_MONS_RED_DEVIL;
+    case MONS_HAIRY_DEVIL:
+        return TILEP_MONS_HAIRY_DEVIL;
+    case MONS_ROTTING_DEVIL:
+        return TILEP_MONS_ROTTING_DEVIL;
+    case MONS_BEAST:
+        return TILEP_MONS_BEAST;
+    case MONS_SMOKE_DEMON:
+        return TILEP_MONS_SMOKE_DEMON;
+
+    // '3' demons
+    case MONS_HELLION:
+        return TILEP_MONS_HELLION;
+    case MONS_TORMENTOR:
+        return TILEP_MONS_TORMENTOR;
+    case MONS_BLUE_DEVIL:
+        return TILEP_MONS_BLUE_DEVIL;
+    case MONS_IRON_DEVIL:
+        return TILEP_MONS_IRON_DEVIL;
     case MONS_NEQOXEC:
         return TILEP_MONS_NEQOXEC;
     case MONS_ORANGE_DEMON:
         return TILEP_MONS_ORANGE_DEMON;
     case MONS_HELLWING:
         return TILEP_MONS_HELLWING;
-    case MONS_SMOKE_DEMON:
-        return TILEP_MONS_SMOKE_DEMON;
     case MONS_YNOXINUL:
         return TILEP_MONS_YNOXINUL;
+    case MONS_DEMONIC_CRAWLER:
+        return TILEP_MONS_DEMONIC_CRAWLER;
+    case MONS_SHADOW_DEMON:
+        return TILEP_MONS_SHADOW_DEMON;
+    case MONS_CHAOS_SPAWN:
+        return TILEP_MONS_CHAOS_SPAWN;
+
+    // '2' demon
+    case MONS_SUN_DEMON:
+        return TILEP_MONS_SUN_DEMON;
+    case MONS_REAPER:
+        return TILEP_MONS_REAPER;
+    case MONS_SOUL_EATER:
+        return TILEP_MONS_SOUL_EATER;
+    case MONS_ICE_DEVIL:
+        return TILEP_MONS_ICE_DEVIL;
+    case MONS_LOROCYPROCA:
+        return TILEP_MONS_LOROCYPROCA;
+
+    // '1' demons
+    case MONS_FIEND:
+        return TILEP_MONS_FIEND;
+    case MONS_ICE_FIEND:
+        return TILEP_MONS_ICE_FIEND;
+    case MONS_SHADOW_FIEND:
+        return TILEP_MONS_SHADOW_FIEND;
+    case MONS_PIT_FIEND:
+        return TILEP_MONS_PIT_FIEND;
     case MONS_EXECUTIONER:
         return TILEP_MONS_EXECUTIONER;
     case MONS_GREEN_DEATH:
@@ -549,94 +847,84 @@ static int _tileidx_monster_base(const monsters *mon, bool detected)
         return TILEP_MONS_BALRUG;
     case MONS_CACODEMON:
         return TILEP_MONS_CACODEMON;
-    case MONS_DEMONIC_CRAWLER:
-        return TILEP_MONS_DEMONIC_CRAWLER;
-    case MONS_SUN_DEMON:
-        return TILEP_MONS_SUN_DEMON;
-    case MONS_SHADOW_IMP:
-        return TILEP_MONS_SHADOW_IMP;
-    case MONS_SHADOW_DEMON:
-        return TILEP_MONS_SHADOW_DEMON;
-    case MONS_LOROCYPROCA:
-        return TILEP_MONS_LOROCYPROCA;
-    case MONS_SHADOW_WRAITH:
-        return TILEP_MONS_SHADOW_WRAITH;
-    case MONS_GIANT_AMOEBA:
-        return TILEP_MONS_GIANT_AMOEBA;
-    case MONS_GIANT_SLUG:
-        return TILEP_MONS_GIANT_SLUG;
-    case MONS_GIANT_SNAIL:
-        return TILEP_MONS_GIANT_SNAIL;
-    case MONS_SPATIAL_VORTEX:
-        return TILEP_MONS_SPATIAL_VORTEX;
-    case MONS_PIT_FIEND:
-        return TILEP_MONS_PIT_FIEND;
-    case MONS_BORING_BEETLE:
-        return TILEP_MONS_BORING_BEETLE;
+
+    // non-living creatures
+    // golems ('8')
+    case MONS_CLAY_GOLEM:
+        return TILEP_MONS_CLAY_GOLEM;
+    case MONS_WOOD_GOLEM:
+        return TILEP_MONS_WOOD_GOLEM;
+    case MONS_IRON_GOLEM:
+        return TILEP_MONS_IRON_GOLEM;
+    case MONS_STONE_GOLEM:
+        return TILEP_MONS_STONE_GOLEM;
+    case MONS_CRYSTAL_GOLEM:
+        return TILEP_MONS_CRYSTAL_GOLEM;
+    case MONS_TOENAIL_GOLEM:
+        return TILEP_MONS_TOENAIL_GOLEM;
+    case MONS_ELECTRIC_GOLEM:
+        return TILEP_MONS_ELECTRIC_GOLEM;
+    // statues (also '8')
+    case MONS_ICE_STATUE:
+        return TILEP_ICE_STATUE;
+    case MONS_SILVER_STATUE:
+        return TILEP_SILVER_STATUE;
+    case MONS_ORANGE_STATUE:
+        return TILEP_ORANGE_CRYSTAL_STATUE;
+
+    // gargoyles ('9')
     case MONS_GARGOYLE:
         return TILEP_MONS_GARGOYLE;
     case MONS_METAL_GARGOYLE:
         return TILEP_MONS_METAL_GARGOYLE;
     case MONS_MOLTEN_GARGOYLE:
         return TILEP_MONS_MOLTEN_GARGOYLE;
-    case MONS_PROGRAM_BUG:
-        return TILEP_MONS_PROGRAM_BUG;
-    case MONS_MNOLEG:
-        return TILEP_MONS_MNOLEG;
-    case MONS_LOM_LOBON:
-        return TILEP_MONS_LOM_LOBON;
-    case MONS_CEREBOV:
-        return TILEP_MONS_CEREBOV;
-    case MONS_GLOORX_VLOQ:
-        return TILEP_MONS_GLOORX_VLOQ;
-    case MONS_MOLLUSC_LORD:
-        return TILE_TODO;
-    case MONS_NAGA_MAGE:
-        return TILEP_MONS_NAGA_MAGE;
-    case MONS_NAGA_WARRIOR:
-        return TILEP_MONS_NAGA_WARRIOR;
-    case MONS_ORC_WARLORD:
-        return TILEP_MONS_ORC_WARLORD;
-    case MONS_DEEP_ELF_SOLDIER:
-        return TILEP_MONS_DEEP_ELF_SOLDIER;
-    case MONS_DEEP_ELF_FIGHTER:
-        return TILEP_MONS_DEEP_ELF_FIGHTER;
-    case MONS_DEEP_ELF_KNIGHT:
-        return TILEP_MONS_DEEP_ELF_KNIGHT;
-    case MONS_DEEP_ELF_MAGE:
-        return TILEP_MONS_DEEP_ELF_MAGE;
-    case MONS_DEEP_ELF_SUMMONER:
-        return TILEP_MONS_DEEP_ELF_SUMMONER;
-    case MONS_DEEP_ELF_CONJURER:
-        return TILEP_MONS_DEEP_ELF_CONJURER;
-    case MONS_DEEP_ELF_PRIEST:
-        return TILEP_MONS_DEEP_ELF_PRIEST;
-    case MONS_DEEP_ELF_HIGH_PRIEST:
-        return TILEP_MONS_DEEP_ELF_HIGH_PRIEST;
-    case MONS_DEEP_ELF_DEMONOLOGIST:
-        return TILEP_MONS_DEEP_ELF_DEMONOLOGIST;
-    case MONS_DEEP_ELF_ANNIHILATOR:
-        return TILEP_MONS_DEEP_ELF_ANNIHILATOR;
-    case MONS_DEEP_ELF_SORCERER:
-        return TILEP_MONS_DEEP_ELF_SORCERER;
-    case MONS_DEEP_ELF_DEATH_MAGE:
-        return TILEP_MONS_DEEP_ELF_DEATH_MAGE;
-    case MONS_BROWN_OOZE:
-        return TILEP_MONS_BROWN_OOZE;
-    case MONS_AZURE_JELLY:
-        return TILEP_MONS_AZURE_JELLY;
-    case MONS_DEATH_OOZE:
-        return TILEP_MONS_DEATH_OOZE;
-    case MONS_ACID_BLOB:
-        return TILEP_MONS_ACID_BLOB;
-    case MONS_ROYAL_JELLY:
-        return TILEP_MONS_ROYAL_JELLY;
+
+    // major demons ('&')
+    case MONS_PANDEMONIUM_DEMON:
+        return TILEP_MONS_PANDEMONIUM_DEMON;
+
+    // ball lightning / orb of fire ('*')
+    case MONS_BALL_LIGHTNING:
+        return TILEP_MONS_BALL_LIGHTNING;
+    case MONS_ORB_OF_FIRE:
+        return TILEP_MONS_ORB_OF_FIRE;
+
+    // other symbols
+    case MONS_VAPOUR:
+        return TILEP_MONS_VAPOUR;
+    case MONS_SHADOW:
+        return TILEP_MONS_SHADOW;
+    case MONS_DEATH_COB:
+        return TILEP_MONS_DEATH_COB;
+
+    // non-human uniques
+    case MONS_IJYB:
+        return TILEP_MONS_IJYB;
+    case MONS_URUG:
+        return TILEP_MONS_URUG;
+    case MONS_EROLCHA:
+        return TILEP_MONS_EROLCHA;
+    case MONS_SNORG:
+        return TILEP_MONS_SNORG;
+    case MONS_POLYPHEMUS:
+        return TILEP_MONS_POLYPHEMUS;
+    case MONS_ANTAEUS:
+        return TILEP_MONS_ANTAEUS;
+    case MONS_TIAMAT:
+        return TILEP_MONS_TIAMAT;
+    case MONS_XTAHUA:
+        return TILEP_MONS_XTAHUA;
+    case MONS_BORIS:
+        return TILEP_MONS_BORIS;
+    case MONS_MURRAY:
+        return TILEP_MONS_MURRAY;
+
+    // human uniques ('@')
     case MONS_TERENCE:
         return TILEP_MONS_TERENCE;
     case MONS_JESSICA:
         return TILEP_MONS_JESSICA;
-    case MONS_IJYB:
-        return TILEP_MONS_IJYB;
     case MONS_SIGMUND:
         return TILEP_MONS_SIGMUND;
     case MONS_BLORK_THE_ORC:
@@ -645,18 +933,12 @@ static int _tileidx_monster_base(const monsters *mon, bool detected)
         return TILEP_MONS_EDMUND;
     case MONS_PSYCHE:
         return TILEP_MONS_PSYCHE;
-    case MONS_EROLCHA:
-        return TILEP_MONS_EROLCHA;
     case MONS_DONALD:
         return TILEP_MONS_DONALD;
-    case MONS_URUG:
-        return TILEP_MONS_URUG;
     case MONS_MICHAEL:
         return TILEP_MONS_MICHAEL;
     case MONS_JOSEPH:
         return TILEP_MONS_JOSEPH;
-    case MONS_SNORG:
-        return TILEP_MONS_SNORG;
     case MONS_ERICA:
         return TILEP_MONS_ERICA;
     case MONS_JOSEPHINE:
@@ -683,176 +965,30 @@ static int _tileidx_monster_base(const monsters *mon, bool detected)
         return TILEP_MONS_WAYNE;
     case MONS_DUANE:
         return TILEP_MONS_DUANE;
-    case MONS_XTAHUA:
-        return TILEP_MONS_XTAHUA;
     case MONS_NORRIS:
         return TILEP_MONS_NORRIS;
     case MONS_FREDERICK:
         return TILEP_MONS_FREDERICK;
     case MONS_MARGERY:
         return TILEP_MONS_MARGERY;
-    case MONS_POLYPHEMUS:
-        return TILEP_MONS_POLYPHEMUS;
-    case MONS_BORIS:
-        return TILEP_MONS_BORIS;
-    // Draconians handled above
-    case MONS_MURRAY:
-        return TILEP_MONS_MURRAY;
-    case MONS_TIAMAT:
-        return TILEP_MONS_TIAMAT;
-    case MONS_DEEP_ELF_BLADEMASTER:
-        return TILEP_MONS_DEEP_ELF_BLADEMASTER;
-    case MONS_DEEP_ELF_MASTER_ARCHER:
-        return TILEP_MONS_DEEP_ELF_MASTER_ARCHER;
 
+    // unique major demons ('&')
+    case MONS_MNOLEG:
+        return TILEP_MONS_MNOLEG;
+    case MONS_LOM_LOBON:
+        return TILEP_MONS_LOM_LOBON;
+    case MONS_CEREBOV:
+        return TILEP_MONS_CEREBOV;
+    case MONS_GLOORX_VLOQ:
+        return TILEP_MONS_GLOORX_VLOQ;
     case MONS_GERYON:
         return TILEP_MONS_GERYON;
     case MONS_DISPATER:
         return TILEP_MONS_DISPATER;
     case MONS_ASMODEUS:
         return TILEP_MONS_ASMODEUS;
-    case MONS_ANTAEUS:
-        return TILEP_MONS_ANTAEUS;
     case MONS_ERESHKIGAL:
         return TILEP_MONS_ERESHKIGAL;
-
-    case MONS_ANCIENT_LICH:
-        return TILEP_MONS_ANCIENT_LICH;
-    case MONS_OOZE:
-        return TILEP_MONS_OOZE;
-    case MONS_VAULT_GUARD:
-        return TILEP_MONS_VAULT_GUARD;
-    case MONS_CURSE_SKULL:
-        return TILEP_MONS_CURSE_SKULL;
-    case MONS_VAMPIRE_KNIGHT:
-        return TILEP_MONS_VAMPIRE_KNIGHT;
-    case MONS_VAMPIRE_MAGE:
-        return TILEP_MONS_VAMPIRE_MAGE;
-    case MONS_SHINING_EYE:
-        return TILEP_MONS_SHINING_EYE;
-    case MONS_ORB_GUARDIAN:
-        return TILEP_MONS_ORB_GUARDIAN;
-    case MONS_DAEVA:
-        return TILEP_MONS_DAEVA;
-    case MONS_SPECTRAL_THING:
-        return TILEP_MONS_SPECTRAL_THING;
-    case MONS_GREATER_NAGA:
-        return TILEP_MONS_GREATER_NAGA;
-    case MONS_SKELETAL_DRAGON:
-        return TILEP_MONS_SKELETAL_DRAGON;
-    case MONS_TENTACLED_MONSTROSITY:
-        return TILEP_MONS_TENTACLED_MONSTROSITY;
-    case MONS_SPHINX:
-        return TILEP_MONS_SPHINX;
-    case MONS_ROTTING_HULK:
-        return TILEP_MONS_ROTTING_HULK;
-    case MONS_GUARDIAN_MUMMY:
-        return TILEP_MONS_GUARDIAN_MUMMY;
-    case MONS_GREATER_MUMMY:
-        return TILEP_MONS_GREATER_MUMMY;
-    case MONS_MUMMY_PRIEST:
-        return TILEP_MONS_MUMMY_PRIEST;
-    case MONS_CENTAUR_WARRIOR:
-        return TILEP_MONS_CENTAUR_WARRIOR + _bow_offset(mon);
-    case MONS_YAKTAUR_CAPTAIN:
-        return TILEP_MONS_YAKTAUR_CAPTAIN + _bow_offset(mon);
-    case MONS_KILLER_KLOWN:
-        return TILEP_MONS_KILLER_KLOWN;
-    case MONS_ELECTRIC_GOLEM:
-        return TILEP_MONS_ELECTRIC_GOLEM;
-    case MONS_BALL_LIGHTNING:
-        return TILEP_MONS_BALL_LIGHTNING;
-    case MONS_ORB_OF_FIRE:
-        return TILEP_MONS_ORB_OF_FIRE;
-    case MONS_QUOKKA:
-        return TILEP_MONS_QUOKKA;
-    case MONS_EYE_OF_DEVASTATION:
-        return TILEP_MONS_EYE_OF_DEVASTATION;
-    case MONS_MOTH_OF_WRATH:
-        return TILEP_MONS_MOTH_OF_WRATH;
-    case MONS_DEATH_COB:
-        return TILEP_MONS_DEATH_COB;
-    case MONS_CURSE_TOE:
-        return TILEP_MONS_CURSE_TOE;
-
-    case MONS_GOLD_MIMIC:
-    case MONS_WEAPON_MIMIC:
-    case MONS_ARMOUR_MIMIC:
-    case MONS_SCROLL_MIMIC:
-    case MONS_POTION_MIMIC:
-    {
-      // Use item tile
-      item_def  item;
-      get_mimic_item( mon, item );
-      return tileidx_item(item);
-    }
-
-    case MONS_HELL_HOG:
-        return TILEP_MONS_HELL_HOG;
-    case MONS_SERPENT_OF_HELL:
-        return TILEP_MONS_SERPENT_OF_HELL;
-    case MONS_BOGGART:
-        return TILEP_MONS_BOGGART;
-    case MONS_QUICKSILVER_DRAGON:
-        return TILEP_MONS_QUICKSILVER_DRAGON;
-    case MONS_IRON_DRAGON:
-        return TILEP_MONS_IRON_DRAGON;
-    case MONS_SKELETAL_WARRIOR:
-        return TILEP_MONS_SKELETAL_WARRIOR;
-    case MONS_PLAYER_GHOST:
-        return TILEP_MONS_PLAYER_GHOST;
-    case MONS_PANDEMONIUM_DEMON:
-        return TILEP_MONS_PANDEMONIUM_DEMON;
-    case MONS_GIANT_NEWT:
-        return TILEP_MONS_GIANT_NEWT;
-    case MONS_GIANT_GECKO:
-        return TILEP_MONS_GIANT_GECKO;
-    case MONS_GIANT_IGUANA:
-        return TILEP_MONS_GIANT_IGUANA;
-    case MONS_GILA_MONSTER:
-        return TILEP_MONS_GILA_MONSTER;
-    case MONS_KOMODO_DRAGON:
-        return TILEP_MONS_KOMODO_DRAGON;
-    case MONS_LAVA_WORM:
-        return TILEP_MONS_LAVA_WORM;
-    case MONS_LAVA_FISH:
-        return TILEP_MONS_LAVA_FISH;
-    case MONS_LAVA_SNAKE:
-        return TILEP_MONS_LAVA_SNAKE;
-    case MONS_SALAMANDER:
-        return TILEP_MONS_SALAMANDER;
-    case MONS_BIG_FISH:
-        return TILEP_MONS_BIG_FISH;
-    case MONS_GIANT_GOLDFISH:
-        return TILEP_MONS_GIANT_GOLDFISH;
-    case MONS_ELECTRICAL_EEL:
-        return TILEP_MONS_ELECTRICAL_EEL;
-    case MONS_JELLYFISH:
-        return TILEP_MONS_JELLYFISH;
-    case MONS_WATER_ELEMENTAL:
-        return TILEP_MONS_WATER_ELEMENTAL;
-    case MONS_SWAMP_WORM:
-        return TILEP_MONS_SWAMP_WORM;
-    case MONS_ROCK_WORM:
-        return TILEP_MONS_ROCK_WORM;
-    case MONS_ORANGE_STATUE:
-        return TILEP_ORANGE_CRYSTAL_STATUE;
-    case MONS_SILVER_STATUE:
-        return TILEP_SILVER_STATUE;
-    case MONS_ICE_STATUE:
-        return TILEP_ICE_STATUE;
-    case MONS_DEATH_DRAKE:
-        return TILEP_MONS_DEATH_DRAKE;
-    case MONS_MERFOLK:
-        if (in_water)
-            return TILEP_MONS_MERFOLK_FIGHTER_WATER;
-        else
-            return TILEP_MONS_MERFOLK_FIGHTER;
-    case MONS_MERMAID:
-        if (in_water)
-            return TILEP_MONS_MERMAID_WATER;
-        else
-            return TILEP_MONS_MERMAID;
     }
 
     return TILE_ERROR;