Tiles mcache improvements. Monsters out of sight are now shown with their last seen equipment. Player ghosts are now drawn correctly again. Denzi's new 48x32 pandemonium demon tiles are now used.

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

28 files changed, 1536 insertions, 1088 deletions

diff --git a/crawl-ref/source/abyss.cc b/crawl-ref/source/abyss.cc
index bb8f286177..39377bddc8 100644
--- a/crawl-ref/source/abyss.cc
+++ b/crawl-ref/source/abyss.cc
@@ -839,12 +839,12 @@ static void _corrupt_square(const crawl_environment &oenv, const coord_def &c)
     if (feat == DNGN_ROCK_WALL)
     {
         env.tile_flv(c).wall = TILE_WALL_UNDEAD
-            + random2(tile_dngn_count[TILE_WALL_UNDEAD]);
+            + random2(tile_dngn_count(TILE_WALL_UNDEAD));
     }
     else if (feat == DNGN_FLOOR)
     {
         env.tile_flv(c).floor = TILE_FLOOR_NERVES
-            + random2(tile_dngn_count[TILE_FLOOR_NERVES]);
+            + random2(tile_dngn_count(TILE_FLOOR_NERVES));
     }
 #endif
 }
diff --git a/crawl-ref/source/enum.h b/crawl-ref/source/enum.h
index 96952719ca..9e252c7330 100644
--- a/crawl-ref/source/enum.h
+++ b/crawl-ref/source/enum.h
@@ -1802,6 +1802,7 @@ enum monster_type                      // (int) menv[].type
 // BCR - end second batch of uniques.
 
     MONS_DRACONIAN,
+    MONS_FIRST_DRACONIAN = MONS_DRACONIAN,
 
     // If adding more drac colours, sync up colour names in
     // mon-util.cc.
@@ -1823,6 +1824,8 @@ enum monster_type                      // (int) menv[].type
     MONS_DRACONIAN_KNIGHT,
     MONS_DRACONIAN_SCORCHER,
 
+    MONS_LAST_DRACONIAN = MONS_DRACONIAN_SCORCHER,
+
     MONS_MURRAY,
     MONS_TIAMAT,
 
diff --git a/crawl-ref/source/externs.h b/crawl-ref/source/externs.h
index 2fa78812ee..8626972a11 100644
--- a/crawl-ref/source/externs.h
+++ b/crawl-ref/source/externs.h
@@ -44,6 +44,20 @@ struct tile_flavour
     // Used as a random value or for special cases e.g. (bazaars, gates).
     unsigned char special;
 };
+
+// A glorified unsigned int that assists with ref-counting the mcache.
+class tile_fg_store
+{
+public:
+    tile_fg_store() : m_tile(0) {}
+    tile_fg_store(unsigned int tile) : m_tile(tile) {}
+    operator unsigned int() { return m_tile; }
+    unsigned int operator=(unsigned int tile);
+protected:
+    unsigned int m_tile;
+};
+
+
 #endif
 
 #define INFO_SIZE       200          // size of message buffers
@@ -1446,8 +1460,8 @@ public:
 
 #ifdef USE_TILE
     // indexed by grid coords
-    FixedArray<unsigned int,GXM, GYM> tile_bk_fg; // tile fg
-    FixedArray<unsigned int,GXM, GYM> tile_bk_bg; // tile bg
+    FixedArray<tile_fg_store, GXM, GYM> tile_bk_fg; // tile fg
+    FixedArray<unsigned int, GXM, GYM> tile_bk_bg; // tile bg
     FixedArray<tile_flavour, GXM, GYM> tile_flv;
     // indexed by (show-1) coords
     FixedArray<unsigned int,ENV_SHOW_DIAMETER-2,ENV_SHOW_DIAMETER-2> tile_fg;
diff --git a/crawl-ref/source/makefile_tiles.mgw b/crawl-ref/source/makefile_tiles.mgw
index 558cc58f22..dabf6cec74 100644
--- a/crawl-ref/source/makefile_tiles.mgw
+++ b/crawl-ref/source/makefile_tiles.mgw
@@ -48,7 +48,6 @@ PCRELIBA := lib$(PCRELIB).a
 RLTILES = rltiles
 EXTRA_INCLUDES += -I$(RLTILES)
 OBJECTS += \
-    $(RLTILES)/tiledef-demon.o \
     $(RLTILES)/tiledef-dngn.o \
     $(RLTILES)/tiledef-main.o \
     $(RLTILES)/tiledef-player.o
@@ -56,8 +55,7 @@ OBJECTS += \
 TILEFILES = \
     main.png \
     player.png \
-    dngn.png \
-    demon.png
+    dngn.png
 
 DESTTILEFILES = $(TILEFILES:%=dat/tiles/%)
 
@@ -78,7 +76,7 @@ CFOTHERS := -fsigned-char \
 CFLAGS   := $(INCLUDES) $(CFWARN) $(CFOTHERS) $(SDL_CFLAGS)
 YCFLAGS  := $(INCLUDES) $(CFOTHERS)
 
-OBJECTS := $(OBJECTS) libgui.o tilepick.o tile2.o tilereg.o tilesdl.o tilefont.o tiletex.o
+OBJECTS := $(OBJECTS) libgui.o tilepick.o tile2.o tilereg.o tilesdl.o tilefont.o tiletex.o tilemcache.o
 
 LDFLAGS =
 
diff --git a/crawl-ref/source/makefile_tiles.unix b/crawl-ref/source/makefile_tiles.unix
index dd379e0b95..bd3148a931 100644
--- a/crawl-ref/source/makefile_tiles.unix
+++ b/crawl-ref/source/makefile_tiles.unix
@@ -10,7 +10,7 @@ GAME = crawl
 # it will make a variable called OBJECTS that contains all the libraries
 include makefile.obj
 
-OBJECTS += libgui.o tilepick.o tile2.o tilereg.o tilesdl.o tilefont.o tiletex.o
+OBJECTS += libgui.o tilepick.o tile2.o tilereg.o tilesdl.o tilefont.o tiletex.o tilemcache.o
 
 SDL_CFLAGS := $(shell sdl-config --cflags)
 SDL_LDFLAGS := $(shell sdl-config --libs) -lSDLmain
@@ -104,12 +104,11 @@ endif
 RLTILES = rltiles
 
 EXTRA_INCLUDES += -I$(RLTILES)
-OBJECTS += $(RLTILES)/tiledef-demon.o $(RLTILES)/tiledef-dngn.o $(RLTILES)/tiledef-main.o $(RLTILES)/tiledef-player.o
+OBJECTS += $(RLTILES)/tiledef-dngn.o $(RLTILES)/tiledef-main.o $(RLTILES)/tiledef-player.o
 
 TILEFILES = \
 	main.png \
 	player.png \
-	demon.png \
     dngn.png
 DESTTILEFILES = $(TILEFILES:%=dat/tiles/%)
 
diff --git a/crawl-ref/source/mon-util.cc b/crawl-ref/source/mon-util.cc
index 024676cb51..703b9c343b 100644
--- a/crawl-ref/source/mon-util.cc
+++ b/crawl-ref/source/mon-util.cc
@@ -5001,9 +5001,6 @@ void monsters::slow_down(int strength)
 
 void monsters::set_ghost(const ghost_demon &g)
 {
-#ifdef USE_TILE
-    TileGhostInit(g);
-#endif
     ghost.reset( new ghost_demon(g) );
     mname = ghost->name;
 }
diff --git a/crawl-ref/source/rltiles/dc-demon.txt b/crawl-ref/source/rltiles/dc-demon.txt
index 8a3239277c..340860ac09 100644
--- a/crawl-ref/source/rltiles/dc-demon.txt
+++ b/crawl-ref/source/rltiles/dc-demon.txt
@@ -1,6 +1,3 @@
-%name demon
-%prefix TILE
-
 %rim 1
 %sdir dc-mon/demon
 
diff --git a/crawl-ref/source/rltiles/dc-dngn.txt b/crawl-ref/source/rltiles/dc-dngn.txt
index c3dcd4dc5e..053cbed0bd 100644
--- a/crawl-ref/source/rltiles/dc-dngn.txt
+++ b/crawl-ref/source/rltiles/dc-dngn.txt
@@ -344,7 +344,6 @@ gate_open_left DNGN_GATE_OPEN_LEFT
 gate_open_middle DNGN_GATE_OPEN_MIDDLE
 gate_open_right DNGN_GATE_OPEN_RIGHT
 dngn_orcish_idol DNGN_ORCISH_IDOL
-dngn_silver_statue DNGN_SILVER_STATUE
 dngn_granite_statue DNGN_GRANITE_STATUE
 
 %rim 1
diff --git a/crawl-ref/source/rltiles/dc-main.txt b/crawl-ref/source/rltiles/dc-main.txt
index 2b41b50195..71038a0656 100644
--- a/crawl-ref/source/rltiles/dc-main.txt
+++ b/crawl-ref/source/rltiles/dc-main.txt
@@ -7,8 +7,6 @@ dc-dngn/dngn_unseen
 ## Set black rim

 ## Items

 %include dc-item.txt

-## Monsters

-%include dc-mon.txt

 ## Clear black rim

 %rim 0

 

diff --git a/crawl-ref/source/rltiles/dc-misc.txt b/crawl-ref/source/rltiles/dc-misc.txt
index 0972fdc71e..1b28fad328 100644
--- a/crawl-ref/source/rltiles/dc-misc.txt
+++ b/crawl-ref/source/rltiles/dc-misc.txt
@@ -57,7 +57,6 @@ poison POISON
 %rim 0

 may_stab_brand MAY_STAB_BRAND

 stab_brand STAB_BRAND

-unseen PLAYER

 out_of_sight MESH

 magicmap MAGIC_MAP_MESH

 something_under SOMETHING_UNDER

@@ -85,6 +84,3 @@ slot_eq ITEM_SLOT_EQUIP
 slot_cursed ITEM_SLOT_CURSED

 slot_eq_cursed ITEM_SLOT_EQUIP_CURSED

 ray ITEM_SLOT_SELECTED

-

-%back unseen

-dc-misc/unseen_monster MCACHE_START

diff --git a/crawl-ref/source/rltiles/dc-mon.txt b/crawl-ref/source/rltiles/dc-mon.txt
index 36ddecb904..4cbdc25071 100644
--- a/crawl-ref/source/rltiles/dc-mon.txt
+++ b/crawl-ref/source/rltiles/dc-mon.txt
@@ -453,6 +453,11 @@ mermaid_water MONS_MERMAID_WATER
 rock_worm MONS_ROCK_WORM

 

 %sdir dc-dngn

-dngn_orange_crystal_statue DNGN_ORANGE_CRYSTAL_STATUE

-dngn_ice_statue DNGN_ICE_STATUE

+dngn_orange_crystal_statue ORANGE_CRYSTAL_STATUE

+dngn_ice_statue ICE_STATUE

+dngn_silver_statue SILVER_STATUE

 %sdir dc-mon

+

+dc-misc/unseen PLAYER

+dc-misc/unseen_monster MONS_UNKNOWN

+dc-misc/unseen_monster MCACHE_START

diff --git a/crawl-ref/source/rltiles/dc-player.txt b/crawl-ref/source/rltiles/dc-player.txt
index 44d285e423..c6a60c56fb 100644
--- a/crawl-ref/source/rltiles/dc-player.txt
+++ b/crawl-ref/source/rltiles/dc-player.txt
@@ -1,6 +1,10 @@
 %name player

+%startvalue TILE_MAIN_MAX tiledef-main.h

 %prefix TILEP

 

+%include dc-demon.txt

+%include dc-mon.txt

+

 %rim 1

 

 ###BASE

@@ -845,3 +849,4 @@ drchead_purple PURPLE
 drchead_red RED

 drchead_white WHITE

 %end

+

diff --git a/crawl-ref/source/rltiles/makefile.mgw b/crawl-ref/source/rltiles/makefile.mgw
index 2707002797..edeeb30a56 100644
--- a/crawl-ref/source/rltiles/makefile.mgw
+++ b/crawl-ref/source/rltiles/makefile.mgw
@@ -20,7 +20,7 @@ DELETE = del /q
 TOOLDIR := tool
 TILEGEN := $(TOOLDIR)\\tilegen.elf
 
-INPUTS := main dngn player demon
+INPUTS := main dngn player
 INPUTFILES := $(INPUTS:%=dc-%.txt)
 HEADERS := $(INPUTS:%=tiledef-%.h)
 SOURCE := $(INPUTS:%=tiledef-%.cc)
diff --git a/crawl-ref/source/rltiles/makefile.unix b/crawl-ref/source/rltiles/makefile.unix
index b7096a7bd7..f64bfe42d9 100644
--- a/crawl-ref/source/rltiles/makefile.unix
+++ b/crawl-ref/source/rltiles/makefile.unix
@@ -19,7 +19,7 @@ DELETE = rm -f
 TOOLDIR := tool
 TILEGEN := $(TOOLDIR)/tilegen.elf
 
-INPUTS := main dngn player demon
+INPUTS := main dngn player
 INPUTFILES := $(INPUTS:%=dc-%.txt)
 HEADERS := $(INPUTS:%=tiledef-%.h)
 SOURCE := $(INPUTS:%=tiledef-%.cc)
diff --git a/crawl-ref/source/rltiles/tiledef_defines.h b/crawl-ref/source/rltiles/tiledef_defines.h
index 9882db3053..882cf03830 100644
--- a/crawl-ref/source/rltiles/tiledef_defines.h
+++ b/crawl-ref/source/rltiles/tiledef_defines.h
@@ -43,4 +43,8 @@ public:
     unsigned short ey;
 };
 
+typedef unsigned int (tile_count_func)(unsigned int);
+typedef const char *(tile_name_func)(unsigned int);
+typedef tile_info &(tile_info_func)(unsigned int);
+
 #endif
diff --git a/crawl-ref/source/rltiles/tool/tile_list_processor.cc b/crawl-ref/source/rltiles/tool/tile_list_processor.cc
index e1cf1191ad..80d17bcc11 100644
--- a/crawl-ref/source/rltiles/tool/tile_list_processor.cc
+++ b/crawl-ref/source/rltiles/tool/tile_list_processor.cc
@@ -10,7 +10,8 @@ tile_list_processor::tile_list_processor() :
     m_corpsify(false),
     m_composing(false),
     m_shrink(true),
-    m_prefix("TILE")
+    m_prefix("TILE"),
+    m_start_value("0")
 {
 }
 
@@ -192,8 +193,8 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
                 return false; \
             }
 
-        #define CHECK_ARG1 \
-            if (m_args.size() <= 1) \
+        #define CHECK_ARG(x) \
+            if (m_args.size() <= x) \
             { \
                 fprintf(stderr, "Error (%s:%d): " \
                     "missing arg following '%s'.\n", \
@@ -203,7 +204,7 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
 
         if (strcmp(arg, "back") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
 
             for (unsigned int i = 0; i < m_back.size(); i++)
             {
@@ -231,7 +232,7 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
         }
         else if (strcmp(arg, "compose") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             if (!m_composing)
             {
                 fprintf(stderr, "Error (%s:%d): not composing yet.\n",
@@ -271,7 +272,7 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
         }
         else if (strcmp(arg, "corpse") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             m_corpsify = (bool)atoi(m_args[1]);
         }
         else if (strcmp(arg, "end") == 0)
@@ -325,7 +326,7 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
         }
         else if (strcmp(arg, "include") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             if (!process_list(m_args[1]))
             {
                 fprintf(stderr, "Error (%s:%d): include failed.\n",
@@ -335,7 +336,7 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
         }
         else if (strcmp(arg, "name") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
 
             if (m_name != "")
             {
@@ -349,7 +350,7 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
         }
         else if (strcmp(arg, "parts_ctg") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
 
             for (unsigned int i = 0; i < m_categories.size(); i++)
             {
@@ -368,22 +369,22 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
         }
         else if (strcmp(arg, "prefix") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             m_prefix = m_args[1];
         }
         else if (strcmp(arg, "rim") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             m_rim = (bool)atoi(m_args[1]);
         }
         else if (strcmp(arg, "sdir") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             m_sdir = m_args[1];
         }
         else if (strcmp(arg, "shrink") == 0)
         {
-            CHECK_ARG1;
+            CHECK_ARG(1);
             m_shrink = (bool)atoi(m_args[1]);
         }
         else if (strcmp(arg, "start") == 0)
@@ -399,6 +400,14 @@ bool tile_list_processor::process_line(char *read_line, const char *list_file,
             m_composing = true;
             m_compose.unload();
         }
+        else if (strcmp(arg, "startvalue") == 0)
+        {
+            CHECK_ARG(2);
+            CHECK_NO_ARG(3);
+
+            m_start_value = m_args[1];
+            m_include = m_args[2];
+        }
         else
         {
             fprintf(stderr, "Error (%s:%d): unknown command '%%%s'\n",
@@ -542,28 +551,38 @@ bool tile_list_processor::write_data()
             ucname.c_str(), ucname.c_str());
         fprintf(fp, "#include \"tiledef_defines.h\"\n\n");
 
+        if (!m_include.empty())
+        {
+            fprintf(fp, "#include \"%s\"\n\n", m_include.c_str());
+        }
+
         fprintf(fp, "enum tile_%s_type\n{\n", lcname.c_str());
 
+        std::string start_val = " = ";
+        start_val += m_start_value;
+
         for (unsigned int i = 0; i < m_page.m_tiles.size(); i++)
         {
             const std::string &enumname = m_page.m_tiles[i]->enumname();
             const std::string &parts_ctg = m_page.m_tiles[i]->parts_ctg();
             if (enumname.empty())
             {
-                fprintf(fp, "    %s_%s_FILLER_%d,\n", m_prefix.c_str(), 
-                    ucname.c_str(), i);
+                fprintf(fp, "    %s_%s_FILLER_%d%s,\n", m_prefix.c_str(), 
+                    ucname.c_str(), i, start_val.c_str());
             }
             else if (parts_ctg.empty())
             {
-                fprintf(fp, "    %s_%s,\n", m_prefix.c_str(),
-                    enumname.c_str());
+                fprintf(fp, "    %s_%s%s,\n", m_prefix.c_str(),
+                    enumname.c_str(), start_val.c_str());
             }
             else
             {
-                fprintf(fp, "    %s_%s_%s,\n", m_prefix.c_str(),
-                    parts_ctg.c_str(), enumname.c_str());
+                fprintf(fp, "    %s_%s_%s%s,\n", m_prefix.c_str(),
+                    parts_ctg.c_str(), enumname.c_str(), start_val.c_str());
             }
 
+            start_val = "";
+
             if (!parts_ctg.empty())
             {
                 int idx;
@@ -580,12 +599,11 @@ bool tile_list_processor::write_data()
 
         fprintf(fp, "    %s_%s_MAX\n};\n\n", m_prefix.c_str(), ucname.c_str());
 
-        fprintf(fp, "extern int tile_%s_count[%s];\n",
-            lcname.c_str(), max.c_str());
-        fprintf(fp, "extern const char *tile_%s_name[%s];\n",
-            lcname.c_str(), max.c_str());
-        fprintf(fp, "extern tile_info tile_%s_info[%s];\n",
-            lcname.c_str(), max.c_str());
+        fprintf(fp, "int tile_%s_count(unsigned int idx);\n", lcname.c_str());
+        fprintf(fp, "const char *tile_%s_name(unsigned int idx);\n",
+            lcname.c_str());
+        fprintf(fp, "tile_info &tile_%s_info(unsigned int idx);\n",
+            lcname.c_str());
 
         if (m_categories.size() > 0)
         {
@@ -624,14 +642,21 @@ bool tile_list_processor::write_data()
         fprintf(fp, "// This file has been automatically generated.\n\n");
         fprintf(fp, "#include \"tiledef-%s.h\"\n\n", lcname.c_str());
 
-        fprintf(fp, "int tile_%s_count[%s] =\n{\n",
-            lcname.c_str(), max.c_str());
+        fprintf(fp, "int _tile_%s_count[%s - %s] =\n{\n",
+            lcname.c_str(), max.c_str(), m_start_value.c_str());
         for (unsigned int i = 0; i < m_page.m_counts.size(); i++)
             fprintf(fp, "    %d,\n", m_page.m_counts[i]);
         fprintf(fp, "};\n\n");
 
-        fprintf(fp, "const char *tile_%s_name[%s] =\n{\n",
-            lcname.c_str(), max.c_str());
+        fprintf(fp, "int tile_%s_count(unsigned int idx)\n{\n", lcname.c_str());
+        fprintf(fp, "    assert(idx >= %s && idx < %s);\n",
+            m_start_value.c_str(), max.c_str());
+        fprintf(fp, "    return _tile_%s_count[idx - %s];\n",
+            lcname.c_str(), m_start_value.c_str());
+        fprintf(fp, "}\n\n");
+
+        fprintf(fp, "const char *_tile_%s_name[%s - %s] =\n{\n",
+            lcname.c_str(), max.c_str(), m_start_value.c_str());
         for (unsigned int i = 0; i < m_page.m_tiles.size(); i++)
         {
             const std::string &enumname = m_page.m_tiles[i]->enumname();
@@ -642,8 +667,16 @@ bool tile_list_processor::write_data()
         }
         fprintf(fp, "};\n\n");
 
-        fprintf(fp, "tile_info tile_%s_info[%s] =\n{\n",
-            lcname.c_str(), max.c_str());
+        fprintf(fp, "const char *tile_%s_name(unsigned int idx)\n{\n",
+            lcname.c_str());
+        fprintf(fp, "    assert(idx >= %s && idx < %s);\n",
+            m_start_value.c_str(), max.c_str());
+        fprintf(fp, "    return _tile_%s_name[idx - %s];\n",
+            lcname.c_str(), m_start_value.c_str());
+        fprintf(fp, "}\n\n");
+
+        fprintf(fp, "tile_info _tile_%s_info[%s - %s] =\n{\n",
+            lcname.c_str(), max.c_str(), m_start_value.c_str());
         for (unsigned int i = 0; i < m_page.m_offsets.size(); i+=4)
         {
             fprintf(fp, "    tile_info(%d, %d, %d, %d, %d, %d, %d, %d),\n",
@@ -654,6 +687,14 @@ bool tile_list_processor::write_data()
         }
         fprintf(fp, "};\n\n");
 
+        fprintf(fp, "tile_info &tile_%s_info(unsigned int idx)\n{\n",
+            lcname.c_str());
+        fprintf(fp, "    assert(idx >= %s && idx < %s);\n",
+            m_start_value.c_str(), max.c_str());
+        fprintf(fp, "    return _tile_%s_info[idx - %s];\n",
+            lcname.c_str(), m_start_value.c_str());
+        fprintf(fp, "}\n\n");
+
         if (m_categories.size() > 0)
         {
             fprintf(fp, "int tile_%s_part_count[%s] =\n{\n",
@@ -671,7 +712,7 @@ bool tile_list_processor::write_data()
 
             for (int i = 0; i < m_categories.size(); i++)
             {
-                fprintf(fp, "    %d,\n", part_min[i]);
+                fprintf(fp, "    %d+%s,\n", part_min[i], m_start_value.c_str());
             }
 
             fprintf(fp, "};\n\n");
diff --git a/crawl-ref/source/rltiles/tool/tile_list_processor.h b/crawl-ref/source/rltiles/tool/tile_list_processor.h
index 0c718a8044..74b199b5ef 100644
--- a/crawl-ref/source/rltiles/tool/tile_list_processor.h
+++ b/crawl-ref/source/rltiles/tool/tile_list_processor.h
@@ -33,6 +33,8 @@ protected:
     std::string m_parts_ctg;
     std::string m_sdir;
     std::string m_prefix;
+    std::string m_start_value;
+    std::string m_include;
     std::vector<std::string> m_categories;
     std::vector<int> m_ctg_counts;
     tile m_compose;
diff --git a/crawl-ref/source/tags.cc b/crawl-ref/source/tags.cc
index 3c9ca7606f..d9991d58e9 100644
--- a/crawl-ref/source/tags.cc
+++ b/crawl-ref/source/tags.cc
@@ -87,6 +87,7 @@
 #include "stuff.h"
 #include "tags.h"
 #include "tiles.h"
+#include "tilemcache.h"
 #include "travel.h"
 
 // defined in overmap.cc
@@ -1856,7 +1857,7 @@ void tag_construct_level_tiles(writer &th)
     unsigned int last_tile = 0;
 
     // tile routine subversion
-    marshallShort(th, 71);
+    marshallShort(th, TILETAG_CURRENT);
 
     // Map grids.
     // how many X?
@@ -1935,6 +1936,8 @@ void tag_construct_level_tiles(writer &th)
             marshallByte(th, env.tile_flv[count_x][count_y].special);
         }
 
+    mcache.construct(th);
+
 #endif
 }
 
@@ -2251,6 +2254,11 @@ void tag_read_level_tiles(struct reader &th)
             env.tile_flv[x][y].special = unmarshallByte(th);
         }
 
+    if (ver > TILETAG_PRE_MCACHE)
+        mcache.read(th);
+    else
+        mcache.clear_all();
+
 #endif
 }
 
@@ -2267,6 +2275,7 @@ static void tag_missing_level_tiles()
             env.tile_bk_fg[i][j] = 0;
         }
 
+    mcache.clear_all();
 #endif
 }
 
diff --git a/crawl-ref/source/tile2.cc b/crawl-ref/source/tile2.cc
index 3de5276d92..3e6b3bed3f 100644
--- a/crawl-ref/source/tile2.cc
+++ b/crawl-ref/source/tile2.cc
@@ -365,12 +365,12 @@ void TileLoadWall(bool wizard)
     WallIdx(wall_tile_idx, floor_tile_idx, special_tile_idx);
 
     // Number of flavors are generated automatically...
-    floor_flavors  = tile_dngn_count[floor_tile_idx];
-    wall_flavors  = tile_dngn_count[wall_tile_idx];
+    floor_flavors  = tile_dngn_count(floor_tile_idx);
+    wall_flavors  = tile_dngn_count(wall_tile_idx);
 
     if (special_tile_idx != -1)
     {
-        special_flavors = tile_dngn_count[special_tile_idx];
+        special_flavors = tile_dngn_count(special_tile_idx);
     }
     else
     {
@@ -384,6 +384,7 @@ void TileLoadWall(bool wizard)
 #define TILEP_SELECT_DOLL 20
 
 static dolls_data current_doll;
+#if 0
 static int current_gender = 0;
 
 static void _load_doll_data(const char *fn, dolls_data *dolls, int max,
@@ -468,6 +469,7 @@ static void _load_doll_data(const char *fn, dolls_data *dolls, int max,
 
     current_gender = dolls[cur0].parts[TILEP_PART_BASE] % 2;
 }
+#endif
 
 void TilePlayerEdit()
 {
@@ -670,8 +672,8 @@ void TilePlayerEdit()
         ImgCopy(DollCacheImg, 0, 0, TILE_X, TILE_Y,
                 DollsListImg, cur_doll*TILE_X, 0, 1);
 
-        _ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
-        _ImgCopyFromTileImg(TILE_PLAYER, ScrBufImg, 8*TILE_X, 8*TILE_Y, 0);
+        _ImgCopyToTileImg(TILEP_PLAYER, DollCacheImg, 0, 0, 1);
+        _ImgCopyFromTileImg(TILEP_PLAYER, ScrBufImg, 8*TILE_X, 8*TILE_Y, 0);
         ImgCopy(DollsListImg, 0, 0,
                 ImgWidth(DollsListImg), ImgHeight(DollsListImg),
                 ScrBufImg, 3 * TILE_X, PARTS_Y, 0);
@@ -909,7 +911,7 @@ void TilePlayerEdit()
 
     current_doll = dolls[cur_doll];
     _draw_doll(DollCacheImg, &current_doll);
-    _ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
+    _ImgCopyToTileImg(TILEP_PLAYER, DollCacheImg, 0, 0, 1);
 
     std::string dollsTxtString = datafile_path("dolls.txt", false, true);
     const char *dollsTxt = (dollsTxtString.c_str()[0] == 0) ?
@@ -932,7 +934,7 @@ void TilePlayerEdit()
     ImgDestroy(DollsListImg);
 
     ImgClear(ScrBufImg);
-    _redraw_spx_tcache(TILE_PLAYER);
+    _redraw_spx_tcache(TILEP_PLAYER);
 
     for (x = 0; x < TILE_DAT_XMAX + 2; x++)
     {
@@ -953,272 +955,13 @@ void TilePlayerEdit()
 #endif
 }
 
-void TileGhostInit(const struct ghost_demon &ghost)
-{
-#if 0
-    dolls_data doll;
-    int x, y;
-    unsigned int pseudo_rand = ghost.max_hp * 54321 * 54321;
-    char mask[TILE_X*TILE_Y];
-    int g_gender = (pseudo_rand >> 8) & 1;
-
-    for (x = 0; x < TILE_X; x++)
-    for (y = 0; y < TILE_X; y++)
-         mask[x + y*TILE_X] = (x+y)&1;
-
-    for (x = 0; x < TILEP_PART_MAX; x++)
-    {
-         doll.parts[x] = 0;
-         current_parts[x] = 0;
-    }
-    tilep_race_default(ghost.species, g_gender,
-                       ghost.xl, doll.parts);
-    tilep_job_default (ghost.job, g_gender,  doll.parts);
-
-    for (x = TILEP_PART_CLOAK; x < TILEP_PART_MAX; x++)
-    {
-         if (doll.parts[x] == TILEP_SHOW_EQUIP)
-         {
-             doll.parts[x] = 1 + (pseudo_rand % tilep_parts_total[x]);
-
-             if (x == TILEP_PART_BODY)
-             {
-                 int p = 0;
-                 int ac = ghost.ac;
-                 ac *= (5 + (pseudo_rand/11) % 11);
-                 ac /= 10;
-
-                 if (ac > 25)
-                     p = TILEP_BODY_PLATE_BLACK;
-                 else if (ac > 20)
-                     p =  TILEP_BODY_BANDED;
-                 else if (ac > 15)
-                     p = TILEP_BODY_SCALEMAIL;
-                 else if (ac > 10)
-                     p = TILEP_BODY_CHAINMAIL;
-                 else if (ac > 5 )
-                     p = TILEP_BODY_LEATHER_HEAVY;
-                 else
-                     p = TILEP_BODY_ROBE_BLUE;
-                doll.parts[x] = p;
-            }
-        }
-    }
-
-    int sk = ghost.best_skill;
-    int dam = ghost.damage;
-    int p = 0;
-
-    dam *= (5 + pseudo_rand % 11);
-    dam /= 10;
-
-    switch (sk)
-    {
-    case SK_MACES_FLAILS:
-        if (dam > 30)
-            p = TILEP_HAND1_GREAT_FRAIL;
-        else if (dam > 25)
-            p = TILEP_HAND1_GREAT_MACE;
-        else if (dam > 20)
-            p = TILEP_HAND1_SPIKED_FRAIL;
-        else if (dam > 15)
-            p = TILEP_HAND1_MORNINGSTAR;
-        else if (dam > 10)
-            p = TILEP_HAND1_FRAIL;
-        else if (dam > 5)
-            p = TILEP_HAND1_MACE;
-        else
-            p = TILEP_HAND1_CLUB_SLANT;
-
-        doll.parts[TILEP_PART_HAND1] = p;
-        break;
-
-    case SK_SHORT_BLADES:
-        if (dam > 20)
-            p = TILEP_HAND1_SABRE;
-        else if (dam > 10)
-            p = TILEP_HAND1_SHORT_SWORD_SLANT;
-        else
-            p = TILEP_HAND1_DAGGER_SLANT;
-
-        doll.parts[TILEP_PART_HAND1] = p;
-        break;
-
-    case SK_LONG_BLADES:
-        if (dam > 25)
-            p = TILEP_HAND1_GREAT_SWORD_SLANT;
-        else if (dam > 20)
-            p = TILEP_HAND1_KATANA_SLANT;
-        else if (dam > 15)
-            p = TILEP_HAND1_SCIMITAR;
-        else if (dam > 10)
-            p = TILEP_HAND1_LONG_SWORD_SLANT;
-        else
-            p = TILEP_HAND1_FALCHION;
-
-        doll.parts[TILEP_PART_HAND1] = p;
-        break;
-
-    case SK_AXES:
-        if (dam > 30)
-            p = TILEP_HAND1_EXECUTIONERS_AXE;
-        else if (dam > 20)
-            p = TILEP_HAND1_BATTLEAXE;
-        else if (dam > 15)
-            p = TILEP_HAND1_BROAD_AXE;
-        else if (dam > 10)
-            p = TILEP_HAND1_WAR_AXE;
-        else
-            p = TILEP_HAND1_HAND_AXE;
-
-        doll.parts[TILEP_PART_HAND1] = p;
-        break;
-
-    case SK_POLEARMS:
-        if (dam > 30)
-            p =  TILEP_HAND1_GLAIVE;
-        else if (dam > 20)
-            p = TILEP_HAND1_SCYTHE;
-        else if (dam > 15)
-            p = TILEP_HAND1_HALBERD;
-        else if (dam > 10)
-            p = TILEP_HAND1_TRIDENT2;
-        else if (dam > 10)
-            p = TILEP_HAND1_HAMMER;
-        else
-            p = TILEP_HAND1_SPEAR;
-
-        doll.parts[TILEP_PART_HAND1] = p;
-        break;
-
-    case SK_BOWS:
-        doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_BOW2;
-        break;
-
-    case SK_CROSSBOWS:
-        doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_CROSSBOW;
-        break;
-
-    case SK_SLINGS:
-        doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SLING;
-        break;
-
-    case SK_UNARMED_COMBAT:
-    default:
-        doll.parts[TILEP_PART_HAND1] = doll.parts[TILEP_PART_HAND2] = 0;
-        break;
-    }
-
-    ImgClear(DollCacheImg);
-    // Clear
-    _ImgCopyToTileImg(TILE_MONS_PLAYER_GHOST, DollCacheImg, 0, 0, 1);
-
-    _draw_doll(DollCacheImg, &doll);
-    _ImgCopyToTileImg(TILE_MONS_PLAYER_GHOST, DollCacheImg, 0, 0, 1, mask, false);
-    _redraw_spx_tcache(TILE_MONS_PLAYER_GHOST);
-#endif
-}
-
-void tile_get_monster_weapon_offset(int mon_tile, int &ofs_x, int &ofs_y)
-{
-    ofs_x = 0;
-    ofs_y = 0;
-
-    switch (mon_tile)
-    {
-        case TILE_MONS_ORC:
-        case TILE_MONS_URUG:
-        case TILE_MONS_BLORK_THE_ORC:
-        case TILE_MONS_ORC_WARRIOR:
-        case TILE_MONS_ORC_KNIGHT:
-        case TILE_MONS_ORC_WARLORD:
-            ofs_y = 2;
-            break;
-        case TILE_MONS_GOBLIN:
-        case TILE_MONS_IJYB:
-            ofs_y = 4;
-            break;
-        case TILE_MONS_GNOLL:
-            ofs_x = -1;
-            break;
-        case TILE_MONS_BOGGART:
-            ofs_y = 2;
-            break;
-        case TILE_MONS_DEEP_ELF_FIGHTER:
-        case TILE_MONS_DEEP_ELF_SOLDIER:
-            ofs_y = 2;
-            break;
-        case TILE_MONS_DEEP_ELF_KNIGHT:
-            ofs_y = 1;
-            break;
-        case TILE_MONS_KOBOLD:
-            ofs_x = 3;
-            ofs_y = 4;
-            break;
-        case TILE_MONS_KOBOLD_DEMONOLOGIST:
-            ofs_y = -10;
-            break;
-        case TILE_MONS_BIG_KOBOLD:
-            ofs_x = 2;
-            ofs_y = 3;
-            break;
-        case TILE_MONS_MIDGE:
-            ofs_y = -2;
-            break;
-        case TILE_MONS_NAGA:
-        case TILE_MONS_GREATER_NAGA:
-        case TILE_MONS_NAGA_WARRIOR:
-        case TILE_MONS_GUARDIAN_NAGA:
-        case TILE_MONS_NAGA_MAGE:
-            ofs_y = 1;
-            break;
-        case TILE_MONS_HELL_KNIGHT:
-            ofs_x = -1;
-            ofs_y = 3;
-            break;
-        case TILE_MONS_RED_DEVIL:
-            ofs_x = 2;
-            ofs_y = -3;
-            break;
-        case TILE_MONS_WIZARD:
-            ofs_x = 2;
-            ofs_y = -2;
-            break;
-        case TILE_MONS_HUMAN:
-            ofs_x = 5;
-            ofs_y = 2;
-            break;
-        case TILE_MONS_ELF:
-            ofs_y = 1;
-            ofs_x = 4;
-            break;
-        case TILE_MONS_OGRE_MAGE:
-            ofs_y = -2;
-            ofs_x = -4;
-            break;
-        case TILE_MONS_DEEP_ELF_MAGE:
-        case TILE_MONS_DEEP_ELF_SUMMONER:
-        case TILE_MONS_DEEP_ELF_CONJURER:
-        case TILE_MONS_DEEP_ELF_PRIEST:
-        case TILE_MONS_DEEP_ELF_HIGH_PRIEST:
-        case TILE_MONS_DEEP_ELF_DEMONOLOGIST:
-        case TILE_MONS_DEEP_ELF_ANNIHILATOR:
-        case TILE_MONS_DEEP_ELF_SORCERER:
-            ofs_x = -1;
-            ofs_y = -2;
-            break;
-        case TILE_MONS_DEEP_ELF_DEATH_MAGE:
-            ofs_x = -1;
-            break;
-    }
-}
-
 int get_clean_map_idx(int tile_idx)
 {
+    // TODO enne - need to separate TILEP from non-TILEP...
     int idx = tile_idx & TILE_FLAG_MASK;
     if (idx >= TILE_CLOUD_FIRE_0 && idx <= TILE_CLOUD_PURP_SMOKE ||
-        idx >= TILE_MONS_SHADOW && idx <= TILE_MONS_WATER_ELEMENTAL ||
-        idx >= TILE_MCACHE_START)
+        idx >= TILEP_MONS_SHADOW && idx <= TILEP_MONS_WATER_ELEMENTAL ||
+        idx >= TILEP_MCACHE_START)
     {
         return 0;
     }
diff --git a/crawl-ref/source/tilemcache.cc b/crawl-ref/source/tilemcache.cc
new file mode 100644
index 0000000000..046e4ed08f
--- /dev/null
+++ b/crawl-ref/source/tilemcache.cc
@@ -0,0 +1,856 @@
+#include "tilemcache.h"
+#include "tags.h"
+#include "ghost.h"
+#include "mon-util.h"
+
+mcache_manager mcache;
+
+// Used internally for streaming
+enum mcache_type
+{
+    MCACHE_MONSTER,
+    MCACHE_DRACO,
+    MCACHE_GHOST,
+    MCACHE_DEMON,
+    MCACHE_MAX,
+
+    MCACHE_NULL
+};
+
+// Custom marshall/unmarshall functions.
+static void unmarshallDoll(reader &th, dolls_data &doll)
+{
+    for (unsigned int i = 0; i < TILEP_PART_MAX; i++)
+    {
+        doll.parts[i] = unmarshallLong(th);
+    }
+}
+
+static void marshallDoll(writer &th, const dolls_data &doll)
+{
+    for (unsigned int i = 0; i < TILEP_PART_MAX; i++)
+    {
+        marshallLong(th, doll.parts[i]);
+    }
+}
+
+static void unmarshallDemon(reader &th, demon_data &demon)
+{
+    demon.head = unmarshallLong(th);
+    demon.body = unmarshallLong(th);
+    demon.wings = unmarshallLong(th);
+}
+
+static void marshallDemon(writer &th, const demon_data &demon)
+{
+    marshallLong(th, demon.head);
+    marshallLong(th, demon.body);
+    marshallLong(th, demon.wings);
+}
+
+// Internal mcache classes.  The mcache_manager creates these internally.
+// The only access external clients need is through the virtual 
+// info function.
+
+class mcache_monster : public mcache_entry
+{
+public:
+    mcache_monster(const monsters *mon);
+    mcache_monster(reader &th);
+
+    virtual unsigned int info(tile_draw_info *dinfo) const;
+
+    static bool valid(const monsters *mon);
+
+    static bool get_weapon_offset(int mon_tile, int &ofs_x, int &ofs_y);
+
+    virtual void construct(writer &th);
+
+protected:
+    int m_mon_tile;
+    int m_equ_tile;
+};
+
+class mcache_draco : public mcache_entry
+{
+public:
+    mcache_draco(const monsters *mon);
+    mcache_draco(reader &th);
+
+    virtual const dolls_data *doll() const;
+
+    static bool valid(const monsters *mon);
+
+    virtual void construct(writer &th);
+
+protected:
+    dolls_data m_doll;
+};
+
+class mcache_ghost : public mcache_entry
+{
+public:
+    mcache_ghost(const monsters *mon);
+    mcache_ghost(reader &th);
+
+    virtual const dolls_data *doll() const;
+
+    static bool valid(const monsters *mon);
+
+    virtual void construct(writer &th);
+
+protected:
+    dolls_data m_doll;
+};
+
+class mcache_demon : public mcache_entry
+{
+public:
+    mcache_demon(const monsters *mon);
+    mcache_demon(reader &th);
+
+    virtual unsigned int info(tile_draw_info *dinfo) const;
+
+    static bool valid(const monsters *mon);
+
+    virtual void construct(writer &th);
+
+protected:
+    demon_data m_demon;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// tile_fg_store
+
+unsigned int tile_fg_store::operator=(unsigned int tile)
+{
+    if (tile & TILE_FLAG_MASK == m_tile & TILE_FLAG_MASK)
+    {
+        // update, as flags may have changed.
+        m_tile = tile;
+        return m_tile;
+    }
+
+    mcache_entry *old_entry = mcache.get(m_tile);
+    if (old_entry)
+        old_entry->dec_ref();
+
+    m_tile = tile;
+
+    mcache_entry *new_entry = mcache.get(m_tile);
+    if (new_entry)
+        new_entry->inc_ref();
+
+    return m_tile;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+// mcache_manager
+
+mcache_manager::~mcache_manager()
+{
+    clear_all();
+}
+
+unsigned int mcache_manager::register_monster(const monsters *mon)
+{
+    assert(mon);
+    if (!mon)
+        return 0;
+
+    // TODO enne - is it worth it to search against all mcache entries?
+    // TODO enne - pool mcache types to avoid too much alloc/dealloc?
+
+    mcache_entry *entry;
+
+    if (mcache_demon::valid(mon))
+    {
+        entry = new mcache_demon(mon);        
+    }
+    else if (mcache_ghost::valid(mon))
+    {
+        entry = new mcache_ghost(mon);        
+    }
+    else if (mcache_draco::valid(mon))
+    {
+        entry = new mcache_draco(mon);        
+    }
+    else if (mcache_monster::valid(mon))
+    {
+        entry = new mcache_monster(mon);        
+    }
+    else
+    {
+        return 0;
+    }
+
+    unsigned int idx = ~0;
+
+    for (unsigned int i = 0; i < m_entries.size(); i++)
+    {
+        if (!m_entries[i])
+        {
+            m_entries[i] = entry;
+            idx = i;
+            break;
+        }
+    }
+
+    if (idx > m_entries.size())
+    {
+        idx = m_entries.size();
+        m_entries.push_back(entry);
+    }
+
+    return TILEP_MCACHE_START + idx;
+}
+
+void mcache_manager::clear_nonref()
+{
+    for (unsigned int i = 0; i < m_entries.size(); i++)
+    {
+        if (!m_entries[i] || m_entries[i]->ref_count() > 0)
+            continue;
+        
+        delete m_entries[i];
+        m_entries[i] = NULL;
+    }
+}
+
+void mcache_manager::clear_all()
+{
+    for (unsigned int i = 0; i < m_entries.size(); i++)
+    {
+        delete m_entries[i];
+    }
+    m_entries.resize(0);
+}
+
+mcache_entry *mcache_manager::get(unsigned int tile)
+{
+    unsigned int idx = tile & TILE_FLAG_MASK;
+    if (idx < TILEP_MCACHE_START)
+        return NULL;
+
+    if (idx >= TILEP_MCACHE_START + m_entries.size())
+        return NULL;
+
+    mcache_entry *entry = m_entries[idx - TILEP_MCACHE_START];
+    return (entry);
+}
+
+void mcache_manager::read(reader &th)
+{
+    unsigned int size = unmarshallLong(th);
+    m_entries.reserve(size);
+    m_entries.clear();
+    
+    for (unsigned int i = 0; i < size; i++)
+    {
+        char type = unmarshallByte(th);
+
+        mcache_entry *entry;
+        switch (type)
+        {
+        case MCACHE_MONSTER:
+            entry = new mcache_monster(th);
+            break;
+        case MCACHE_DRACO:
+            entry = new mcache_draco(th);
+            break;
+        case MCACHE_GHOST:
+            entry = new mcache_ghost(th);
+            break;
+        case MCACHE_DEMON:
+            entry = new mcache_demon(th);
+            break;
+        default:
+            ASSERT(!"Invalid streamed mcache type.");
+        case MCACHE_NULL:
+            entry = NULL;
+            break;
+        }
+
+        m_entries.push_back(entry);
+    }
+}
+
+void mcache_manager::construct(writer &th)
+{
+    marshallLong(th, m_entries.size());
+    for (unsigned int i = 0; i < m_entries.size(); i++)
+    {
+        if (m_entries[i] == NULL)
+        {
+            marshallByte(th, MCACHE_NULL);
+            continue;
+        }
+
+        if (dynamic_cast<mcache_monster*>(m_entries[i]))
+            marshallByte(th, MCACHE_MONSTER);
+        else if (dynamic_cast<mcache_draco*>(m_entries[i]))
+            marshallByte(th, MCACHE_DRACO);
+        else if (dynamic_cast<mcache_ghost*>(m_entries[i]))
+            marshallByte(th, MCACHE_GHOST);
+        else if (dynamic_cast<mcache_demon*>(m_entries[i]))
+            marshallByte(th, MCACHE_DEMON);
+        else
+        {
+            marshallByte(th, MCACHE_NULL);
+            continue;
+        }
+
+        m_entries[i]->construct(th);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// mcache_entry
+
+mcache_entry::mcache_entry(reader &th)
+{
+    m_ref_count = unmarshallLong(th);
+}
+
+void mcache_entry::construct(writer &th)
+{
+    marshallLong(th, m_ref_count);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// mcache_monster
+
+mcache_monster::mcache_monster(const monsters *mon)
+{
+    assert(mcache_monster::valid(mon));
+
+    m_mon_tile = tileidx_monster(mon, false) & TILE_FLAG_MASK;
+
+    int mon_wep = mon->inv[MSLOT_WEAPON];
+    m_equ_tile = tilep_equ_weapon(mitm[mon_wep]);
+}
+
+bool mcache_monster::get_weapon_offset(int mon_tile, int &ofs_x, int &ofs_y)
+{
+    switch (mon_tile)
+    {
+    case TILEP_MONS_VAULT_GUARD:
+    case TILEP_MONS_HOBGOBLIN:
+    case TILEP_MONS_DEEP_ELF_MASTER_ARCHER:
+    case TILEP_MONS_IMP:
+    case TILEP_MONS_ANGEL:
+    case TILEP_MONS_NORRIS:
+    case TILEP_MONS_MAUD:
+    case TILEP_MONS_DUANE:
+    case TILEP_MONS_EDMUND:
+    case TILEP_MONS_FRANCES:
+    case TILEP_MONS_HAROLD:
+    case TILEP_MONS_JOSEPH:
+    case TILEP_MONS_JOZEF:
+    case TILEP_MONS_RUPERT:
+    case TILEP_MONS_TERENCE:
+    case TILEP_MONS_WAYNE:
+    case TILEP_MONS_FREDERICK:
+    case TILEP_MONS_RAKSHASA:
+    case TILEP_MONS_RAKSHASA_FAKE:
+    case TILEP_MONS_VAMPIRE_KNIGHT:
+    case TILEP_MONS_SKELETAL_WARRIOR:
+    case TILEP_MONS_MERMAID:
+    case TILEP_MONS_MERMAID_WATER:
+    case TILEP_MONS_MERFOLK_FIGHTER:
+    case TILEP_MONS_MERFOLK_FIGHTER_WATER:
+        ofs_x = 0;
+        ofs_y = 0;
+        break;
+    case TILEP_MONS_ORC:
+    case TILEP_MONS_URUG:
+    case TILEP_MONS_BLORK_THE_ORC:
+    case TILEP_MONS_ORC_WARRIOR:
+    case TILEP_MONS_ORC_KNIGHT:
+    case TILEP_MONS_ORC_WARLORD:
+        ofs_x = 0;
+        ofs_y = 2;
+        break;
+    case TILEP_MONS_GOBLIN:
+    case TILEP_MONS_IJYB:
+        ofs_x = 0;
+        ofs_y = 4;
+        break;
+    case TILEP_MONS_GNOLL:
+        ofs_x = -1;
+        ofs_y = 0;
+        break;
+    case TILEP_MONS_BOGGART:
+    case TILEP_MONS_DEEP_ELF_FIGHTER:
+    case TILEP_MONS_DEEP_ELF_SOLDIER:
+        ofs_x = 0;
+        ofs_y = 2;
+        break;
+    case TILEP_MONS_DEEP_ELF_KNIGHT:
+        ofs_x = 0;
+        ofs_y = 1;
+        break;
+    case TILEP_MONS_KOBOLD:
+        ofs_x = 3;
+        ofs_y = 4;
+        break;
+    case TILEP_MONS_KOBOLD_DEMONOLOGIST:
+        ofs_x = 0;
+        ofs_y = -10;
+        break;
+    case TILEP_MONS_BIG_KOBOLD:
+        ofs_x = 2;
+        ofs_y = 3;
+        break;
+    case TILEP_MONS_MIDGE:
+        ofs_x = 0;
+        ofs_y = -2;
+        break;
+    case TILEP_MONS_NAGA:
+    case TILEP_MONS_GREATER_NAGA:
+    case TILEP_MONS_NAGA_WARRIOR:
+    case TILEP_MONS_GUARDIAN_NAGA:
+    case TILEP_MONS_NAGA_MAGE:
+        ofs_x = 0;
+        ofs_y = 1;
+        break;
+    case TILEP_MONS_HELL_KNIGHT:
+        ofs_x = -1;
+        ofs_y = 3;
+        break;
+    case TILEP_MONS_RED_DEVIL:
+        ofs_x = 2;
+        ofs_y = -3;
+        break;
+    case TILEP_MONS_WIZARD:
+        ofs_x = 2;
+        ofs_y = -2;
+        break;
+    case TILEP_MONS_HUMAN:
+        ofs_x = 5;
+        ofs_y = 2;
+        break;
+    case TILEP_MONS_ELF:
+        ofs_y = 1;
+        ofs_x = 4;
+        break;
+    case TILEP_MONS_OGRE_MAGE:
+        ofs_y = -2;
+        ofs_x = -4;
+        break;
+    case TILEP_MONS_DEEP_ELF_MAGE:
+    case TILEP_MONS_DEEP_ELF_SUMMONER:
+    case TILEP_MONS_DEEP_ELF_CONJURER:
+    case TILEP_MONS_DEEP_ELF_PRIEST:
+    case TILEP_MONS_DEEP_ELF_HIGH_PRIEST:
+    case TILEP_MONS_DEEP_ELF_DEMONOLOGIST:
+    case TILEP_MONS_DEEP_ELF_ANNIHILATOR:
+    case TILEP_MONS_DEEP_ELF_SORCERER:
+        ofs_x = -1;
+        ofs_y = -2;
+        break;
+    case TILEP_MONS_DEEP_ELF_DEATH_MAGE:
+        ofs_x = -1;
+        ofs_y = 0;
+        break;
+    default:
+        // This monster cannot be displayed with a weapon.
+        return false;
+    }
+
+    return true;
+}
+
+unsigned int mcache_monster::info(tile_draw_info *dinfo) const
+{
+    int ofs_x, ofs_y;
+    get_weapon_offset(m_mon_tile, ofs_x, ofs_y);
+
+    dinfo[0].set(m_mon_tile);
+    dinfo[1].set(m_equ_tile, ofs_x, ofs_y);
+
+    // In some cases, overlay a second weapon tile...
+    if (m_mon_tile == TILEP_MONS_DEEP_ELF_BLADEMASTER)
+    {
+        int eq2;
+        switch (m_equ_tile)
+        {
+            case TILEP_HAND1_DAGGER:
+                eq2 = TILEP_HAND2_DAGGER;
+                break;
+            case TILEP_HAND1_SABRE:
+                eq2 = TILEP_HAND2_SABRE;
+                break;
+            default:
+            case TILEP_HAND1_SHORT_SWORD_SLANT:
+                eq2 = TILEP_HAND2_SHORT_SWORD_SLANT;
+                break;
+        };
+        
+        dinfo[2].set(eq2, -ofs_x, ofs_y);
+
+        return 3;
+    }
+    else
+    {
+        return 2;
+    }
+}
+
+bool mcache_monster::valid(const monsters *mon)
+{
+    if (!mon)
+        return false;
+    int mon_wep = mon->inv[MSLOT_WEAPON];
+    if (mon_wep == NON_ITEM)
+        return false;
+
+    int mon_tile = tileidx_monster(mon, false) & TILE_FLAG_MASK;
+
+    int ox, oy;
+    return get_weapon_offset(mon_tile, ox, oy);
+}
+
+mcache_monster::mcache_monster(reader &th) : mcache_entry(th)
+{
+    m_mon_tile = unmarshallLong(th);
+    m_equ_tile = unmarshallLong(th);
+}
+
+void mcache_monster::construct(writer &th)
+{
+    mcache_entry::construct(th);
+    
+    marshallLong(th, m_mon_tile);
+    marshallLong(th, m_equ_tile);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// mcache_draco
+
+mcache_draco::mcache_draco(const monsters *mon)
+{
+    assert(mcache_draco::valid(mon));
+
+    int draco = draco_subspecies(mon);
+    int colour;
+    switch (draco)
+    {
+    default:
+    case MONS_DRACONIAN:        colour = 0; break;
+    case MONS_BLACK_DRACONIAN:  colour = 1; break;
+    case MONS_YELLOW_DRACONIAN: colour = 2; break;
+    case MONS_GREEN_DRACONIAN:  colour = 4; break;
+    case MONS_MOTTLED_DRACONIAN:colour = 5; break;
+    case MONS_PALE_DRACONIAN:   colour = 6; break;
+    case MONS_PURPLE_DRACONIAN: colour = 7; break;
+    case MONS_RED_DRACONIAN:    colour = 8; break;
+    case MONS_WHITE_DRACONIAN:  colour = 9; break;
+    }
+
+    m_doll.parts[TILEP_PART_SHADOW] = TILEP_SHADOW_SHADOW;
+    m_doll.parts[TILEP_PART_BASE] = TILEP_BASE_DRACONIAN + colour * 2;
+    m_doll.parts[TILEP_PART_DRCWING] =
+        tile_player_part_start[TILEP_PART_DRCWING] + colour;
+    m_doll.parts[TILEP_PART_DRCHEAD] =
+        tile_player_part_start[TILEP_PART_DRCHEAD] + colour;
+
+    int mon_wep = mon->inv[MSLOT_WEAPON];
+    int equ_tile = (mon_wep != NON_ITEM) ? tilep_equ_weapon(mitm[mon_wep]) : 0;
+
+    switch (mon->type)
+    {
+        case MONS_DRACONIAN_CALLER:
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_STAFF_EVIL;
+            m_doll.parts[TILEP_PART_HAND2] = TILEP_HAND2_BOOK_YELLOW;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_ROBE_BROWN;
+            break;
+
+        case MONS_DRACONIAN_MONK:
+            m_doll.parts[TILEP_PART_ARM] = TILEP_ARM_GLOVE_SHORT_BLUE;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_KARATE2;
+            break;
+
+        case MONS_DRACONIAN_ZEALOT:
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_MACE;
+            m_doll.parts[TILEP_PART_HAND2] = TILEP_HAND2_BOOK_CYAN;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_MONK_BLUE;
+            break;
+
+        case MONS_DRACONIAN_SHIFTER:
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_STAFF_LARGE;
+            m_doll.parts[TILEP_PART_HAND2] = TILEP_HAND2_BOOK_GREEN;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_ROBE_CYAN;
+            break;
+
+        case MONS_DRACONIAN_ANNIHILATOR:
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_STAFF_RUBY;
+            m_doll.parts[TILEP_PART_HAND2] = TILEP_HAND2_FIRE_CYAN;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_ROBE_GREEN_GOLD;
+            break;
+
+        case MONS_DRACONIAN_KNIGHT:
+            m_doll.parts[TILEP_PART_HAND1] = equ_tile;
+            m_doll.parts[TILEP_PART_HAND2] = TILEP_HAND2_SHIELD_KNIGHT_GRAY;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_BPLATE_METAL1;
+            m_doll.parts[TILEP_PART_LEG] = TILEP_LEG_BELT_GRAY;
+            break;
+
+        case MONS_DRACONIAN_SCORCHER:
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_FIRE_RED;
+            m_doll.parts[TILEP_PART_HAND2] = TILEP_HAND2_BOOK_RED;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_ROBE_RED;
+            break;
+
+        default:
+            m_doll.parts[TILEP_PART_HAND1] = equ_tile;
+            m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_BELT2;
+            m_doll.parts[TILEP_PART_LEG] = TILEP_LEG_LOINCLOTH_RED;
+            break;
+    }
+}
+
+const dolls_data *mcache_draco::doll() const
+{
+    return &m_doll;
+}
+
+bool mcache_draco::valid(const monsters *mon)
+{
+    return (mon && mon->type >= MONS_FIRST_DRACONIAN 
+            && mon->type <= MONS_LAST_DRACONIAN);
+}
+
+mcache_draco::mcache_draco(reader &th) : mcache_entry(th)
+{
+    unmarshallDoll(th, m_doll);
+}
+
+void mcache_draco::construct(writer &th)
+{
+    mcache_entry::construct(th);
+
+    marshallDoll(th, m_doll);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// mcache_ghost
+
+mcache_ghost::mcache_ghost(const monsters *mon)
+{
+    assert(mcache_ghost::valid(mon));
+
+    const struct ghost_demon &ghost = *mon->ghost;
+
+    unsigned int pseudo_rand = ghost.max_hp * 54321 * 54321;
+    int gender = (pseudo_rand >> 8) & 1;
+
+    tilep_race_default(ghost.species, gender,
+                       ghost.xl, m_doll.parts);
+    tilep_job_default(ghost.job, gender, m_doll.parts);
+
+    for (int p = TILEP_PART_CLOAK; p < TILEP_PART_MAX; p++)
+    {
+         if (m_doll.parts[p] == TILEP_SHOW_EQUIP)
+         {
+             int part_offset = pseudo_rand % tile_player_part_count[p];
+             m_doll.parts[p] = tile_player_part_start[p] + part_offset;
+        }
+    }
+
+    int ac = ghost.ac;
+    ac *= (5 + (pseudo_rand / 11) % 11);
+    ac /= 10;
+
+    if (ac > 25)
+        m_doll.parts[TILEP_PART_BODY] = TILEP_BODY_PLATE_BLACK;
+    else if (ac > 20)
+        m_doll.parts[TILEP_PART_BODY]= TILEP_BODY_BANDED;
+    else if (ac > 15)
+        m_doll.parts[TILEP_PART_BODY]= TILEP_BODY_SCALEMAIL;
+    else if (ac > 10)
+        m_doll.parts[TILEP_PART_BODY]= TILEP_BODY_CHAINMAIL;
+    else if (ac > 5 )
+        m_doll.parts[TILEP_PART_BODY]= TILEP_BODY_LEATHER_HEAVY;
+    else
+        m_doll.parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_BLUE;
+
+    int sk = ghost.best_skill;
+    int dam = ghost.damage;
+    dam *= (5 + pseudo_rand % 11);
+    dam /= 10;
+
+    switch (sk)
+    {
+    case SK_MACES_FLAILS:
+        if (dam > 30)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_GREAT_FRAIL;
+        else if (dam > 25)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_GREAT_MACE;
+        else if (dam > 20)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SPIKED_FRAIL;
+        else if (dam > 15)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_MORNINGSTAR;
+        else if (dam > 10)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_FRAIL;
+        else if (dam > 5)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_MACE;
+        else
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_CLUB_SLANT;
+        break;
+
+    case SK_SHORT_BLADES:
+        if (dam > 20)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SABRE;
+        else if (dam > 10)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SHORT_SWORD_SLANT;
+        else
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_DAGGER_SLANT;
+        break;
+
+    case SK_LONG_BLADES:
+        if (dam > 25)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_GREAT_SWORD_SLANT;
+        else if (dam > 20)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_KATANA_SLANT;
+        else if (dam > 15)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SCIMITAR;
+        else if (dam > 10)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_LONG_SWORD_SLANT;
+        else
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_FALCHION;
+        break;
+
+    case SK_AXES:
+        if (dam > 30)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_EXECUTIONERS_AXE;
+        else if (dam > 20)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_BATTLEAXE;
+        else if (dam > 15)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_BROAD_AXE;
+        else if (dam > 10)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_WAR_AXE;
+        else
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_HAND_AXE;
+        break;
+
+    case SK_POLEARMS:
+        if (dam > 30)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_GLAIVE;
+        else if (dam > 20)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SCYTHE;
+        else if (dam > 15)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_HALBERD;
+        else if (dam > 10)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_TRIDENT2;
+        else if (dam > 10)
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_HAMMER;
+        else
+            m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SPEAR;
+        break;
+
+    case SK_BOWS:
+        m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_BOW2;
+        break;
+
+    case SK_CROSSBOWS:
+        m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_CROSSBOW;
+        break;
+
+    case SK_SLINGS:
+        m_doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SLING;
+        break;
+
+    case SK_UNARMED_COMBAT:
+    default:
+        m_doll.parts[TILEP_PART_HAND1] = m_doll.parts[TILEP_PART_HAND2] = 0;
+        break;
+    }
+}
+
+const dolls_data *mcache_ghost::doll() const
+{
+    return &m_doll;
+}
+
+bool mcache_ghost::valid(const monsters *mon)
+{
+    return (mon && mon->type == MONS_PLAYER_GHOST);
+}
+
+mcache_ghost::mcache_ghost(reader &th) : mcache_entry(th)
+{
+    unmarshallDoll(th, m_doll);
+}
+
+void mcache_ghost::construct(writer &th)
+{
+    mcache_entry::construct(th);
+
+    marshallDoll(th, m_doll);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// mcache_demon
+
+mcache_demon::mcache_demon(const monsters *mon)
+{
+    assert(mcache_demon::valid(mon));
+
+    const struct ghost_demon &ghost = *mon->ghost;
+
+    unsigned int pseudo_rand1 = ghost.max_hp * 54321 * 54321;
+    unsigned int pseudo_rand2 = ghost.ac * 54321 * 54321;
+    unsigned int pseudo_rand3 = ghost.ev * 54321 * 54321;
+
+    int head_offset = pseudo_rand1 % tile_player_count(TILEP_DEMON_HEAD);
+    m_demon.head = TILEP_DEMON_HEAD + head_offset;
+
+    int body_offset = pseudo_rand2 % tile_player_count(TILEP_DEMON_BODY);
+    m_demon.body = TILEP_DEMON_BODY + body_offset;
+
+    if (ghost.ev % 2)
+    {
+        int wings_offset = pseudo_rand3 % tile_player_count(TILEP_DEMON_WINGS);
+        m_demon.wings = TILEP_DEMON_WINGS + wings_offset;
+    }
+    else
+    {
+        m_demon.wings = 0;
+    }
+}
+
+unsigned int mcache_demon::info(tile_draw_info *dinfo) const
+{
+    if (m_demon.wings)
+    {
+        dinfo[0].set(m_demon.wings);
+        dinfo[1].set(m_demon.body);
+        dinfo[2].set(m_demon.head);
+        return 3;
+    }
+    else
+    {
+        dinfo[0].set(m_demon.body);
+        dinfo[1].set(m_demon.head);
+        return 2;
+    }
+}
+
+bool mcache_demon::valid(const monsters *mon)
+{
+    return (mon && mon->type == MONS_PANDEMONIUM_DEMON);
+}
+
+mcache_demon::mcache_demon(reader &th) : mcache_entry(th)
+{
+    unmarshallDemon(th, m_demon);
+}
+
+void mcache_demon::construct(writer &th)
+{
+    mcache_entry::construct(th);
+
+    marshallDemon(th, m_demon);
+}
diff --git a/crawl-ref/source/tilemcache.h b/crawl-ref/source/tilemcache.h
new file mode 100644
index 0000000000..d170ae7de2
--- /dev/null
+++ b/crawl-ref/source/tilemcache.h
@@ -0,0 +1,80 @@
+/*
+ *  File:       tilemcache.h
+ *  Summary:    Monster cache support
+ *  Written by: Enne Walker
+ */
+
+#ifdef USE_TILE
+#ifndef TILEMCACHE_H
+#define TILEMCACHE_H
+
+#include "AppHdr.h"
+#include "debug.h"
+#include <vector>
+
+// The monster cache is designed to hold extra information about monsters that
+// can't be contained in a single tile.  This is usually for equipment,
+// doll parts, or demon parts.
+//
+// Monster cache entries for monsters that are out of sight are ref-counted
+// that they can be drawn even if that monster no longer exists.  When no
+// out-of-sight tiles refer to them, they can be deleted.
+
+class tile_draw_info
+{
+public:
+    tile_draw_info() : idx(~0), ofs_x(0), ofs_y(0) {}
+
+    void set(unsigned int _idx, int _ofs_x = 0, int _ofs_y = 0)
+        { idx = _idx; _ofs_x = ofs_x; _ofs_y = ofs_y; }
+
+    unsigned int idx;
+    int ofs_x;
+    int ofs_y;
+};
+
+class mcache_entry
+{
+public:
+    mcache_entry() : m_ref_count(0) {}
+    virtual ~mcache_entry() {}
+
+    void inc_ref() { m_ref_count++; }
+    void dec_ref() { m_ref_count--; ASSERT(m_ref_count >= 0); }
+    int ref_count() { return m_ref_count; }
+
+    virtual unsigned int info(tile_draw_info *dinfo) const { return 0; }
+    virtual const dolls_data *doll() const { return NULL; }
+
+    virtual void construct(writer &th);
+
+protected:
+    mcache_entry(reader &th);
+
+    // ref count in backstore
+    int m_ref_count;
+};
+
+class mcache_manager
+{
+public:
+    ~mcache_manager();
+
+    unsigned int register_monster(const monsters *mon);
+    mcache_entry *get(unsigned int idx);
+
+    void clear_nonref();
+    void clear_all();
+
+    void read(reader &th);
+    void construct(writer &th);
+
+protected:
+    std::vector<mcache_entry*> m_entries;  
+};
+
+// The global monster cache.
+extern mcache_manager mcache;
+
+#endif
+#endif
diff --git a/crawl-ref/source/tilepick.cc b/crawl-ref/source/tilepick.cc
index 695281c990..00afc11192 100644
--- a/crawl-ref/source/tilepick.cc
+++ b/crawl-ref/source/tilepick.cc
@@ -24,64 +24,12 @@
 #include "stuff.h"
 #include "terrain.h"
 #include "tiles.h"
+#include "tilemcache.h"
 #include "tiledef-dngn.h"
 #include "traps.h"
 #include "travel.h"
 #include "view.h"
 
-struct mcache_entry
-{
-    int mon_tile;
-    int equ_tile;
-    int draco;
-};
-
-static std::vector<mcache_entry> mcache;
-
-int get_base_idx_from_mcache(int tile_idx)
-{
-    int mcache_idx = tile_idx - TILE_MCACHE_START;
-    if (mcache_idx >= 0 && mcache_idx < (int)mcache.size())
-    {
-        return mcache[mcache_idx].mon_tile;
-    }
-
-    return tile_idx;
-}
-
-bool get_mcache_entry(int tile_idx, int &mon_idx, int &equ_tile, int &draco)
-{
-    int mcache_idx = tile_idx - TILE_MCACHE_START;
-    if (mcache_idx >= 0 && (unsigned int)mcache_idx < mcache.size())
-    {
-        mon_idx = mcache[mcache_idx].mon_tile;
-        equ_tile = mcache[mcache_idx].equ_tile;
-        draco = mcache[mcache_idx].draco;
-
-        return true;
-    }
-
-    return false;
-}
-
-static int _mcache_register(int mon_tile, int equ_tile, int draco = 0)
-{
-    mcache_entry entry;
-    entry.mon_tile = mon_tile;
-    entry.equ_tile = equ_tile;
-    entry.draco = draco;
-
-    mcache.push_back(entry);
-
-    int idx = TILE_MCACHE_START + mcache.size() - 1;
-    return idx;
-}
-
-void tile_mcache_unlock()
-{
-    mcache.clear();
-}
-
 static inline bool _is_bazaar()
 {
     return (you.level_type == LEVEL_PORTAL_VAULT
@@ -154,9 +102,8 @@ int tile_unseen_flag(const coord_def& gc)
     }
 }
 
-static int _tileidx_monster_base(int mon_idx, bool detected)
+static int _tileidx_monster_base(const monsters* mon, bool detected)
 {
-    const monsters* mon = &menv[mon_idx];
     int grid = grd(mon->pos());
     bool in_water = (grid == DNGN_SHALLOW_WATER || grid == DNGN_DEEP_WATER);
 
@@ -169,633 +116,633 @@ static int _tileidx_monster_base(int mon_idx, bool detected)
     switch (type)
     {
     case MONS_GIANT_ANT:
-        return TILE_MONS_GIANT_ANT;
+        return TILEP_MONS_GIANT_ANT;
     case MONS_GIANT_BAT:
-        return TILE_MONS_GIANT_BAT;
+        return TILEP_MONS_GIANT_BAT;
     case MONS_CENTAUR:
-        return TILE_MONS_CENTAUR;
+        return TILEP_MONS_CENTAUR;
     case MONS_RED_DEVIL:
-        return TILE_MONS_RED_DEVIL;
+        return TILEP_MONS_RED_DEVIL;
     case MONS_ETTIN:
-        return TILE_MONS_ETTIN;
+        return TILEP_MONS_ETTIN;
     case MONS_FUNGUS:
-        return TILE_MONS_FUNGUS;
+        return TILEP_MONS_FUNGUS;
     case MONS_GOBLIN:
-        return TILE_MONS_GOBLIN;
+        return TILEP_MONS_GOBLIN;
     case MONS_HOUND:
-        return TILE_MONS_HOUND;
+        return TILEP_MONS_HOUND;
     case MONS_IMP:
-        return TILE_MONS_IMP;
+        return TILEP_MONS_IMP;
     case MONS_JACKAL:
-        return TILE_MONS_JACKAL;
+        return TILEP_MONS_JACKAL;
     case MONS_KILLER_BEE:
-        return TILE_MONS_KILLER_BEE;
+        return TILEP_MONS_KILLER_BEE;
     case MONS_KILLER_BEE_LARVA:
-        return TILE_MONS_KILLER_BEE_LARVA;
+        return TILEP_MONS_KILLER_BEE_LARVA;
     case MONS_MANTICORE:
-        return TILE_MONS_MANTICORE;
+        return TILEP_MONS_MANTICORE;
     case MONS_NECROPHAGE:
-        return TILE_MONS_NECROPHAGE;
+        return TILEP_MONS_NECROPHAGE;
     case MONS_ORC:
-        return TILE_MONS_ORC;
+        return TILEP_MONS_ORC;
     case MONS_PHANTOM:
-        return TILE_MONS_PHANTOM;
+        return TILEP_MONS_PHANTOM;
     case MONS_QUASIT:
-        return TILE_MONS_QUASIT;
+        return TILEP_MONS_QUASIT;
     case MONS_RAT:
-        return TILE_MONS_RAT;
+        return TILEP_MONS_RAT;
     case MONS_SCORPION:
-        return TILE_MONS_SCORPION;
+        return TILEP_MONS_SCORPION;
     case MONS_UGLY_THING :
-        return TILE_MONS_UGLY_THING ;
+        return TILEP_MONS_UGLY_THING ;
     case MONS_FIRE_VORTEX:
-        return TILE_MONS_FIRE_VORTEX;
+        return TILEP_MONS_FIRE_VORTEX;
     case MONS_WORM:
-        return TILE_MONS_WORM;
+        return TILEP_MONS_WORM;
     case MONS_ABOMINATION_SMALL:
-        return TILE_MONS_ABOMINATION_SMALL;
+        return TILEP_MONS_ABOMINATION_SMALL;
     case MONS_YELLOW_WASP:
-        return TILE_MONS_YELLOW_WASP;
+        return TILEP_MONS_YELLOW_WASP;
     case MONS_ZOMBIE_SMALL:
-        return TILE_MONS_ZOMBIE_SMALL;
+        return TILEP_MONS_ZOMBIE_SMALL;
     case MONS_ANGEL:
-        return TILE_MONS_ANGEL;
+        return TILEP_MONS_ANGEL;
     case MONS_GIANT_BEETLE:
-        return TILE_MONS_GIANT_BEETLE;
+        return TILEP_MONS_GIANT_BEETLE;
     case MONS_CYCLOPS:
-        return TILE_MONS_CYCLOPS;
+        return TILEP_MONS_CYCLOPS;
     case MONS_DRAGON:
-        return TILE_MONS_DRAGON;
+        return TILEP_MONS_DRAGON;
     case MONS_TWO_HEADED_OGRE:
-        return TILE_MONS_TWO_HEADED_OGRE;
+        return TILEP_MONS_TWO_HEADED_OGRE;
     case MONS_FIEND:
-        return TILE_MONS_FIEND;
+        return TILEP_MONS_FIEND;
     case MONS_GIANT_SPORE:
-        return TILE_MONS_GIANT_SPORE;
+        return TILEP_MONS_GIANT_SPORE;
     case MONS_HOBGOBLIN:
-        return TILE_MONS_HOBGOBLIN;
+        return TILEP_MONS_HOBGOBLIN;
     case MONS_ICE_BEAST:
-        return TILE_MONS_ICE_BEAST;
+        return TILEP_MONS_ICE_BEAST;
     case MONS_JELLY:
-        return TILE_MONS_JELLY;
+        return TILEP_MONS_JELLY;
     case MONS_KOBOLD:
-        return TILE_MONS_KOBOLD;
+        return TILEP_MONS_KOBOLD;
     case MONS_LICH:
-        return TILE_MONS_LICH;
+        return TILEP_MONS_LICH;
     case MONS_MUMMY:
-        return TILE_MONS_MUMMY;
+        return TILEP_MONS_MUMMY;
     case MONS_GUARDIAN_NAGA:
-        return TILE_MONS_GUARDIAN_NAGA;
+        return TILEP_MONS_GUARDIAN_NAGA;
     case MONS_OGRE:
-        return TILE_MONS_OGRE;
+        return TILEP_MONS_OGRE;
     case MONS_PLANT:
-        return TILE_MONS_PLANT;
+        return TILEP_MONS_PLANT;
     case MONS_QUEEN_BEE:
-        return TILE_MONS_QUEEN_BEE;
+        return TILEP_MONS_QUEEN_BEE;
     case MONS_RAKSHASA:
-        return TILE_MONS_RAKSHASA;
+        return TILEP_MONS_RAKSHASA;
     case MONS_SNAKE:
-        return TILE_MONS_SNAKE;
+        return TILEP_MONS_SNAKE;
     case MONS_TROLL:
-        return TILE_MONS_TROLL;
+        return TILEP_MONS_TROLL;
     case MONS_UNSEEN_HORROR:
-        return TILE_MONS_UNSEEN_HORROR;
+        return TILEP_MONS_UNSEEN_HORROR;
     case MONS_VAMPIRE:
-        return TILE_MONS_VAMPIRE;
+        return TILEP_MONS_VAMPIRE;
     case MONS_WRAITH:
-        return TILE_MONS_WRAITH;
+        return TILEP_MONS_WRAITH;
     case MONS_ABOMINATION_LARGE:
-        return TILE_MONS_ABOMINATION_LARGE + ((mon->colour)%7);
+        return TILEP_MONS_ABOMINATION_LARGE + ((mon->colour)%7);
     case MONS_YAK:
-        return TILE_MONS_YAK;
+        return TILEP_MONS_YAK;
     case MONS_ZOMBIE_LARGE:
-        return TILE_MONS_ZOMBIE_LARGE;
+        return TILEP_MONS_ZOMBIE_LARGE;
     case MONS_ORC_WARRIOR:
-        return TILE_MONS_ORC_WARRIOR;
+        return TILEP_MONS_ORC_WARRIOR;
     case MONS_KOBOLD_DEMONOLOGIST:
-        return TILE_MONS_KOBOLD_DEMONOLOGIST;
+        return TILEP_MONS_KOBOLD_DEMONOLOGIST;
     case MONS_ORC_WIZARD:
-        return TILE_MONS_ORC_WIZARD;
+        return TILEP_MONS_ORC_WIZARD;
     case MONS_ORC_KNIGHT:
-        return TILE_MONS_ORC_KNIGHT;
+        return TILEP_MONS_ORC_KNIGHT;
     case MONS_WYVERN:
-        return TILE_MONS_WYVERN;
+        return TILEP_MONS_WYVERN;
     case MONS_BIG_KOBOLD:
-        return TILE_MONS_BIG_KOBOLD;
+        return TILEP_MONS_BIG_KOBOLD;
     case MONS_GIANT_EYEBALL:
-        return TILE_MONS_GIANT_EYEBALL;
+        return TILEP_MONS_GIANT_EYEBALL;
     case MONS_WIGHT:
-        return TILE_MONS_WIGHT;
+        return TILEP_MONS_WIGHT;
     case MONS_OKLOB_PLANT:
-        return TILE_MONS_OKLOB_PLANT;
+        return TILEP_MONS_OKLOB_PLANT;
     case MONS_WOLF_SPIDER:
-        return TILE_MONS_WOLF_SPIDER;
+        return TILEP_MONS_WOLF_SPIDER;
     case MONS_SHADOW:
-        return TILE_MONS_SHADOW;
+        return TILEP_MONS_SHADOW;
     case MONS_HUNGRY_GHOST:
-        return TILE_MONS_HUNGRY_GHOST;
+        return TILEP_MONS_HUNGRY_GHOST;
     case MONS_EYE_OF_DRAINING:
-        return TILE_MONS_EYE_OF_DRAINING;
+        return TILEP_MONS_EYE_OF_DRAINING;
     case MONS_BUTTERFLY:
-        return TILE_MONS_BUTTERFLY + ((mon->colour)%7);
+        return TILEP_MONS_BUTTERFLY + ((mon->colour)%7);
     case MONS_WANDERING_MUSHROOM:
-        return TILE_MONS_WANDERING_MUSHROOM;
+        return TILEP_MONS_WANDERING_MUSHROOM;
     case MONS_EFREET:
-        return TILE_MONS_EFREET;
+        return TILEP_MONS_EFREET;
     case MONS_BRAIN_WORM:
-        return TILE_MONS_BRAIN_WORM;
+        return TILEP_MONS_BRAIN_WORM;
     case MONS_GIANT_ORANGE_BRAIN:
-        return TILE_MONS_GIANT_ORANGE_BRAIN;
+        return TILEP_MONS_GIANT_ORANGE_BRAIN;
     case MONS_BOULDER_BEETLE:
-        return TILE_MONS_BOULDER_BEETLE;
+        return TILEP_MONS_BOULDER_BEETLE;
     case MONS_FLYING_SKULL:
-        return TILE_MONS_FLYING_SKULL;
+        return TILEP_MONS_FLYING_SKULL;
     case MONS_HELL_HOUND:
-        return TILE_MONS_HELL_HOUND;
+        return TILEP_MONS_HELL_HOUND;
     case MONS_MINOTAUR:
-        return TILE_MONS_MINOTAUR;
+        return TILEP_MONS_MINOTAUR;
     case MONS_ICE_DRAGON:
-        return TILE_MONS_ICE_DRAGON;
+        return TILEP_MONS_ICE_DRAGON;
     case MONS_SLIME_CREATURE:
-        return TILE_MONS_SLIME_CREATURE;
+        return TILEP_MONS_SLIME_CREATURE;
     case MONS_FREEZING_WRAITH:
-        return TILE_MONS_FREEZING_WRAITH;
+        return TILEP_MONS_FREEZING_WRAITH;
     case MONS_RAKSHASA_FAKE:
-        return TILE_MONS_RAKSHASA_FAKE;
+        return TILEP_MONS_RAKSHASA_FAKE;
     case MONS_GREAT_ORB_OF_EYES:
-        return TILE_MONS_GREAT_ORB_OF_EYES;
+        return TILEP_MONS_GREAT_ORB_OF_EYES;
     case MONS_HELLION:
-        return TILE_MONS_HELLION;
+        return TILEP_MONS_HELLION;
     case MONS_ROTTING_DEVIL:
-        return TILE_MONS_ROTTING_DEVIL;
+        return TILEP_MONS_ROTTING_DEVIL;
     case MONS_TORMENTOR:
-        return TILE_MONS_TORMENTOR;
+        return TILEP_MONS_TORMENTOR;
     case MONS_REAPER:
-        return TILE_MONS_REAPER;
+        return TILEP_MONS_REAPER;
     case MONS_SOUL_EATER:
-        return TILE_MONS_SOUL_EATER;
+        return TILEP_MONS_SOUL_EATER;
     case MONS_HAIRY_DEVIL:
-        return TILE_MONS_HAIRY_DEVIL;
+        return TILEP_MONS_HAIRY_DEVIL;
     case MONS_ICE_DEVIL:
-        return TILE_MONS_ICE_DEVIL;
+        return TILEP_MONS_ICE_DEVIL;
     case MONS_BLUE_DEVIL:
-        return TILE_MONS_BLUE_DEVIL;
+        return TILEP_MONS_BLUE_DEVIL;
     case MONS_BEAST:
-        return TILE_MONS_BEAST;
+        return TILEP_MONS_BEAST;
     case MONS_IRON_DEVIL:
-        return TILE_MONS_IRON_DEVIL;
+        return TILEP_MONS_IRON_DEVIL;
     case MONS_GLOWING_SHAPESHIFTER:
-        return TILE_MONS_GLOWING_SHAPESHIFTER;
+        return TILEP_MONS_GLOWING_SHAPESHIFTER;
     case MONS_SHAPESHIFTER:
-        return TILE_MONS_SHAPESHIFTER;
+        return TILEP_MONS_SHAPESHIFTER;
     case MONS_GIANT_MITE:
-        return TILE_MONS_GIANT_MITE;
+        return TILEP_MONS_GIANT_MITE;
     case MONS_STEAM_DRAGON:
-        return TILE_MONS_STEAM_DRAGON;
+        return TILEP_MONS_STEAM_DRAGON;
     case MONS_VERY_UGLY_THING:
-        return TILE_MONS_VERY_UGLY_THING;
+        return TILEP_MONS_VERY_UGLY_THING;
     case MONS_ORC_SORCERER:
-        return TILE_MONS_ORC_SORCERER;
+        return TILEP_MONS_ORC_SORCERER;
     case MONS_HIPPOGRIFF:
-        return TILE_MONS_HIPPOGRIFF;
+        return TILEP_MONS_HIPPOGRIFF;
     case MONS_GRIFFON:
-        return TILE_MONS_GRIFFON;
+        return TILEP_MONS_GRIFFON;
 
     case MONS_HYDRA:
         // Number of heads
-        return TILE_MONS_HYDRA + std::min((int)mon->number, 7) - 1;
+        return TILEP_MONS_HYDRA + std::min((int)mon->number, 7) - 1;
 
     case MONS_SKELETON_SMALL:
-        return TILE_MONS_SKELETON_SMALL;
+        return TILEP_MONS_SKELETON_SMALL;
     case MONS_SKELETON_LARGE:
-        return TILE_MONS_SKELETON_LARGE;
+        return TILEP_MONS_SKELETON_LARGE;
     case MONS_HELL_KNIGHT:
-        return TILE_MONS_HELL_KNIGHT;
+        return TILEP_MONS_HELL_KNIGHT;
     case MONS_NECROMANCER:
-        return TILE_MONS_NECROMANCER;
+        return TILEP_MONS_NECROMANCER;
     case MONS_WIZARD:
-        return TILE_MONS_WIZARD;
+        return TILEP_MONS_WIZARD;
     case MONS_ORC_PRIEST:
-        return TILE_MONS_ORC_PRIEST;
+        return TILEP_MONS_ORC_PRIEST;
     case MONS_ORC_HIGH_PRIEST:
-        return TILE_MONS_ORC_HIGH_PRIEST;
+        return TILEP_MONS_ORC_HIGH_PRIEST;
     case MONS_HUMAN:
-        return TILE_MONS_HUMAN;
+        return TILEP_MONS_HUMAN;
     case MONS_GNOLL:
-        return TILE_MONS_GNOLL;
+        return TILEP_MONS_GNOLL;
     case MONS_CLAY_GOLEM:
-        return TILE_MONS_CLAY_GOLEM;
+        return TILEP_MONS_CLAY_GOLEM;
     case MONS_WOOD_GOLEM:
-        return TILE_MONS_WOOD_GOLEM;
+        return TILEP_MONS_WOOD_GOLEM;
     case MONS_STONE_GOLEM:
-        return TILE_MONS_STONE_GOLEM;
+        return TILEP_MONS_STONE_GOLEM;
     case MONS_IRON_GOLEM:
-        return TILE_MONS_IRON_GOLEM;
+        return TILEP_MONS_IRON_GOLEM;
     case MONS_CRYSTAL_GOLEM:
-        return TILE_MONS_CRYSTAL_GOLEM;
+        return TILEP_MONS_CRYSTAL_GOLEM;
     case MONS_TOENAIL_GOLEM:
-        return TILE_MONS_TOENAIL_GOLEM;
+        return TILEP_MONS_TOENAIL_GOLEM;
     case MONS_MOTTLED_DRAGON:
-        return TILE_MONS_MOTTLED_DRAGON;
+        return TILEP_MONS_MOTTLED_DRAGON;
     case MONS_EARTH_ELEMENTAL:
-        return TILE_MONS_EARTH_ELEMENTAL;
+        return TILEP_MONS_EARTH_ELEMENTAL;
     case MONS_FIRE_ELEMENTAL:
-        return TILE_MONS_FIRE_ELEMENTAL;
+        return TILEP_MONS_FIRE_ELEMENTAL;
     case MONS_AIR_ELEMENTAL:
-        return TILE_MONS_AIR_ELEMENTAL;
+        return TILEP_MONS_AIR_ELEMENTAL;
     case MONS_ICE_FIEND:
-        return TILE_MONS_ICE_FIEND;
+        return TILEP_MONS_ICE_FIEND;
     case MONS_SHADOW_FIEND:
-        return TILE_MONS_SHADOW_FIEND;
+        return TILEP_MONS_SHADOW_FIEND;
     case MONS_BROWN_SNAKE:
-        return TILE_MONS_BROWN_SNAKE;
+        return TILEP_MONS_BROWN_SNAKE;
     case MONS_GIANT_LIZARD:
-        return TILE_MONS_GIANT_LIZARD;
+        return TILEP_MONS_GIANT_LIZARD;
     case MONS_SPECTRAL_WARRIOR:
-        return TILE_MONS_SPECTRAL_WARRIOR;
+        return TILEP_MONS_SPECTRAL_WARRIOR;
     case MONS_PULSATING_LUMP:
-        return TILE_MONS_PULSATING_LUMP;
+        return TILEP_MONS_PULSATING_LUMP;
     case MONS_STORM_DRAGON:
-        return TILE_MONS_STORM_DRAGON;
+        return TILEP_MONS_STORM_DRAGON;
     case MONS_YAKTAUR:
-        return TILE_MONS_YAKTAUR;
+        return TILEP_MONS_YAKTAUR;
     case MONS_DEATH_YAK:
-        return TILE_MONS_DEATH_YAK;
+        return TILEP_MONS_DEATH_YAK;
     case MONS_ROCK_TROLL:
-        return TILE_MONS_ROCK_TROLL;
+        return TILEP_MONS_ROCK_TROLL;
     case MONS_STONE_GIANT:
-        return TILE_MONS_STONE_GIANT;
+        return TILEP_MONS_STONE_GIANT;
     case MONS_FLAYED_GHOST:
-        return TILE_MONS_FLAYED_GHOST;
+        return TILEP_MONS_FLAYED_GHOST;
     case MONS_BUMBLEBEE:
-        return TILE_MONS_BUMBLEBEE;
+        return TILEP_MONS_BUMBLEBEE;
     case MONS_REDBACK:
-        return TILE_MONS_REDBACK;
+        return TILEP_MONS_REDBACK;
     case MONS_INSUBSTANTIAL_WISP:
-        return TILE_MONS_INSUBSTANTIAL_WISP;
+        return TILEP_MONS_INSUBSTANTIAL_WISP;
     case MONS_VAPOUR:
-        return TILE_MONS_VAPOUR;
+        return TILEP_MONS_VAPOUR;
     case MONS_OGRE_MAGE:
-        return TILE_MONS_OGRE_MAGE;
+        return TILEP_MONS_OGRE_MAGE;
     case MONS_SPINY_WORM:
-        return TILE_MONS_SPINY_WORM;
+        return TILEP_MONS_SPINY_WORM;
 
     case MONS_DANCING_WEAPON:
     {
         // Use item tile
-        item_def item = mitm[menv[mon_idx].inv[MSLOT_WEAPON]];
+        item_def item = mitm[mon->inv[MSLOT_WEAPON]];
         return tileidx_item(item) | TILE_FLAG_ANIM_WEP;
     }
 
     case MONS_TITAN:
-        return TILE_MONS_TITAN;
+        return TILEP_MONS_TITAN;
     case MONS_GOLDEN_DRAGON:
-        return TILE_MONS_GOLDEN_DRAGON;
+        return TILEP_MONS_GOLDEN_DRAGON;
     case MONS_ELF:
-        return TILE_MONS_ELF;
+        return TILEP_MONS_ELF;
     case MONS_LINDWURM:
-        return TILE_MONS_LINDWURM;
+        return TILEP_MONS_LINDWURM;
     case MONS_ELEPHANT_SLUG:
-        return TILE_MONS_ELEPHANT_SLUG;
+        return TILEP_MONS_ELEPHANT_SLUG;
     case MONS_WAR_DOG:
-        return TILE_MONS_WAR_DOG;
+        return TILEP_MONS_WAR_DOG;
     case MONS_GREY_RAT:
-        return TILE_MONS_GREY_RAT;
+        return TILEP_MONS_GREY_RAT;
     case MONS_GREEN_RAT:
-        return TILE_MONS_GREEN_RAT;
+        return TILEP_MONS_GREEN_RAT;
     case MONS_ORANGE_RAT:
-        return TILE_MONS_ORANGE_RAT;
+        return TILEP_MONS_ORANGE_RAT;
     case MONS_BLACK_SNAKE:
-        return TILE_MONS_BLACK_SNAKE;
+        return TILEP_MONS_BLACK_SNAKE;
     case MONS_SHEEP:
-        return TILE_MONS_SHEEP;
+        return TILEP_MONS_SHEEP;
     case MONS_GHOUL:
-        return TILE_MONS_GHOUL;
+        return TILEP_MONS_GHOUL;
     case MONS_HOG:
-        return TILE_MONS_HOG;
+        return TILEP_MONS_HOG;
     case MONS_GIANT_MOSQUITO:
-        return TILE_MONS_GIANT_MOSQUITO;
+        return TILEP_MONS_GIANT_MOSQUITO;
     case MONS_GIANT_CENTIPEDE:
-        return TILE_MONS_GIANT_CENTIPEDE;
+        return TILEP_MONS_GIANT_CENTIPEDE;
     case MONS_IRON_TROLL:
-        return TILE_MONS_IRON_TROLL;
+        return TILEP_MONS_IRON_TROLL;
     case MONS_NAGA:
-        return TILE_MONS_NAGA;
+        return TILEP_MONS_NAGA;
     case MONS_FIRE_GIANT:
-        return TILE_MONS_FIRE_GIANT;
+        return TILEP_MONS_FIRE_GIANT;
     case MONS_FROST_GIANT:
-        return TILE_MONS_FROST_GIANT;
+        return TILEP_MONS_FROST_GIANT;
     case MONS_FIREDRAKE:
-        return TILE_MONS_FIREDRAKE;
+        return TILEP_MONS_FIREDRAKE;
     case MONS_SHADOW_DRAGON:
-        return TILE_MONS_SHADOW_DRAGON;
+        return TILEP_MONS_SHADOW_DRAGON;
     case MONS_YELLOW_SNAKE:
-        return TILE_MONS_YELLOW_SNAKE;
+        return TILEP_MONS_YELLOW_SNAKE;
     case MONS_GREY_SNAKE:
-        return TILE_MONS_GREY_SNAKE;
+        return TILEP_MONS_GREY_SNAKE;
     case MONS_DEEP_TROLL:
-        return TILE_MONS_DEEP_TROLL;
+        return TILEP_MONS_DEEP_TROLL;
     case MONS_GIANT_BLOWFLY:
-        return TILE_MONS_GIANT_BLOWFLY;
+        return TILEP_MONS_GIANT_BLOWFLY;
     case MONS_RED_WASP:
-        return TILE_MONS_RED_WASP;
+        return TILEP_MONS_RED_WASP;
     case MONS_SWAMP_DRAGON:
-        return TILE_MONS_SWAMP_DRAGON;
+        return TILEP_MONS_SWAMP_DRAGON;
     case MONS_SWAMP_DRAKE:
-        return TILE_MONS_SWAMP_DRAKE;
+        return TILEP_MONS_SWAMP_DRAKE;
     case MONS_SOLDIER_ANT:
-        return TILE_MONS_SOLDIER_ANT;
+        return TILEP_MONS_SOLDIER_ANT;
     case MONS_HILL_GIANT:
-        return TILE_MONS_HILL_GIANT;
+        return TILEP_MONS_HILL_GIANT;
     case MONS_QUEEN_ANT:
-        return TILE_MONS_QUEEN_ANT;
+        return TILEP_MONS_QUEEN_ANT;
     case MONS_ANT_LARVA:
-        return TILE_MONS_ANT_LARVA;
+        return TILEP_MONS_ANT_LARVA;
     case MONS_GIANT_FROG:
-        return TILE_MONS_GIANT_FROG;
+        return TILEP_MONS_GIANT_FROG;
     case MONS_GIANT_BROWN_FROG:
-        return TILE_MONS_GIANT_BROWN_FROG;
+        return TILEP_MONS_GIANT_BROWN_FROG;
     case MONS_SPINY_FROG:
-        return TILE_MONS_SPINY_FROG;
+        return TILEP_MONS_SPINY_FROG;
     case MONS_BLINK_FROG:
-        return TILE_MONS_BLINK_FROG;
+        return TILEP_MONS_BLINK_FROG;
     case MONS_GIANT_COCKROACH:
-        return TILE_MONS_GIANT_COCKROACH;
+        return TILEP_MONS_GIANT_COCKROACH;
     case MONS_SMALL_SNAKE:
-        return TILE_MONS_SMALL_SNAKE;
+        return TILEP_MONS_SMALL_SNAKE;
     case MONS_SHUGGOTH:
         return TILE_TODO;
     case MONS_WOLF:
-        return TILE_MONS_WOLF;
+        return TILEP_MONS_WOLF;
     case MONS_WARG:
-        return TILE_MONS_WARG;
+        return TILEP_MONS_WARG;
     case MONS_BEAR:
-        return TILE_MONS_BEAR;
+        return TILEP_MONS_BEAR;
     case MONS_GRIZZLY_BEAR:
-        return TILE_MONS_GRIZZLY_BEAR;
+        return TILEP_MONS_GRIZZLY_BEAR;
     case MONS_POLAR_BEAR:
-        return TILE_MONS_POLAR_BEAR;
+        return TILEP_MONS_POLAR_BEAR;
     case MONS_BLACK_BEAR:
-        return TILE_MONS_BLACK_BEAR;
+        return TILEP_MONS_BLACK_BEAR;
     case MONS_SIMULACRUM_SMALL:
-        return TILE_MONS_SIMULACRUM_SMALL;
+        return TILEP_MONS_SIMULACRUM_SMALL;
     case MONS_SIMULACRUM_LARGE:
-        return TILE_MONS_SIMULACRUM_LARGE;
+        return TILEP_MONS_SIMULACRUM_LARGE;
     case MONS_WHITE_IMP:
-        return TILE_MONS_WHITE_IMP;
+        return TILEP_MONS_WHITE_IMP;
     case MONS_LEMURE:
-        return TILE_MONS_LEMURE;
+        return TILEP_MONS_LEMURE;
     case MONS_UFETUBUS:
-        return TILE_MONS_UFETUBUS;
+        return TILEP_MONS_UFETUBUS;
     case MONS_MANES:
-        return TILE_MONS_MANES;
+        return TILEP_MONS_MANES;
     case MONS_MIDGE:
-        return TILE_MONS_MIDGE;
+        return TILEP_MONS_MIDGE;
     case MONS_NEQOXEC:
-        return TILE_MONS_NEQOXEC;
+        return TILEP_MONS_NEQOXEC;
     case MONS_ORANGE_DEMON:
-        return TILE_MONS_ORANGE_DEMON;
+        return TILEP_MONS_ORANGE_DEMON;
     case MONS_HELLWING:
-        return TILE_MONS_HELLWING;
+        return TILEP_MONS_HELLWING;
     case MONS_SMOKE_DEMON:
-        return TILE_MONS_SMOKE_DEMON;
+        return TILEP_MONS_SMOKE_DEMON;
     case MONS_YNOXINUL:
-        return TILE_MONS_YNOXINUL;
+        return TILEP_MONS_YNOXINUL;
     case MONS_EXECUTIONER:
-        return TILE_MONS_EXECUTIONER;
+        return TILEP_MONS_EXECUTIONER;
     case MONS_GREEN_DEATH:
-        return TILE_MONS_GREEN_DEATH;
+        return TILEP_MONS_GREEN_DEATH;
     case MONS_BLUE_DEATH:
-        return TILE_MONS_BLUE_DEATH;
+        return TILEP_MONS_BLUE_DEATH;
     case MONS_BALRUG:
-        return TILE_MONS_BALRUG;
+        return TILEP_MONS_BALRUG;
     case MONS_CACODEMON:
-        return TILE_MONS_CACODEMON;
+        return TILEP_MONS_CACODEMON;
     case MONS_DEMONIC_CRAWLER:
-        return TILE_MONS_DEMONIC_CRAWLER;
+        return TILEP_MONS_DEMONIC_CRAWLER;
     case MONS_SUN_DEMON:
-        return TILE_MONS_SUN_DEMON;
+        return TILEP_MONS_SUN_DEMON;
     case MONS_SHADOW_IMP:
-        return TILE_MONS_SHADOW_IMP;
+        return TILEP_MONS_SHADOW_IMP;
     case MONS_SHADOW_DEMON:
-        return TILE_MONS_SHADOW_DEMON;
+        return TILEP_MONS_SHADOW_DEMON;
     case MONS_LOROCYPROCA:
-        return TILE_MONS_LOROCYPROCA;
+        return TILEP_MONS_LOROCYPROCA;
     case MONS_SHADOW_WRAITH:
-        return TILE_MONS_SHADOW_WRAITH;
+        return TILEP_MONS_SHADOW_WRAITH;
     case MONS_GIANT_AMOEBA:
-        return TILE_MONS_GIANT_AMOEBA;
+        return TILEP_MONS_GIANT_AMOEBA;
     case MONS_GIANT_SLUG:
-        return TILE_MONS_GIANT_SLUG;
+        return TILEP_MONS_GIANT_SLUG;
     case MONS_GIANT_SNAIL:
-        return TILE_MONS_GIANT_SNAIL;
+        return TILEP_MONS_GIANT_SNAIL;
     case MONS_SPATIAL_VORTEX:
-        return TILE_MONS_SPATIAL_VORTEX;
+        return TILEP_MONS_SPATIAL_VORTEX;
     case MONS_PIT_FIEND:
-        return TILE_MONS_PIT_FIEND;
+        return TILEP_MONS_PIT_FIEND;
     case MONS_BORING_BEETLE:
-        return TILE_MONS_BORING_BEETLE;
+        return TILEP_MONS_BORING_BEETLE;
     case MONS_GARGOYLE:
-        return TILE_MONS_GARGOYLE;
+        return TILEP_MONS_GARGOYLE;
     case MONS_METAL_GARGOYLE:
-        return TILE_MONS_METAL_GARGOYLE;
+        return TILEP_MONS_METAL_GARGOYLE;
     case MONS_MOLTEN_GARGOYLE:
-        return TILE_MONS_MOLTEN_GARGOYLE;
+        return TILEP_MONS_MOLTEN_GARGOYLE;
     case MONS_PROGRAM_BUG:
-        return TILE_MONS_PROGRAM_BUG;
+        return TILEP_MONS_PROGRAM_BUG;
     case MONS_MNOLEG:
-        return TILE_MONS_MNOLEG;
+        return TILEP_MONS_MNOLEG;
     case MONS_LOM_LOBON:
-        return TILE_MONS_LOM_LOBON;
+        return TILEP_MONS_LOM_LOBON;
     case MONS_CEREBOV:
-        return TILE_MONS_CEREBOV;
+        return TILEP_MONS_CEREBOV;
     case MONS_GLOORX_VLOQ:
-        return TILE_MONS_GLOORX_VLOQ;
+        return TILEP_MONS_GLOORX_VLOQ;
     case MONS_MOLLUSC_LORD:
         return TILE_TODO;
     case MONS_NAGA_MAGE:
-        return TILE_MONS_NAGA_MAGE;
+        return TILEP_MONS_NAGA_MAGE;
     case MONS_NAGA_WARRIOR:
-        return TILE_MONS_NAGA_WARRIOR;
+        return TILEP_MONS_NAGA_WARRIOR;
     case MONS_ORC_WARLORD:
-        return TILE_MONS_ORC_WARLORD;
+        return TILEP_MONS_ORC_WARLORD;
     case MONS_DEEP_ELF_SOLDIER:
-        return TILE_MONS_DEEP_ELF_SOLDIER;
+        return TILEP_MONS_DEEP_ELF_SOLDIER;
     case MONS_DEEP_ELF_FIGHTER:
-        return TILE_MONS_DEEP_ELF_FIGHTER;
+        return TILEP_MONS_DEEP_ELF_FIGHTER;
     case MONS_DEEP_ELF_KNIGHT:
-        return TILE_MONS_DEEP_ELF_KNIGHT;
+        return TILEP_MONS_DEEP_ELF_KNIGHT;
     case MONS_DEEP_ELF_MAGE:
-        return TILE_MONS_DEEP_ELF_MAGE;
+        return TILEP_MONS_DEEP_ELF_MAGE;
     case MONS_DEEP_ELF_SUMMONER:
-        return TILE_MONS_DEEP_ELF_SUMMONER;
+        return TILEP_MONS_DEEP_ELF_SUMMONER;
     case MONS_DEEP_ELF_CONJURER:
-        return TILE_MONS_DEEP_ELF_CONJURER;
+        return TILEP_MONS_DEEP_ELF_CONJURER;
     case MONS_DEEP_ELF_PRIEST:
-        return TILE_MONS_DEEP_ELF_PRIEST;
+        return TILEP_MONS_DEEP_ELF_PRIEST;
     case MONS_DEEP_ELF_HIGH_PRIEST:
-        return TILE_MONS_DEEP_ELF_HIGH_PRIEST;
+        return TILEP_MONS_DEEP_ELF_HIGH_PRIEST;
     case MONS_DEEP_ELF_DEMONOLOGIST:
-        return TILE_MONS_DEEP_ELF_DEMONOLOGIST;
+        return TILEP_MONS_DEEP_ELF_DEMONOLOGIST;
     case MONS_DEEP_ELF_ANNIHILATOR:
-        return TILE_MONS_DEEP_ELF_ANNIHILATOR;
+        return TILEP_MONS_DEEP_ELF_ANNIHILATOR;
     case MONS_DEEP_ELF_SORCERER:
-        return TILE_MONS_DEEP_ELF_SORCERER;
+        return TILEP_MONS_DEEP_ELF_SORCERER;
     case MONS_DEEP_ELF_DEATH_MAGE:
-        return TILE_MONS_DEEP_ELF_DEATH_MAGE;
+        return TILEP_MONS_DEEP_ELF_DEATH_MAGE;
     case MONS_BROWN_OOZE:
-        return TILE_MONS_BROWN_OOZE;
+        return TILEP_MONS_BROWN_OOZE;
     case MONS_AZURE_JELLY:
-        return TILE_MONS_AZURE_JELLY;
+        return TILEP_MONS_AZURE_JELLY;
     case MONS_DEATH_OOZE:
-        return TILE_MONS_DEATH_OOZE;
+        return TILEP_MONS_DEATH_OOZE;
     case MONS_ACID_BLOB:
-        return TILE_MONS_ACID_BLOB;
+        return TILEP_MONS_ACID_BLOB;
     case MONS_ROYAL_JELLY:
-        return TILE_MONS_ROYAL_JELLY;
+        return TILEP_MONS_ROYAL_JELLY;
     case MONS_TERENCE:
-        return TILE_MONS_TERENCE;
+        return TILEP_MONS_TERENCE;
     case MONS_JESSICA:
-        return TILE_MONS_JESSICA;
+        return TILEP_MONS_JESSICA;
     case MONS_IJYB:
-        return TILE_MONS_IJYB;
+        return TILEP_MONS_IJYB;
     case MONS_SIGMUND:
-        return TILE_MONS_SIGMUND;
+        return TILEP_MONS_SIGMUND;
     case MONS_BLORK_THE_ORC:
-        return TILE_MONS_BLORK_THE_ORC;
+        return TILEP_MONS_BLORK_THE_ORC;
     case MONS_EDMUND:
-        return TILE_MONS_EDMUND;
+        return TILEP_MONS_EDMUND;
     case MONS_PSYCHE:
-        return TILE_MONS_PSYCHE;
+        return TILEP_MONS_PSYCHE;
     case MONS_EROLCHA:
-        return TILE_MONS_EROLCHA;
+        return TILEP_MONS_EROLCHA;
     case MONS_DONALD:
-        return TILE_MONS_DONALD;
+        return TILEP_MONS_DONALD;
     case MONS_URUG:
-        return TILE_MONS_URUG;
+        return TILEP_MONS_URUG;
     case MONS_MICHAEL:
-        return TILE_MONS_MICHAEL;
+        return TILEP_MONS_MICHAEL;
     case MONS_JOSEPH:
-        return TILE_MONS_JOSEPH;
+        return TILEP_MONS_JOSEPH;
     case MONS_SNORG:
-        return TILE_MONS_SNORG;
+        return TILEP_MONS_SNORG;
     case MONS_ERICA:
-        return TILE_MONS_ERICA;
+        return TILEP_MONS_ERICA;
     case MONS_JOSEPHINE:
-        return TILE_MONS_JOSEPHINE;
+        return TILEP_MONS_JOSEPHINE;
     case MONS_HAROLD:
-        return TILE_MONS_HAROLD;
+        return TILEP_MONS_HAROLD;
     case MONS_NORBERT:
-        return TILE_MONS_NORBERT;
+        return TILEP_MONS_NORBERT;
     case MONS_JOZEF:
-        return TILE_MONS_JOZEF;
+        return TILEP_MONS_JOZEF;
     case MONS_AGNES:
-        return TILE_MONS_AGNES;
+        return TILEP_MONS_AGNES;
     case MONS_MAUD:
-        return TILE_MONS_MAUD;
+        return TILEP_MONS_MAUD;
     case MONS_LOUISE:
-        return TILE_MONS_LOUISE;
+        return TILEP_MONS_LOUISE;
     case MONS_FRANCIS:
-        return TILE_MONS_FRANCIS;
+        return TILEP_MONS_FRANCIS;
     case MONS_FRANCES:
-        return TILE_MONS_FRANCES;
+        return TILEP_MONS_FRANCES;
     case MONS_RUPERT:
-        return TILE_MONS_RUPERT;
+        return TILEP_MONS_RUPERT;
     case MONS_WAYNE:
-        return TILE_MONS_WAYNE;
+        return TILEP_MONS_WAYNE;
     case MONS_DUANE:
-        return TILE_MONS_DUANE;
+        return TILEP_MONS_DUANE;
     case MONS_XTAHUA:
-        return TILE_MONS_XTAHUA;
+        return TILEP_MONS_XTAHUA;
     case MONS_NORRIS:
-        return TILE_MONS_NORRIS;
+        return TILEP_MONS_NORRIS;
     case MONS_FREDERICK:
-        return TILE_MONS_FREDERICK;
+        return TILEP_MONS_FREDERICK;
     case MONS_MARGERY:
-        return TILE_MONS_MARGERY;
+        return TILEP_MONS_MARGERY;
     case MONS_POLYPHEMUS:
-        return TILE_MONS_POLYPHEMUS;
+        return TILEP_MONS_POLYPHEMUS;
     case MONS_BORIS:
-        return TILE_MONS_BORIS;
+        return TILEP_MONS_BORIS;
     // Draconians handled above
     case MONS_MURRAY:
-        return TILE_MONS_MURRAY;
+        return TILEP_MONS_MURRAY;
     case MONS_TIAMAT:
-        return TILE_MONS_TIAMAT;
+        return TILEP_MONS_TIAMAT;
     case MONS_DEEP_ELF_BLADEMASTER:
-        return TILE_MONS_DEEP_ELF_BLADEMASTER;
+        return TILEP_MONS_DEEP_ELF_BLADEMASTER;
     case MONS_DEEP_ELF_MASTER_ARCHER:
-        return TILE_MONS_DEEP_ELF_MASTER_ARCHER;
+        return TILEP_MONS_DEEP_ELF_MASTER_ARCHER;
 
     case MONS_GERYON:
-        return TILE_MONS_GERYON;
+        return TILEP_MONS_GERYON;
     case MONS_DISPATER:
-        return TILE_MONS_DISPATER;
+        return TILEP_MONS_DISPATER;
     case MONS_ASMODEUS:
-        return TILE_MONS_ASMODEUS;
+        return TILEP_MONS_ASMODEUS;
     case MONS_ANTAEUS:
-        return TILE_MONS_ANTAEUS;
+        return TILEP_MONS_ANTAEUS;
     case MONS_ERESHKIGAL:
-        return TILE_MONS_ERESHKIGAL;
+        return TILEP_MONS_ERESHKIGAL;
 
     case MONS_ANCIENT_LICH:
-        return TILE_MONS_ANCIENT_LICH;
+        return TILEP_MONS_ANCIENT_LICH;
     case MONS_OOZE:
-        return TILE_MONS_OOZE;
+        return TILEP_MONS_OOZE;
     case MONS_VAULT_GUARD:
-        return TILE_MONS_VAULT_GUARD;
+        return TILEP_MONS_VAULT_GUARD;
     case MONS_CURSE_SKULL:
-        return TILE_MONS_CURSE_SKULL;
+        return TILEP_MONS_CURSE_SKULL;
     case MONS_VAMPIRE_KNIGHT:
-        return TILE_MONS_VAMPIRE_KNIGHT;
+        return TILEP_MONS_VAMPIRE_KNIGHT;
     case MONS_VAMPIRE_MAGE:
-        return TILE_MONS_VAMPIRE_MAGE;
+        return TILEP_MONS_VAMPIRE_MAGE;
     case MONS_SHINING_EYE:
-        return TILE_MONS_SHINING_EYE;
+        return TILEP_MONS_SHINING_EYE;
     case MONS_ORB_GUARDIAN:
-        return TILE_MONS_ORB_GUARDIAN;
+        return TILEP_MONS_ORB_GUARDIAN;
     case MONS_DAEVA:
-        return TILE_MONS_DAEVA;
+        return TILEP_MONS_DAEVA;
     case MONS_SPECTRAL_THING:
-        return TILE_MONS_SPECTRAL_THING;
+        return TILEP_MONS_SPECTRAL_THING;
     case MONS_GREATER_NAGA:
-        return TILE_MONS_GREATER_NAGA;
+        return TILEP_MONS_GREATER_NAGA;
     case MONS_SKELETAL_DRAGON:
-        return TILE_MONS_SKELETAL_DRAGON;
+        return TILEP_MONS_SKELETAL_DRAGON;
     case MONS_TENTACLED_MONSTROSITY:
-        return TILE_MONS_TENTACLED_MONSTROSITY;
+        return TILEP_MONS_TENTACLED_MONSTROSITY;
     case MONS_SPHINX:
-        return TILE_MONS_SPHINX;
+        return TILEP_MONS_SPHINX;
     case MONS_ROTTING_HULK:
-        return TILE_MONS_ROTTING_HULK;
+        return TILEP_MONS_ROTTING_HULK;
     case MONS_GUARDIAN_MUMMY:
-        return TILE_MONS_GUARDIAN_MUMMY;
+        return TILEP_MONS_GUARDIAN_MUMMY;
     case MONS_GREATER_MUMMY:
-        return TILE_MONS_GREATER_MUMMY;
+        return TILEP_MONS_GREATER_MUMMY;
     case MONS_MUMMY_PRIEST:
-        return TILE_MONS_MUMMY_PRIEST;
+        return TILEP_MONS_MUMMY_PRIEST;
     case MONS_CENTAUR_WARRIOR:
-        return TILE_MONS_CENTAUR_WARRIOR;
+        return TILEP_MONS_CENTAUR_WARRIOR;
     case MONS_YAKTAUR_CAPTAIN:
-        return TILE_MONS_YAKTAUR_CAPTAIN;
+        return TILEP_MONS_YAKTAUR_CAPTAIN;
     case MONS_KILLER_KLOWN:
-        return TILE_MONS_KILLER_KLOWN;
+        return TILEP_MONS_KILLER_KLOWN;
     case MONS_ELECTRIC_GOLEM:
-        return TILE_MONS_ELECTRIC_GOLEM;
+        return TILEP_MONS_ELECTRIC_GOLEM;
     case MONS_BALL_LIGHTNING:
-        return TILE_MONS_BALL_LIGHTNING;
+        return TILEP_MONS_BALL_LIGHTNING;
     case MONS_ORB_OF_FIRE:
-        return TILE_MONS_ORB_OF_FIRE;
+        return TILEP_MONS_ORB_OF_FIRE;
     case MONS_QUOKKA:
-        return TILE_MONS_QUOKKA;
+        return TILEP_MONS_QUOKKA;
     case MONS_EYE_OF_DEVASTATION:
-        return TILE_MONS_EYE_OF_DEVASTATION;
+        return TILEP_MONS_EYE_OF_DEVASTATION;
     case MONS_MOTH_OF_WRATH:
-        return TILE_MONS_MOTH_OF_WRATH;
+        return TILEP_MONS_MOTH_OF_WRATH;
     case MONS_DEATH_COB:
-        return TILE_MONS_DEATH_COB;
+        return TILEP_MONS_DEATH_COB;
     case MONS_CURSE_TOE:
-        return TILE_MONS_CURSE_TOE;
+        return TILEP_MONS_CURSE_TOE;
 
     case MONS_GOLD_MIMIC:
     case MONS_WEAPON_MIMIC:
@@ -810,81 +757,79 @@ static int _tileidx_monster_base(int mon_idx, bool detected)
     }
 
     case MONS_HELL_HOG:
-        return TILE_MONS_HELL_HOG;
+        return TILEP_MONS_HELL_HOG;
     case MONS_SERPENT_OF_HELL:
-        return TILE_MONS_SERPENT_OF_HELL;
+        return TILEP_MONS_SERPENT_OF_HELL;
     case MONS_BOGGART:
-        return TILE_MONS_BOGGART;
+        return TILEP_MONS_BOGGART;
     case MONS_QUICKSILVER_DRAGON:
-        return TILE_MONS_QUICKSILVER_DRAGON;
+        return TILEP_MONS_QUICKSILVER_DRAGON;
     case MONS_IRON_DRAGON:
-        return TILE_MONS_IRON_DRAGON;
+        return TILEP_MONS_IRON_DRAGON;
     case MONS_SKELETAL_WARRIOR:
-        return TILE_MONS_SKELETAL_WARRIOR;
+        return TILEP_MONS_SKELETAL_WARRIOR;
     case MONS_PLAYER_GHOST:
-        return TILE_MONS_PLAYER_GHOST;
+        return TILEP_MONS_PLAYER_GHOST;
     case MONS_PANDEMONIUM_DEMON:
-        return TILE_MONS_PANDEMONIUM_DEMON;
+        return TILEP_MONS_PANDEMONIUM_DEMON;
     case MONS_GIANT_NEWT:
-        return TILE_MONS_GIANT_NEWT;
+        return TILEP_MONS_GIANT_NEWT;
     case MONS_GIANT_GECKO:
-        return TILE_MONS_GIANT_GECKO;
+        return TILEP_MONS_GIANT_GECKO;
     case MONS_GIANT_IGUANA:
-        return TILE_MONS_GIANT_IGUANA;
+        return TILEP_MONS_GIANT_IGUANA;
     case MONS_GILA_MONSTER:
-        return TILE_MONS_GILA_MONSTER;
+        return TILEP_MONS_GILA_MONSTER;
     case MONS_KOMODO_DRAGON:
-        return TILE_MONS_KOMODO_DRAGON;
+        return TILEP_MONS_KOMODO_DRAGON;
     case MONS_LAVA_WORM:
-        return TILE_MONS_LAVA_WORM;
+        return TILEP_MONS_LAVA_WORM;
     case MONS_LAVA_FISH:
-        return TILE_MONS_LAVA_FISH;
+        return TILEP_MONS_LAVA_FISH;
     case MONS_LAVA_SNAKE:
-        return TILE_MONS_LAVA_SNAKE;
+        return TILEP_MONS_LAVA_SNAKE;
     case MONS_SALAMANDER:
-        return TILE_MONS_SALAMANDER;
+        return TILEP_MONS_SALAMANDER;
     case MONS_BIG_FISH:
-        return TILE_MONS_BIG_FISH;
+        return TILEP_MONS_BIG_FISH;
     case MONS_GIANT_GOLDFISH:
-        return TILE_MONS_GIANT_GOLDFISH;
+        return TILEP_MONS_GIANT_GOLDFISH;
     case MONS_ELECTRICAL_EEL:
-        return TILE_MONS_ELECTRICAL_EEL;
+        return TILEP_MONS_ELECTRICAL_EEL;
     case MONS_JELLYFISH:
-        return TILE_MONS_JELLYFISH;
+        return TILEP_MONS_JELLYFISH;
     case MONS_WATER_ELEMENTAL:
-        return TILE_MONS_WATER_ELEMENTAL;
+        return TILEP_MONS_WATER_ELEMENTAL;
     case MONS_SWAMP_WORM:
-        return TILE_MONS_SWAMP_WORM;
+        return TILEP_MONS_SWAMP_WORM;
     case MONS_ROCK_WORM:
-        return TILE_MONS_ROCK_WORM;
+        return TILEP_MONS_ROCK_WORM;
     case MONS_ORANGE_STATUE:
-        return TILE_DNGN_ORANGE_CRYSTAL_STATUE;
+        return TILEP_ORANGE_CRYSTAL_STATUE;
     case MONS_SILVER_STATUE:
-        return TILE_DNGN_SILVER_STATUE;
+        return TILEP_SILVER_STATUE;
     case MONS_ICE_STATUE:
-        return TILE_DNGN_ICE_STATUE;
+        return TILEP_ICE_STATUE;
     case MONS_DEATH_DRAKE:
-        return TILE_MONS_DEATH_DRAKE;
+        return TILEP_MONS_DEATH_DRAKE;
     case MONS_MERFOLK:
         if (in_water)
-            return TILE_MONS_MERFOLK_FIGHTER_WATER;
+            return TILEP_MONS_MERFOLK_FIGHTER_WATER;
         else
-            return TILE_MONS_MERFOLK_FIGHTER;
+            return TILEP_MONS_MERFOLK_FIGHTER;
     case MONS_MERMAID:
         if (in_water)
-            return TILE_MONS_MERMAID_WATER;
+            return TILEP_MONS_MERMAID_WATER;
         else
-            return TILE_MONS_MERMAID;
+            return TILEP_MONS_MERMAID;
     }
 
     return TILE_ERROR;
 }
 
-static int _tileidx_monster(int mon_idx, bool detected)
+int tileidx_monster(const monsters *mons, bool detected)
 {
-    ASSERT(mon_idx != -1);
-    int ch = _tileidx_monster_base(mon_idx, detected);
-    const monsters* mons = &menv[mon_idx];
+    int ch = _tileidx_monster_base(mons, detected);
 
     if (mons_flies(mons))
         ch |= TILE_FLAG_FLYING;
@@ -912,6 +857,13 @@ static int _tileidx_monster(int mon_idx, bool detected)
     return ch;
 }
 
+static int _tileidx_monster(int mon_idx, bool detected)
+{
+    ASSERT(mon_idx != -1);
+    const monsters* mons = &menv[mon_idx];
+    return tileidx_monster(mons, detected);
+}
+
 static int _tileidx_fixed_artefact(int special)
 {
   switch(special)
@@ -2276,19 +2228,19 @@ static int _tileidx_cloud(int type, int decay)
 
 int tileidx_player(int job)
 {
-    int ch = TILE_PLAYER;
+    int ch = TILEP_PLAYER;
 
     // Handle shapechange first
     switch (you.symbol)
     {
-        case 's': ch = TILE_MONS_WOLF_SPIDER; break;
-        case 'I': ch = TILE_MONS_ICE_BEAST;   break;
-        case '8': ch = TILE_MONS_STONE_GOLEM; break;
-        case 'D': ch = TILE_MONS_DRAGON;      break;
-        case 'L': ch = TILE_MONS_LICH;        break;
-        case '#': ch = TILE_MONS_VAPOUR;      break;
-        case 'S': ch = TILE_MONS_LAVA_SNAKE;  break;
-        case 'b': ch = TILE_MONS_GIANT_BAT;   break;
+        case 's': ch = TILEP_MONS_WOLF_SPIDER; break;
+        case 'I': ch = TILEP_MONS_ICE_BEAST;   break;
+        case '8': ch = TILEP_MONS_STONE_GOLEM; break;
+        case 'D': ch = TILEP_MONS_DRAGON;      break;
+        case 'L': ch = TILEP_MONS_LICH;        break;
+        case '#': ch = TILEP_MONS_VAPOUR;      break;
+        case 'S': ch = TILEP_MONS_LAVA_SNAKE;  break;
+        case 'b': ch = TILEP_MONS_GIANT_BAT;   break;
     }
 
     if (player_is_airborne())
@@ -2349,7 +2301,7 @@ int tileidx_unseen(int ch, const coord_def& gc)
         case '+': res =  TILE_BOOK_PAPER_OFFSET + 15; break;
 
         case '/': res = TILE_WAND_OFFSET; break;
-        case '8': res = TILE_DNGN_SILVER_STATUE; break;
+        case '8': res = TILEP_SILVER_STATUE; break;
         case '<': res = TILE_DNGN_STONE_STAIRS_UP; break;
         case '=': res = TILE_RING_NORMAL_OFFSET + 1; break;
         case '>': res = TILE_DNGN_STONE_STAIRS_DOWN; break;
@@ -2431,7 +2383,7 @@ static inline void _finalize_tile(unsigned int *tile, bool is_special,
              || orig == TILE_DNGN_LAVA
              || orig == TILE_DNGN_STONE_WALL)
     {
-        (*tile) = orig + (special_flv % tile_dngn_count[orig]);
+        (*tile) = orig + (special_flv % tile_dngn_count(orig));
     }
     else if (orig == TILE_DNGN_CLOSED_DOOR || orig == TILE_DNGN_OPEN_DOOR)
     {
@@ -2442,7 +2394,7 @@ static inline void _finalize_tile(unsigned int *tile, bool is_special,
     (*tile) |= flag;
 }
 
-void tilep_calc_flags(int parts[], int flag[])
+void tilep_calc_flags(const int parts[], int flag[])
 {
     int i;
 
@@ -4034,7 +3986,7 @@ void tile_place_item_bk(int gx, int gy, int idx)
 
 void tile_place_tile_bk(int gx, int gy, int tileidx)
 {
-    env.tile_bk_fg[gx][gy] = get_base_idx_from_mcache(tileidx);
+    env.tile_bk_fg[gx][gy] = tileidx;
 }
 
 // Called from item() in view.cc
@@ -4058,7 +4010,6 @@ void tile_place_monster(int gx, int gy, int idx, bool foreground, bool detected)
     int t  = _tileidx_monster(idx, detected);
     int t0 = t & TILE_FLAG_MASK;
     int flag = t & (~TILE_FLAG_MASK);
-    int mon_wep = menv[idx].inv[MSLOT_WEAPON];
 
     if (mons_is_mimic(menv[idx].type))
     {
@@ -4096,120 +4047,34 @@ void tile_place_monster(int gx, int gy, int idx, bool foreground, bool detected)
                 t0 |= TILE_FLAG_S_UNDER;
         }
     }
-    else if (menv[idx].type >=  MONS_DRACONIAN &&
-             menv[idx].type <= MONS_DRACONIAN_SCORCHER)
-    {
-        int race = draco_subspecies(&menv[idx]);
-        int cls = menv[idx].type;
-        int eq = 0;
-        if (mon_wep != NON_ITEM &&
-            (cls == race || cls == MONS_DRACONIAN_KNIGHT))
-        {
-            eq = tilep_equ_weapon(mitm[mon_wep]);
-        }
-        t = flag | _mcache_register(cls, eq, race);
-    }
-    else if (mon_wep != NON_ITEM)
+    else
     {
-        int eq = tilep_equ_weapon(mitm[mon_wep]);
-        switch(t0)
-        {
-            // 3D chars
-            case TILE_MONS_VAULT_GUARD:
-
-            case TILE_MONS_BLORK_THE_ORC:
-            case TILE_MONS_ORC:
-            case TILE_MONS_ORC_KNIGHT:
-            case TILE_MONS_ORC_WARLORD:
-            case TILE_MONS_ORC_WARRIOR:
-            case TILE_MONS_URUG:
-
-            case TILE_MONS_GOBLIN:
-            case TILE_MONS_IJYB:
-            case TILE_MONS_HOBGOBLIN:
-            case TILE_MONS_GNOLL:
-            case TILE_MONS_BOGGART:
-
-            case TILE_MONS_KOBOLD:
-            case TILE_MONS_KOBOLD_DEMONOLOGIST:
-            case TILE_MONS_BIG_KOBOLD:
-
-            case TILE_MONS_DEEP_ELF_FIGHTER:
-            case TILE_MONS_DEEP_ELF_SOLDIER:
-            case TILE_MONS_DEEP_ELF_KNIGHT:
-            case TILE_MONS_DEEP_ELF_BLADEMASTER:
-            case TILE_MONS_DEEP_ELF_MASTER_ARCHER:
-            case TILE_MONS_DEEP_ELF_MAGE:
-            case TILE_MONS_DEEP_ELF_SUMMONER:
-            case TILE_MONS_DEEP_ELF_CONJURER:
-            case TILE_MONS_DEEP_ELF_PRIEST:
-            case TILE_MONS_DEEP_ELF_HIGH_PRIEST:
-            case TILE_MONS_DEEP_ELF_DEMONOLOGIST:
-            case TILE_MONS_DEEP_ELF_ANNIHILATOR:
-            case TILE_MONS_DEEP_ELF_SORCERER:
-            case TILE_MONS_DEEP_ELF_DEATH_MAGE:
-
-            case TILE_MONS_MIDGE:
-            case TILE_MONS_IMP:
-
-            case TILE_MONS_NAGA:
-            case TILE_MONS_GREATER_NAGA:
-            case TILE_MONS_NAGA_WARRIOR:
-            case TILE_MONS_NAGA_MAGE:
-
-            case TILE_MONS_OGRE_MAGE:
-            case TILE_MONS_RED_DEVIL:
-            case TILE_MONS_WIZARD:
-            case TILE_MONS_HUMAN:
-            case TILE_MONS_ELF:
-
-            case TILE_MONS_ANGEL:
-
-            case TILE_MONS_HELL_KNIGHT:
-
-            case TILE_MONS_NORRIS:
-            case TILE_MONS_MAUD:
-            case TILE_MONS_DUANE:
-            case TILE_MONS_EDMUND:
-            case TILE_MONS_FRANCES:
-            case TILE_MONS_HAROLD:
-            case TILE_MONS_JOSEPH:
-            case TILE_MONS_JOZEF:
-            case TILE_MONS_RUPERT:
-            case TILE_MONS_TERENCE:
-            case TILE_MONS_WAYNE:
-            case TILE_MONS_FREDERICK:
-
-            case TILE_MONS_RAKSHASA:
-            case TILE_MONS_RAKSHASA_FAKE:
-
-            case TILE_MONS_VAMPIRE_KNIGHT:
-
-            case TILE_MONS_SKELETAL_WARRIOR:
-            case TILE_MONS_MERMAID:
-            case TILE_MONS_MERMAID_WATER:
-            case TILE_MONS_MERFOLK_FIGHTER:
-            case TILE_MONS_MERFOLK_FIGHTER_WATER:
-
-            if (eq != 0 )
-                t = flag | _mcache_register(t0, eq);
-            break;
-
-        }
+        unsigned int mcache_idx = mcache.register_monster(&menv[idx]);
+        t = flag | (mcache_idx ? mcache_idx : t0);
     }
 
     if (foreground)
     {
         env.tile_fg[ep.x-1][ep.y-1] = t;
-        if (menv[idx].is_named() && !mons_friendly(&menv[idx]))
+        if (menv[idx].is_named() && !mons_friendly(&menv[idx])
+            && menv[idx].type != MONS_PANDEMONIUM_DEMON)
         {
-            tiles.add_text_tag(TAG_NAMED_MONSTER,
-                               menv[idx].name(DESC_CAP_A), gc);
+            if (menv[idx].type == MONS_PLAYER_GHOST)
+            {
+                // Beautification hack.  "Foo's ghost" is a little bit
+                // verbose as a tag.  "Foo" on its own should be sufficient.
+                tiles.add_text_tag(TAG_NAMED_MONSTER, menv[idx].mname, gc);
+            }
+            else
+            {
+                tiles.add_text_tag(TAG_NAMED_MONSTER,
+                                   menv[idx].name(DESC_CAP_A), gc);
+            }
         }
     }
     else
     {
-        env.tile_bk_fg[gc.x][gc.y] = get_base_idx_from_mcache(t0);
+        env.tile_bk_fg[gc.x][gc.y] = t0;
     }
 }
 
diff --git a/crawl-ref/source/tilereg.cc b/crawl-ref/source/tilereg.cc
index 972856f93d..fa27a506bb 100644
--- a/crawl-ref/source/tilereg.cc
+++ b/crawl-ref/source/tilereg.cc
@@ -31,6 +31,7 @@
 #include "tiles.h"
 #include "tilefont.h"
 #include "tilesdl.h"
+#include "tilemcache.h"
 
 #include <SDL_opengl.h>
 
@@ -281,7 +282,7 @@ void DungeonRegion::draw_background(unsigned int bg, unsigned int x, unsigned in
     if (bg & TILE_FLAG_BLOOD)
     {
         tile_flavour &flv = env.tile_flv[x + m_cx_to_gx][y + m_cy_to_gy];
-        unsigned int offset = flv.special % tile_dngn_count[TILE_BLOOD];
+        unsigned int offset = flv.special % tile_dngn_count(TILE_BLOOD);
         add_quad(TEX_DUNGEON, TILE_BLOOD + offset, x, y);
     }
 
@@ -426,31 +427,8 @@ void DungeonRegion::draw_player(unsigned int x, unsigned int y)
     draw_doll(result, x, y);
 }
 
-bool DungeonRegion::draw_objects(unsigned int fg, unsigned int x, unsigned int y)
-{
-    unsigned int fg_idx = fg & TILE_FLAG_MASK;
-
-    // handled elsewhere
-    if (fg_idx == TILE_PLAYER)
-        return false;
-
-    int equ_tile;
-    int draco;
-    int mon_tile;
-    if (get_mcache_entry(fg_idx, mon_tile, equ_tile, draco))
-    {
-        if (!draco)
-            add_quad(TEX_DEFAULT, get_base_idx_from_mcache(fg_idx), x, y);
-        return true;
-    }
-    else if (fg_idx)
-    {
-        add_quad(TEX_DEFAULT, fg_idx, x, y);
-    }
-    return false;
-}
-
-void DungeonRegion::draw_doll(dolls_data &doll, unsigned int x, unsigned int y)
+void DungeonRegion::draw_doll(const dolls_data &doll, unsigned int x,
+                              unsigned int y)
 {
     int p_order[TILEP_PART_MAX] =
     {
@@ -499,152 +477,31 @@ void DungeonRegion::draw_doll(dolls_data &doll, unsigned int x, unsigned int y)
     }
 }
 
-void DungeonRegion::draw_draco(int colour, int mon_idx, int equ_tile, unsigned int x, unsigned int y)
+void DungeonRegion::draw_mcache(mcache_entry *entry, unsigned int x, unsigned int y)
 {
-    dolls_data doll;
-
-    int armour = 0;
-    int armour2 = 0;
-    int weapon = 0;
-    int weapon2 = 0;
-    int arm = 0;
-
-    for (int i = 0; i < TILEP_PART_MAX; i++)
-         doll.parts[i] = 0;
-
-    doll.parts[TILEP_PART_SHADOW] = TILEP_SHADOW_SHADOW;
-    doll.parts[TILEP_PART_BASE] = TILEP_BASE_DRACONIAN + colour * 2;
-    doll.parts[TILEP_PART_DRCWING] = tile_player_part_start[TILEP_PART_DRCWING] 
-                                     + colour;
-    doll.parts[TILEP_PART_DRCHEAD] = tile_player_part_start[TILEP_PART_DRCHEAD]
-                                     + colour;
-
-    switch (mon_idx)
-    {
-        case MONS_DRACONIAN_CALLER:
-            weapon = TILEP_HAND1_STAFF_EVIL;
-            weapon2 = TILEP_HAND2_BOOK_YELLOW;
-            armour = TILEP_BODY_ROBE_BROWN;
-            break;
-
-        case MONS_DRACONIAN_MONK:
-            arm = TILEP_ARM_GLOVE_SHORT_BLUE;
-            armour = TILEP_BODY_KARATE2;
-            break;
-
-        case MONS_DRACONIAN_ZEALOT:
-            weapon = TILEP_HAND1_MACE;
-            weapon2 = TILEP_HAND2_BOOK_CYAN;
-            armour = TILEP_BODY_MONK_BLUE;
-            break;
-
-        case MONS_DRACONIAN_SHIFTER:
-            weapon = TILEP_HAND1_STAFF_LARGE;
-            armour = TILEP_BODY_ROBE_CYAN;
-            weapon2 = TILEP_HAND2_BOOK_GREEN;
-            break;
+    ASSERT(entry);
 
-        case MONS_DRACONIAN_ANNIHILATOR:
-            weapon = TILEP_HAND1_STAFF_RUBY;
-            weapon2 = TILEP_HAND2_FIRE_CYAN;
-            armour = TILEP_BODY_ROBE_GREEN_GOLD;
-            break;
-
-        case MONS_DRACONIAN_KNIGHT:
-            weapon = equ_tile;
-            weapon2 = TILEP_HAND2_SHIELD_KNIGHT_GRAY;
-            armour = TILEP_BODY_BPLATE_METAL1;
-            armour2 = TILEP_LEG_BELT_GRAY;
-            break;
-
-        case MONS_DRACONIAN_SCORCHER:
-            weapon = TILEP_HAND1_FIRE_RED;
-            weapon2 = TILEP_HAND2_BOOK_RED;
-            armour = TILEP_BODY_ROBE_RED;
-            break;
-
-        default:
-            weapon = equ_tile;
-            armour = TILEP_BODY_BELT2;
-            armour2 = TILEP_LEG_LOINCLOTH_RED;
-            break;
-    }
+    const dolls_data *doll = entry->doll();
+    if (doll)
+        draw_doll(*doll, x, y);
 
-    doll.parts[TILEP_PART_HAND1] = weapon;
-    doll.parts[TILEP_PART_HAND2] = weapon2;
-    doll.parts[TILEP_PART_BODY]  = armour;
-    doll.parts[TILEP_PART_LEG]   = armour2;
-    doll.parts[TILEP_PART_ARM]   = arm;
+    tile_draw_info dinfo[3];
+    unsigned int draw_info_count = entry->info(&dinfo[0]);
+    ASSERT(draw_info_count <= sizeof(dinfo) / (sizeof(dinfo[0])));
 
-    draw_doll(doll, x, y);
+    for (unsigned int i = 0; i < draw_info_count; i++)
+        add_quad(TEX_DOLL, dinfo[i].idx, x, y, dinfo[i].ofs_x, dinfo[i].ofs_y);
 }
 
-void DungeonRegion::draw_monster(unsigned int fg, unsigned int x, unsigned int y)
+void DungeonRegion::draw_foreground(unsigned int bg, unsigned int fg, unsigned int x, unsigned int y)
 {
-    // Currently, monsters only get displayed weapons (no armour)
     unsigned int fg_idx = fg & TILE_FLAG_MASK;
-    if (fg_idx < TILE_MCACHE_START)
-        return;
-
-    int equ_tile;
-    int draco;
-    int mon_tile;
-
-    if (!get_mcache_entry(fg_idx, mon_tile, equ_tile, draco))
-        return;
+    unsigned int bg_idx = bg & TILE_FLAG_MASK;
 
-    if (draco == 0)
+    if (fg_idx && fg_idx <= TILE_MAIN_MAX)
     {
-        int ofs_x, ofs_y;
-        tile_get_monster_weapon_offset(mon_tile, ofs_x, ofs_y);
-
-        add_quad(TEX_DOLL, equ_tile, x, y, ofs_x, ofs_y, true, TILE_Y);
-
-        // In some cases, overlay a second weapon tile...
-        if (mon_tile == TILE_MONS_DEEP_ELF_BLADEMASTER)
-        {
-            int eq2;
-            switch (equ_tile)
-            {
-                case TILEP_HAND1_DAGGER:
-                    eq2 = TILEP_HAND2_DAGGER;
-                    break;
-                case TILEP_HAND1_SABRE:
-                    eq2 = TILEP_HAND2_SABRE;
-                    break;
-                default:
-                case TILEP_HAND1_SHORT_SWORD_SLANT:
-                    eq2 = TILEP_HAND2_SHORT_SWORD_SLANT;
-                    break;
-            };
-            add_quad(TEX_DOLL, eq2, x, y, -ofs_x, ofs_y, true, TILE_Y);
-        }
-    }
-    else
-    {
-        int colour;
-        switch (draco)
-        {
-        default:
-        case MONS_DRACONIAN:        colour = 0; break;
-        case MONS_BLACK_DRACONIAN:  colour = 1; break;
-        case MONS_YELLOW_DRACONIAN: colour = 2; break;
-        case MONS_GREEN_DRACONIAN:  colour = 4; break;
-        case MONS_MOTTLED_DRACONIAN:colour = 5; break;
-        case MONS_PALE_DRACONIAN:   colour = 6; break;
-        case MONS_PURPLE_DRACONIAN: colour = 7; break;
-        case MONS_RED_DRACONIAN:    colour = 8; break;
-        case MONS_WHITE_DRACONIAN:  colour = 9; break;
-        }
-
-        draw_draco(colour, mon_tile, equ_tile, x, y);
+        add_quad(TEX_DEFAULT, fg_idx, x, y);
     }
-}
-
-void DungeonRegion::draw_foreground(unsigned int bg, unsigned int fg, unsigned int x, unsigned int y)
-{
-    unsigned int fg_idx = fg & TILE_FLAG_MASK;
-    unsigned int bg_idx = bg & TILE_FLAG_MASK;
 
     if (fg_idx && !(fg & TILE_FLAG_FLYING))
     {
@@ -786,47 +643,30 @@ void DungeonRegion::render()
     tile = 0;
     m_verts.clear();
 
-    int player_x = -1;
-    int player_y = -1;
-    bool need_doll = false;
     for (int y = 0; y < crawl_view.viewsz.y; y++)
+    {
         for (int x = 0; x < crawl_view.viewsz.x; x++)
         {
-            unsigned int fg = m_tileb[tile];
-            need_doll |= draw_objects(fg, x, y);
-
-            if ((fg & TILE_FLAG_MASK) == TILE_PLAYER)
+            unsigned int fg = m_tileb[tile] & TILE_FLAG_MASK;
+            if (fg >= TILEP_MCACHE_START)
             {
-                player_x = x;
-                player_y = y;
+                mcache_entry *entry = mcache.get(fg);
+                if (entry)
+                    draw_mcache(entry, x, y);
+                else
+                    add_quad(TEX_DOLL, TILEP_MONS_UNKNOWN, x, y);
+            }
+            else if (fg == TILEP_PLAYER)
+            {
+                draw_player(x, y);
+            }
+            else if (fg >= TILE_MAIN_MAX)
+            {
+                add_quad(TEX_DOLL, fg, x, y);
             }
 
             tile += 2;
         }
-
-    if (m_verts.size() > 0)
-    {
-        m_image->m_textures[TEX_DEFAULT].bind();
-        glVertexPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].pos_x);
-        glTexCoordPointer(2, GL_FLOAT, sizeof(tile_vert), &m_verts[0].tex_x);
-        glDrawArrays(GL_QUADS, 0, m_verts.size());
-    }
-
-    tile = 0;
-    m_verts.clear();
-    if (player_x != -1)
-        draw_player(player_x, player_y);
-
-    if (need_doll)
-    {
-        for (int y = 0; y < crawl_view.viewsz.y; y++)
-            for (int x = 0; x < crawl_view.viewsz.x; x++)
-            {
-                unsigned int fg = m_tileb[tile];
-                draw_monster(fg, x, y);
-
-                tile += 2;
-            }
     }
 
     if (m_verts.size() > 0)
@@ -2394,8 +2234,8 @@ bool ImageManager::load_textures()
     if (!m_textures[TEX_TITLE].load_texture("title.png", mip))
         return false;
 
-    m_textures[TEX_DUNGEON].set_info(TILE_DNGN_MAX, &tile_dngn_info[0]);
-    m_textures[TEX_DOLL].set_info(TILEP_PLAYER_MAX, &tile_player_info[0]);
+    m_textures[TEX_DUNGEON].set_info(TILE_DNGN_MAX, &tile_dngn_info);
+    m_textures[TEX_DOLL].set_info(TILEP_PLAYER_MAX, &tile_player_info);
 
     return true;
 }
@@ -2469,8 +2309,8 @@ static void _copy_into(unsigned char *dest, unsigned char *pixels,
 static bool _copy_under(unsigned char *pixels, unsigned int width,
                         unsigned int height, int idx_under, int idx_over)
 {
-    const tile_info &under = tile_main_info[idx_under];
-    const tile_info &over = tile_main_info[idx_over];
+    const tile_info &under = tile_main_info(idx_under);
+    const tile_info &over = tile_main_info(idx_over);
 
     if (over.width != under.width || over.height != under.height)
         return false;
@@ -2547,7 +2387,7 @@ bool ImageManager::load_item_texture()
     GenericTexture::MipMapOptions mip = GenericTexture::MIPMAP_CREATE;
     bool success = m_textures[TEX_DEFAULT].load_texture("main.png", mip, 
                                                         &_process_item_image);
-    m_textures[TEX_DEFAULT].set_info(TILE_MAIN_MAX, &tile_main_info[0]);
+    m_textures[TEX_DEFAULT].set_info(TILE_MAIN_MAX, tile_main_info);
 
     return success;
 }
diff --git a/crawl-ref/source/tilereg.h b/crawl-ref/source/tilereg.h
index 31b7728f0b..74a14b42e8 100644
--- a/crawl-ref/source/tilereg.h
+++ b/crawl-ref/source/tilereg.h
@@ -12,6 +12,7 @@
 #include "tiletex.h"
 #include "tiles.h"
 #include <vector>
+class mcache_entry;
 
 class ImageManager
 {
@@ -246,12 +247,10 @@ public:
 
 protected:
     void draw_background(unsigned int bg, unsigned int x, unsigned int y);
-    bool draw_objects(unsigned int fg, unsigned int x, unsigned int y);
+    void draw_mcache(mcache_entry *entry, unsigned int x, unsigned int y);
     void draw_player(unsigned int x, unsigned int y);
-    void draw_monster(unsigned int fg, unsigned int x, unsigned int y);
     void draw_foreground(unsigned int bg, unsigned int fg, unsigned int x, unsigned int y);
-    void draw_doll(dolls_data &doll, unsigned int x, unsigned int y);
-    void draw_draco(int colour, int mon_idx, int equ_tile, unsigned int x, unsigned int y);
+    void draw_doll(const dolls_data &doll, unsigned int x, unsigned int y);
     void draw_cursor(cursor_type type, unsigned int tile);
 
     int get_buffer_index(const coord_def &gc);
diff --git a/crawl-ref/source/tiles.h b/crawl-ref/source/tiles.h
index 7fa011ed17..77978a8e3b 100644
--- a/crawl-ref/source/tiles.h
+++ b/crawl-ref/source/tiles.h
@@ -11,12 +11,17 @@
 #ifdef USE_TILE
 
 #include "tiledef-main.h"
-#include "tiledef-demon.h"
 #include "tiledef-dngn.h"
 #include "tiledef-player.h"
 
 #include "beam.h"
 
+enum tag_version
+{
+    TILETAG_PRE_MCACHE = 71,
+    TILETAG_CURRENT = 72 
+};
+
 struct dolls_data
 {
     dolls_data() { memset(parts, 0, sizeof(parts)); }
@@ -24,6 +29,15 @@ struct dolls_data
     int parts[TILEP_PART_MAX];
 };
 
+struct demon_data
+{
+    demon_data() { head = body = wings = 0; }
+
+    int head;
+    int body;
+    int wings;
+};
+
 //*tile1.cc: get data from core part and drives tile drawing codes
 
 //**convert in-game data to tile index
@@ -37,11 +51,12 @@ int tileidx_bolt(const bolt &bolt);
 int tileidx_zap(int colour);
 int tile_idx_unseen_terrain(int x, int y, int what);
 int tile_unseen_flag(const coord_def& gc);
+int tileidx_monster(const monsters *mon, bool detected);
 
 // Player tile related
 void tilep_race_default(int race, int gender, int level, int *parts);
 void tilep_job_default(int job, int gender, int *parts);
-void tilep_calc_flags(int parts[], int flag[]);
+void tilep_calc_flags(const int parts[], int flag[]);
 
 void tilep_part_to_str(int number, char *buf);
 int  tilep_str_to_part(char *str);
@@ -104,12 +119,6 @@ void TileNewLevel(bool first_time);
 
 // edit player tile
 void TilePlayerEdit();
-// init ghost tile
-void TileGhostInit(const struct ghost_demon &gs);
-// init pandem demon tile (only in iso mode)
-void TilePandemInit(struct ghost_demon &gs);
-// edit pandem tile (debug)
-void TileEditPandem();
 
 int item_unid_type(const item_def &item);
 
@@ -118,11 +127,6 @@ void TileLoadWall(bool wizard);
 
 void TileDrawTitle();
 
-// monster+weapon tile
-void tile_mcache_unlock();
-int get_base_idx_from_mcache(int tile_idx);
-void tile_get_monster_weapon_offset(int mon_tile, int &ofs_x, int &ofs_y);
-bool get_mcache_entry(int tile_idx, int &mon_idx, int &equ_tile, int &draco);
 int get_clean_map_idx(int tile_idx);
 
 /* Flags for drawing routines */
@@ -169,15 +173,14 @@ enum
     TILEI_FLAG_CURSOR = 0x2000
 };
 
-#define TILEP_SHOW_EQUIP  0x1000
-
-#define TILEP_GENDER_MALE   0
-#define TILEP_GENDER_FEMALE 1
-
-#define TILEP_M_DEFAULT   0
-#define TILEP_M_LOADING   1
+enum
+{
+    TILEP_GENDER_MALE = 0,
+    TILEP_GENDER_FEMALE = 1,
+    TILEP_SHOW_EQUIP = 0x1000
+};
 
-enum TilePlayerFlagCut
+enum tile_player_flag_cut
 {
     TILEP_FLAG_HIDE,
     TILEP_FLAG_NORMAL,
@@ -185,16 +188,12 @@ enum TilePlayerFlagCut
     TILEP_FLAG_CUT_NAGA
 };
 
-#ifdef TILEP_DEBUG
-const char *get_ctg_name(int part);
-int get_ctg_idx(char *name);
-const char *get_parts_name(int part, int idx);
-int get_parts_idx(int part, char *name);
-#endif
-
 // normal tile size in px
-#define TILE_X 32
-#define TILE_Y 32
+enum
+{
+    TILE_X = 32,
+    TILE_Y = 32
+};
 
 #endif // USE_TILES
 #endif
diff --git a/crawl-ref/source/tiletex.cc b/crawl-ref/source/tiletex.cc
index b8d80d9704..c1a7ce63c4 100644
--- a/crawl-ref/source/tiletex.cc
+++ b/crawl-ref/source/tiletex.cc
@@ -240,14 +240,14 @@ void GenericTexture::bind()
 }
 
 TilesTexture::TilesTexture() :
-    GenericTexture(), m_tile_max(0), m_tile_info(NULL)
+    GenericTexture(), m_tile_max(0), m_info_func(NULL)
 {
 
 }
 
-void TilesTexture::set_info(int _max, tile_info *_info)
+void TilesTexture::set_info(int tile_max, tile_info_func *info_func)
 {
-    m_tile_max = _max;
-    m_tile_info = _info;
+    m_tile_max = tile_max;
+    m_info_func = info_func;
 }
 
diff --git a/crawl-ref/source/tiletex.h b/crawl-ref/source/tiletex.h
index 8d90803ef0..0003395bc8 100644
--- a/crawl-ref/source/tiletex.h
+++ b/crawl-ref/source/tiletex.h
@@ -56,7 +56,7 @@ class TilesTexture : public GenericTexture
 public:
     TilesTexture();
 
-    void set_info(int max, tile_info *info);
+    void set_info(int max, tile_info_func *info);
     inline const tile_info &get_info(int idx);
     inline void get_coords(int idx, int ofs_x, int ofs_y,
                            float &pos_sx, float &pos_sy,
@@ -67,13 +67,12 @@ public:
 
 protected:
     int m_tile_max;
-    tile_info *m_tile_info;
+    tile_info_func *m_info_func;
 };
 
 inline const tile_info &TilesTexture::get_info(int idx)
 {
-    assert(idx < m_tile_max);
-    return m_tile_info[idx];
+    return m_info_func(idx);
 }
 
 inline void TilesTexture::get_coords(int idx, int ofs_x, int ofs_y,
diff --git a/crawl-ref/source/view.cc b/crawl-ref/source/view.cc
index 1500009a16..113b9f55f4 100644
--- a/crawl-ref/source/view.cc
+++ b/crawl-ref/source/view.cc
@@ -73,6 +73,7 @@
 #include "tiles.h"
 #include "state.h"
 #include "terrain.h"
+#include "tilemcache.h"
 #include "tilesdl.h"
 #include "travel.h"
 #include "tutorial.h"
@@ -4823,7 +4824,7 @@ void viewwindow(bool draw_it, bool do_updates)
 
 #ifdef USE_TILE
     tile_draw_floor();
-    tile_mcache_unlock();
+    mcache.clear_nonref();
 #endif
 
     env.show_col.init(LIGHTGREY);
@@ -5010,8 +5011,7 @@ void viewwindow(bool draw_it, bool do_updates)
                             else
                             {
                                 env.tile_bk_fg[gc.x][gc.y] =
-                                    get_base_idx_from_mcache(
-                                    env.tile_fg[ep.x-1][ep.y-1]);
+                                    env.tile_fg[ep.x-1][ep.y-1];
                             }
                             env.tile_bk_bg[gc.x][gc.y] =
                                 env.tile_bg[ep.x-1][ep.y-1];