#include "tilemcache.h"

    tile_mcache_unlock();

    mcache.clear_nonref();

                                    get_base_idx_from_mcache(
                                    env.tile_fg[ep.x-1][ep.y-1]);

                                    env.tile_fg[ep.x-1][ep.y-1];

    void set_info(int max, tile_info *info);

    void set_info(int max, tile_info_func *info);

    tile_info *m_tile_info;

    tile_info_func *m_info_func;

    assert(idx < m_tile_max);
    return m_tile_info[idx];

    return m_info_func(idx);

    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;

#include "tiledef-demon.h"

enum tag_version
{
    TILETAG_PRE_MCACHE = 71,
    TILETAG_CURRENT = 72 
};

};
struct demon_data
{
    demon_data() { head = body = wings = 0; }
    int head;
    int body;
    int wings;

int tileidx_monster(const monsters *mon, bool detected);

void tilep_calc_flags(int parts[], int flag[]);

void tilep_calc_flags(const int parts[], int flag[]);

// 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();

// 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);

#define TILEP_SHOW_EQUIP  0x1000

enum
{
    TILEP_GENDER_MALE = 0,
    TILEP_GENDER_FEMALE = 1,
    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 TilePlayerFlagCut

enum tile_player_flag_cut

#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

#define TILE_X 32
#define TILE_Y 32

enum
{
    TILE_X = 32,
    TILE_Y = 32
};

class mcache_entry;

    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_monster(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);

#include "tilemcache.h"

        unsigned int offset = flv.special % tile_dngn_count[TILE_BLOOD];

        unsigned int offset = flv.special % tile_dngn_count(TILE_BLOOD);

}
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)

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;

    ASSERT(entry);

    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;

    const dolls_data *doll = entry->doll();
    if (doll)
        draw_doll(*doll, x, y);

    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;

    tile_draw_info dinfo[3];
    unsigned int draw_info_count = entry->info(&dinfo[0]);
    ASSERT(draw_info_count <= sizeof(dinfo) / (sizeof(dinfo[0])));

    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;
        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;
    }
    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;
    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)

    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;
    if (draco == 0)
    {
        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);

    unsigned int bg_idx = bg & TILE_FLAG_MASK;

        // 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

    if (fg_idx && fg_idx <= TILE_MAIN_MAX)

        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;

    int player_x = -1;
    int player_y = -1;
    bool need_doll = false;

    {

            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);
            }

    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;
            }
    }

    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);

    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);

    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);

#include "tilemcache.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 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];

        return TILE_MONS_GIANT_ANT;

        return TILEP_MONS_GIANT_ANT;

        return TILE_MONS_GIANT_BAT;

        return TILEP_MONS_GIANT_BAT;

        return TILE_MONS_CENTAUR;

        return TILEP_MONS_CENTAUR;

        return TILE_MONS_RED_DEVIL;

        return TILEP_MONS_RED_DEVIL;

        return TILE_MONS_ETTIN;

        return TILEP_MONS_ETTIN;

        return TILE_MONS_FUNGUS;

        return TILEP_MONS_FUNGUS;

        return TILE_MONS_GOBLIN;

        return TILEP_MONS_GOBLIN;

        return TILE_MONS_HOUND;

        return TILEP_MONS_HOUND;

        return TILE_MONS_IMP;

        return TILEP_MONS_IMP;

        return TILE_MONS_JACKAL;

        return TILEP_MONS_JACKAL;

        return TILE_MONS_KILLER_BEE;

        return TILEP_MONS_KILLER_BEE;

        return TILE_MONS_KILLER_BEE_LARVA;

        return TILEP_MONS_KILLER_BEE_LARVA;

        return TILE_MONS_MANTICORE;

        return TILEP_MONS_MANTICORE;

        return TILE_MONS_NECROPHAGE;

        return TILEP_MONS_NECROPHAGE;

        return TILE_MONS_ORC;

        return TILEP_MONS_ORC;

        return TILE_MONS_PHANTOM;

        return TILEP_MONS_PHANTOM;

        return TILE_MONS_QUASIT;

        return TILEP_MONS_QUASIT;

        return TILE_MONS_RAT;

        return TILEP_MONS_RAT;

        return TILE_MONS_SCORPION;

        return TILEP_MONS_SCORPION;

        return TILE_MONS_UGLY_THING ;

        return TILEP_MONS_UGLY_THING ;

        return TILE_MONS_FIRE_VORTEX;

        return TILEP_MONS_FIRE_VORTEX;

        return TILE_MONS_WORM;

        return TILEP_MONS_WORM;

        return TILE_MONS_ABOMINATION_SMALL;

        return TILEP_MONS_ABOMINATION_SMALL;

        return TILE_MONS_YELLOW_WASP;

        return TILEP_MONS_YELLOW_WASP;

        return TILE_MONS_ZOMBIE_SMALL;

        return TILEP_MONS_ZOMBIE_SMALL;

        return TILE_MONS_ANGEL;

        return TILEP_MONS_ANGEL;

        return TILE_MONS_GIANT_BEETLE;

        return TILEP_MONS_GIANT_BEETLE;

        return TILE_MONS_CYCLOPS;

        return TILEP_MONS_CYCLOPS;

        return TILE_MONS_DRAGON;

        return TILEP_MONS_DRAGON;

        return TILE_MONS_TWO_HEADED_OGRE;

        return TILEP_MONS_TWO_HEADED_OGRE;

        return TILE_MONS_FIEND;

        return TILEP_MONS_FIEND;

        return TILE_MONS_GIANT_SPORE;

        return TILEP_MONS_GIANT_SPORE;

        return TILE_MONS_HOBGOBLIN;

        return TILEP_MONS_HOBGOBLIN;

        return TILE_MONS_ICE_BEAST;

        return TILEP_MONS_ICE_BEAST;

        return TILE_MONS_JELLY;

        return TILEP_MONS_JELLY;

        return TILE_MONS_KOBOLD;

        return TILEP_MONS_KOBOLD;

        return TILE_MONS_LICH;

        return TILEP_MONS_LICH;

        return TILE_MONS_MUMMY;

        return TILEP_MONS_MUMMY;

        return TILE_MONS_GUARDIAN_NAGA;

        return TILEP_MONS_GUARDIAN_NAGA;

        return TILE_MONS_OGRE;

        return TILEP_MONS_OGRE;

        return TILE_MONS_PLANT;

        return TILEP_MONS_PLANT;

        return TILE_MONS_QUEEN_BEE;

        return TILEP_MONS_QUEEN_BEE;

        return TILE_MONS_RAKSHASA;

        return TILEP_MONS_RAKSHASA;

        return TILE_MONS_SNAKE;

        return TILEP_MONS_SNAKE;

        return TILE_MONS_TROLL;

        return TILEP_MONS_TROLL;

        return TILE_MONS_UNSEEN_HORROR;

        return TILEP_MONS_UNSEEN_HORROR;

        return TILE_MONS_VAMPIRE;

        return TILEP_MONS_VAMPIRE;

        return TILE_MONS_WRAITH;

        return TILEP_MONS_WRAITH;

        return TILE_MONS_ABOMINATION_LARGE + ((mon->colour)%7);

        return TILEP_MONS_ABOMINATION_LARGE + ((mon->colour)%7);

        return TILE_MONS_YAK;

        return TILEP_MONS_YAK;

        return TILE_MONS_ZOMBIE_LARGE;

        return TILEP_MONS_ZOMBIE_LARGE;

        return TILE_MONS_ORC_WARRIOR;

        return TILEP_MONS_ORC_WARRIOR;

        return TILE_MONS_KOBOLD_DEMONOLOGIST;

        return TILEP_MONS_KOBOLD_DEMONOLOGIST;

        return TILE_MONS_ORC_WIZARD;

        return TILEP_MONS_ORC_WIZARD;

        return TILE_MONS_ORC_KNIGHT;

        return TILEP_MONS_ORC_KNIGHT;

        return TILE_MONS_WYVERN;

        return TILEP_MONS_WYVERN;

        return TILE_MONS_BIG_KOBOLD;

        return TILEP_MONS_BIG_KOBOLD;

        return TILE_MONS_GIANT_EYEBALL;

        return TILEP_MONS_GIANT_EYEBALL;

        return TILE_MONS_WIGHT;

        return TILEP_MONS_WIGHT;

        return TILE_MONS_OKLOB_PLANT;

        return TILEP_MONS_OKLOB_PLANT;

        return TILE_MONS_WOLF_SPIDER;

        return TILEP_MONS_WOLF_SPIDER;

        return TILE_MONS_SHADOW;

        return TILEP_MONS_SHADOW;

        return TILE_MONS_HUNGRY_GHOST;

        return TILEP_MONS_HUNGRY_GHOST;

        return TILE_MONS_EYE_OF_DRAINING;

        return TILEP_MONS_EYE_OF_DRAINING;

        return TILE_MONS_BUTTERFLY + ((mon->colour)%7);

        return TILEP_MONS_BUTTERFLY + ((mon->colour)%7);

        return TILE_MONS_WANDERING_MUSHROOM;

        return TILEP_MONS_WANDERING_MUSHROOM;

        return TILE_MONS_EFREET;

        return TILEP_MONS_EFREET;

        return TILE_MONS_BRAIN_WORM;

        return TILEP_MONS_BRAIN_WORM;

        return TILE_MONS_GIANT_ORANGE_BRAIN;

        return TILEP_MONS_GIANT_ORANGE_BRAIN;

        return TILE_MONS_BOULDER_BEETLE;

        return TILEP_MONS_BOULDER_BEETLE;

        return TILE_MONS_FLYING_SKULL;

        return TILEP_MONS_FLYING_SKULL;

        return TILE_MONS_HELL_HOUND;

        return TILEP_MONS_HELL_HOUND;

        return TILE_MONS_MINOTAUR;

        return TILEP_MONS_MINOTAUR;

        return TILE_MONS_ICE_DRAGON;

        return TILEP_MONS_ICE_DRAGON;

        return TILE_MONS_SLIME_CREATURE;

        return TILEP_MONS_SLIME_CREATURE;

        return TILE_MONS_FREEZING_WRAITH;

        return TILEP_MONS_FREEZING_WRAITH;

        return TILE_MONS_RAKSHASA_FAKE;

        return TILEP_MONS_RAKSHASA_FAKE;

        return TILE_MONS_GREAT_ORB_OF_EYES;

        return TILEP_MONS_GREAT_ORB_OF_EYES;

        return TILE_MONS_HELLION;

        return TILEP_MONS_HELLION;

        return TILE_MONS_ROTTING_DEVIL;

        return TILEP_MONS_ROTTING_DEVIL;

        return TILE_MONS_TORMENTOR;

        return TILEP_MONS_TORMENTOR;

        return TILE_MONS_REAPER;

        return TILEP_MONS_REAPER;

        return TILE_MONS_SOUL_EATER;

        return TILEP_MONS_SOUL_EATER;

        return TILE_MONS_HAIRY_DEVIL;

        return TILEP_MONS_HAIRY_DEVIL;

        return TILE_MONS_ICE_DEVIL;

        return TILEP_MONS_ICE_DEVIL;

        return TILE_MONS_BLUE_DEVIL;

        return TILEP_MONS_BLUE_DEVIL;

        return TILE_MONS_BEAST;

        return TILEP_MONS_BEAST;

        return TILE_MONS_IRON_DEVIL;

        return TILEP_MONS_IRON_DEVIL;

        return TILE_MONS_GLOWING_SHAPESHIFTER;

        return TILEP_MONS_GLOWING_SHAPESHIFTER;

        return TILE_MONS_SHAPESHIFTER;

        return TILEP_MONS_SHAPESHIFTER;

        return TILE_MONS_GIANT_MITE;

        return TILEP_MONS_GIANT_MITE;

        return TILE_MONS_STEAM_DRAGON;

        return TILEP_MONS_STEAM_DRAGON;

        return TILE_MONS_VERY_UGLY_THING;

        return TILEP_MONS_VERY_UGLY_THING;

        return TILE_MONS_ORC_SORCERER;

        return TILEP_MONS_ORC_SORCERER;

        return TILE_MONS_HIPPOGRIFF;

        return TILEP_MONS_HIPPOGRIFF;

        return TILE_MONS_GRIFFON;

        return TILEP_MONS_GRIFFON;

        return TILE_MONS_HYDRA + std::min((int)mon->number, 7) - 1;

        return TILEP_MONS_HYDRA + std::min((int)mon->number, 7) - 1;

        return TILE_MONS_SKELETON_SMALL;

        return TILEP_MONS_SKELETON_SMALL;

        return TILE_MONS_SKELETON_LARGE;

        return TILEP_MONS_SKELETON_LARGE;

        return TILE_MONS_HELL_KNIGHT;

        return TILEP_MONS_HELL_KNIGHT;

        return TILE_MONS_NECROMANCER;

        return TILEP_MONS_NECROMANCER;

        return TILE_MONS_WIZARD;

        return TILEP_MONS_WIZARD;

        return TILE_MONS_ORC_PRIEST;

        return TILEP_MONS_ORC_PRIEST;

        return TILE_MONS_ORC_HIGH_PRIEST;

        return TILEP_MONS_ORC_HIGH_PRIEST;

        return TILE_MONS_HUMAN;

        return TILEP_MONS_HUMAN;

        return TILE_MONS_GNOLL;

        return TILEP_MONS_GNOLL;

        return TILE_MONS_CLAY_GOLEM;

        return TILEP_MONS_CLAY_GOLEM;

        return TILE_MONS_WOOD_GOLEM;

        return TILEP_MONS_WOOD_GOLEM;

        return TILE_MONS_STONE_GOLEM;

        return TILEP_MONS_STONE_GOLEM;

        return TILE_MONS_IRON_GOLEM;

        return TILEP_MONS_IRON_GOLEM;

        return TILE_MONS_CRYSTAL_GOLEM;

        return TILEP_MONS_CRYSTAL_GOLEM;

        return TILE_MONS_TOENAIL_GOLEM;

        return TILEP_MONS_TOENAIL_GOLEM;

        return TILE_MONS_MOTTLED_DRAGON;

        return TILEP_MONS_MOTTLED_DRAGON;

        return TILE_MONS_EARTH_ELEMENTAL;

        return TILEP_MONS_EARTH_ELEMENTAL;

        return TILE_MONS_FIRE_ELEMENTAL;

        return TILEP_MONS_FIRE_ELEMENTAL;

        return TILE_MONS_AIR_ELEMENTAL;

        return TILEP_MONS_AIR_ELEMENTAL;

        return TILE_MONS_ICE_FIEND;

        return TILEP_MONS_ICE_FIEND;

        return TILE_MONS_SHADOW_FIEND;

        return TILEP_MONS_SHADOW_FIEND;

        return TILE_MONS_BROWN_SNAKE;

        return TILEP_MONS_BROWN_SNAKE;

        return TILE_MONS_GIANT_LIZARD;

        return TILEP_MONS_GIANT_LIZARD;

        return TILE_MONS_SPECTRAL_WARRIOR;

        return TILEP_MONS_SPECTRAL_WARRIOR;

        return TILE_MONS_PULSATING_LUMP;

        return TILEP_MONS_PULSATING_LUMP;

        return TILE_MONS_STORM_DRAGON;

        return TILEP_MONS_STORM_DRAGON;

        return TILE_MONS_YAKTAUR;

        return TILEP_MONS_YAKTAUR;

        return TILE_MONS_DEATH_YAK;

        return TILEP_MONS_DEATH_YAK;

        return TILE_MONS_ROCK_TROLL;

        return TILEP_MONS_ROCK_TROLL;

        return TILE_MONS_STONE_GIANT;

        return TILEP_MONS_STONE_GIANT;

        return TILE_MONS_FLAYED_GHOST;

        return TILEP_MONS_FLAYED_GHOST;

        return TILE_MONS_BUMBLEBEE;

        return TILEP_MONS_BUMBLEBEE;

        return TILE_MONS_REDBACK;

        return TILEP_MONS_REDBACK;

        return TILE_MONS_INSUBSTANTIAL_WISP;

        return TILEP_MONS_INSUBSTANTIAL_WISP;

        return TILE_MONS_VAPOUR;

        return TILEP_MONS_VAPOUR;

        return TILE_MONS_OGRE_MAGE;

        return TILEP_MONS_OGRE_MAGE;

        return TILE_MONS_SPINY_WORM;

        return TILEP_MONS_SPINY_WORM;

        item_def item = mitm[menv[mon_idx].inv[MSLOT_WEAPON]];

        item_def item = mitm[mon->inv[MSLOT_WEAPON]];

        return TILE_MONS_TITAN;

        return TILEP_MONS_TITAN;

        return TILE_MONS_GOLDEN_DRAGON;

        return TILEP_MONS_GOLDEN_DRAGON;

        return TILE_MONS_ELF;

        return TILEP_MONS_ELF;

        return TILE_MONS_LINDWURM;

        return TILEP_MONS_LINDWURM;

        return TILE_MONS_ELEPHANT_SLUG;

        return TILEP_MONS_ELEPHANT_SLUG;

        return TILE_MONS_WAR_DOG;

        return TILEP_MONS_WAR_DOG;

        return TILE_MONS_GREY_RAT;

        return TILEP_MONS_GREY_RAT;

        return TILE_MONS_GREEN_RAT;

        return TILEP_MONS_GREEN_RAT;

        return TILE_MONS_ORANGE_RAT;

        return TILEP_MONS_ORANGE_RAT;

        return TILE_MONS_BLACK_SNAKE;

        return TILEP_MONS_BLACK_SNAKE;

        return TILE_MONS_SHEEP;

        return TILEP_MONS_SHEEP;

        return TILE_MONS_GHOUL;

        return TILEP_MONS_GHOUL;

        return TILE_MONS_HOG;

        return TILEP_MONS_HOG;

        return TILE_MONS_GIANT_MOSQUITO;

        return TILEP_MONS_GIANT_MOSQUITO;

        return TILE_MONS_GIANT_CENTIPEDE;

        return TILEP_MONS_GIANT_CENTIPEDE;

        return TILE_MONS_IRON_TROLL;

        return TILEP_MONS_IRON_TROLL;

        return TILE_MONS_NAGA;

        return TILEP_MONS_NAGA;

        return TILE_MONS_FIRE_GIANT;

        return TILEP_MONS_FIRE_GIANT;

        return TILE_MONS_FROST_GIANT;

        return TILEP_MONS_FROST_GIANT;

        return TILE_MONS_FIREDRAKE;

        return TILEP_MONS_FIREDRAKE;

        return TILE_MONS_SHADOW_DRAGON;

        return TILEP_MONS_SHADOW_DRAGON;

        return TILE_MONS_YELLOW_SNAKE;

        return TILEP_MONS_YELLOW_SNAKE;

        return TILE_MONS_GREY_SNAKE;

        return TILEP_MONS_GREY_SNAKE;

        return TILE_MONS_DEEP_TROLL;

        return TILEP_MONS_DEEP_TROLL;

        return TILE_MONS_GIANT_BLOWFLY;

        return TILEP_MONS_GIANT_BLOWFLY;

        return TILE_MONS_RED_WASP;

        return TILEP_MONS_RED_WASP;

        return TILE_MONS_SWAMP_DRAGON;

        return TILEP_MONS_SWAMP_DRAGON;

        return TILE_MONS_SWAMP_DRAKE;

        return TILEP_MONS_SWAMP_DRAKE;

        return TILE_MONS_SOLDIER_ANT;

        return TILEP_MONS_SOLDIER_ANT;

        return TILE_MONS_HILL_GIANT;

        return TILEP_MONS_HILL_GIANT;

        return TILE_MONS_QUEEN_ANT;

        return TILEP_MONS_QUEEN_ANT;

        return TILE_MONS_ANT_LARVA;

        return TILEP_MONS_ANT_LARVA;

        return TILE_MONS_GIANT_FROG;

        return TILEP_MONS_GIANT_FROG;

        return TILE_MONS_GIANT_BROWN_FROG;

        return TILEP_MONS_GIANT_BROWN_FROG;

        return TILE_MONS_SPINY_FROG;

        return TILEP_MONS_SPINY_FROG;

        return TILE_MONS_BLINK_FROG;

        return TILEP_MONS_BLINK_FROG;

        return TILE_MONS_GIANT_COCKROACH;

        return TILEP_MONS_GIANT_COCKROACH;

        return TILE_MONS_SMALL_SNAKE;

        return TILEP_MONS_SMALL_SNAKE;

        return TILE_MONS_WOLF;

        return TILEP_MONS_WOLF;

        return TILE_MONS_WARG;

        return TILEP_MONS_WARG;

        return TILE_MONS_BEAR;

        return TILEP_MONS_BEAR;

        return TILE_MONS_GRIZZLY_BEAR;

        return TILEP_MONS_GRIZZLY_BEAR;

        return TILE_MONS_POLAR_BEAR;

        return TILEP_MONS_POLAR_BEAR;

        return TILE_MONS_BLACK_BEAR;

        return TILEP_MONS_BLACK_BEAR;

        return TILE_MONS_SIMULACRUM_SMALL;

        return TILEP_MONS_SIMULACRUM_SMALL;

        return TILE_MONS_SIMULACRUM_LARGE;

        return TILEP_MONS_SIMULACRUM_LARGE;

        return TILE_MONS_WHITE_IMP;

        return TILEP_MONS_WHITE_IMP;

        return TILE_MONS_LEMURE;

        return TILEP_MONS_LEMURE;

        return TILE_MONS_UFETUBUS;

        return TILEP_MONS_UFETUBUS;

        return TILE_MONS_MANES;

        return TILEP_MONS_MANES;

        return TILE_MONS_MIDGE;

        return TILEP_MONS_MIDGE;

        return TILE_MONS_NEQOXEC;

        return TILEP_MONS_NEQOXEC;

        return TILE_MONS_ORANGE_DEMON;

        return TILEP_MONS_ORANGE_DEMON;

        return TILE_MONS_HELLWING;

        return TILEP_MONS_HELLWING;

        return TILE_MONS_SMOKE_DEMON;

        return TILEP_MONS_SMOKE_DEMON;

        return TILE_MONS_YNOXINUL;

        return TILEP_MONS_YNOXINUL;

        return TILE_MONS_EXECUTIONER;

        return TILEP_MONS_EXECUTIONER;

        return TILE_MONS_GREEN_DEATH;

        return TILEP_MONS_GREEN_DEATH;

        return TILE_MONS_BLUE_DEATH;

        return TILEP_MONS_BLUE_DEATH;

        return TILE_MONS_BALRUG;

        return TILEP_MONS_BALRUG;

        return TILE_MONS_CACODEMON;

        return TILEP_MONS_CACODEMON;

        return TILE_MONS_DEMONIC_CRAWLER;

        return TILEP_MONS_DEMONIC_CRAWLER;

        return TILE_MONS_SUN_DEMON;

        return TILEP_MONS_SUN_DEMON;

        return TILE_MONS_SHADOW_IMP;

        return TILEP_MONS_SHADOW_IMP;

        return TILE_MONS_SHADOW_DEMON;

        return TILEP_MONS_SHADOW_DEMON;

        return TILE_MONS_LOROCYPROCA;

        return TILEP_MONS_LOROCYPROCA;

        return TILE_MONS_SHADOW_WRAITH;

        return TILEP_MONS_SHADOW_WRAITH;

        return TILE_MONS_GIANT_AMOEBA;

        return TILEP_MONS_GIANT_AMOEBA;

        return TILE_MONS_GIANT_SLUG;

        return TILEP_MONS_GIANT_SLUG;

        return TILE_MONS_GIANT_SNAIL;

        return TILEP_MONS_GIANT_SNAIL;

        return TILE_MONS_SPATIAL_VORTEX;

        return TILEP_MONS_SPATIAL_VORTEX;

        return TILE_MONS_PIT_FIEND;

        return TILEP_MONS_PIT_FIEND;

        return TILE_MONS_BORING_BEETLE;

        return TILEP_MONS_BORING_BEETLE;

        return TILE_MONS_GARGOYLE;

        return TILEP_MONS_GARGOYLE;

        return TILE_MONS_METAL_GARGOYLE;

        return TILEP_MONS_METAL_GARGOYLE;

        return TILE_MONS_MOLTEN_GARGOYLE;

        return TILEP_MONS_MOLTEN_GARGOYLE;

        return TILE_MONS_PROGRAM_BUG;

        return TILEP_MONS_PROGRAM_BUG;

        return TILE_MONS_MNOLEG;

        return TILEP_MONS_MNOLEG;

        return TILE_MONS_LOM_LOBON;

        return TILEP_MONS_LOM_LOBON;

        return TILE_MONS_CEREBOV;

        return TILEP_MONS_CEREBOV;

        return TILE_MONS_GLOORX_VLOQ;

        return TILEP_MONS_GLOORX_VLOQ;

        return TILE_MONS_NAGA_MAGE;

        return TILEP_MONS_NAGA_MAGE;

        return TILE_MONS_NAGA_WARRIOR;

        return TILEP_MONS_NAGA_WARRIOR;

        return TILE_MONS_ORC_WARLORD;

        return TILEP_MONS_ORC_WARLORD;

        return TILE_MONS_DEEP_ELF_SOLDIER;

        return TILEP_MONS_DEEP_ELF_SOLDIER;

        return TILE_MONS_DEEP_ELF_FIGHTER;

        return TILEP_MONS_DEEP_ELF_FIGHTER;

        return TILE_MONS_DEEP_ELF_KNIGHT;

        return TILEP_MONS_DEEP_ELF_KNIGHT;

        return TILE_MONS_DEEP_ELF_MAGE;

        return TILEP_MONS_DEEP_ELF_MAGE;

        return TILE_MONS_DEEP_ELF_SUMMONER;

        return TILEP_MONS_DEEP_ELF_SUMMONER;

        return TILE_MONS_DEEP_ELF_CONJURER;

        return TILEP_MONS_DEEP_ELF_CONJURER;

        return TILE_MONS_DEEP_ELF_PRIEST;

        return TILEP_MONS_DEEP_ELF_PRIEST;

        return TILE_MONS_DEEP_ELF_HIGH_PRIEST;

        return TILEP_MONS_DEEP_ELF_HIGH_PRIEST;

        return TILE_MONS_DEEP_ELF_DEMONOLOGIST;

        return TILEP_MONS_DEEP_ELF_DEMONOLOGIST;

        return TILE_MONS_DEEP_ELF_ANNIHILATOR;

        return TILEP_MONS_DEEP_ELF_ANNIHILATOR;

        return TILE_MONS_DEEP_ELF_SORCERER;

        return TILEP_MONS_DEEP_ELF_SORCERER;

        return TILE_MONS_DEEP_ELF_DEATH_MAGE;

        return TILEP_MONS_DEEP_ELF_DEATH_MAGE;

        return TILE_MONS_BROWN_OOZE;

        return TILEP_MONS_BROWN_OOZE;

        return TILE_MONS_AZURE_JELLY;

        return TILEP_MONS_AZURE_JELLY;

        return TILE_MONS_DEATH_OOZE;

        return TILEP_MONS_DEATH_OOZE;

        return TILE_MONS_ACID_BLOB;

        return TILEP_MONS_ACID_BLOB;

        return TILE_MONS_ROYAL_JELLY;

        return TILEP_MONS_ROYAL_JELLY;

        return TILE_MONS_TERENCE;

        return TILEP_MONS_TERENCE;

        return TILE_MONS_JESSICA;

        return TILEP_MONS_JESSICA;

        return TILE_MONS_IJYB;

        return TILEP_MONS_IJYB;

        return TILE_MONS_SIGMUND;

        return TILEP_MONS_SIGMUND;

        return TILE_MONS_BLORK_THE_ORC;

        return TILEP_MONS_BLORK_THE_ORC;

        return TILE_MONS_EDMUND;

        return TILEP_MONS_EDMUND;

        return TILE_MONS_PSYCHE;

        return TILEP_MONS_PSYCHE;

        return TILE_MONS_EROLCHA;

        return TILEP_MONS_EROLCHA;

        return TILE_MONS_DONALD;

        return TILEP_MONS_DONALD;

        return TILE_MONS_URUG;

        return TILEP_MONS_URUG;

        return TILE_MONS_MICHAEL;

        return TILEP_MONS_MICHAEL;

        return TILE_MONS_JOSEPH;

        return TILEP_MONS_JOSEPH;

        return TILE_MONS_SNORG;

        return TILEP_MONS_SNORG;

        return TILE_MONS_ERICA;

        return TILEP_MONS_ERICA;

        return TILE_MONS_JOSEPHINE;

        return TILEP_MONS_JOSEPHINE;

        return TILE_MONS_HAROLD;

        return TILEP_MONS_HAROLD;

        return TILE_MONS_NORBERT;

        return TILEP_MONS_NORBERT;

        return TILE_MONS_JOZEF;

        return TILEP_MONS_JOZEF;

        return TILE_MONS_AGNES;

        return TILEP_MONS_AGNES;

        return TILE_MONS_MAUD;

        return TILEP_MONS_MAUD;

        return TILE_MONS_LOUISE;

        return TILEP_MONS_LOUISE;

        return TILE_MONS_FRANCIS;

        return TILEP_MONS_FRANCIS;

        return TILE_MONS_FRANCES;

        return TILEP_MONS_FRANCES;

        return TILE_MONS_RUPERT;

        return TILEP_MONS_RUPERT;

        return TILE_MONS_WAYNE;

        return TILEP_MONS_WAYNE;

        return TILE_MONS_DUANE;

        return TILEP_MONS_DUANE;

        return TILE_MONS_XTAHUA;

        return TILEP_MONS_XTAHUA;

        return TILE_MONS_NORRIS;

        return TILEP_MONS_NORRIS;

        return TILE_MONS_FREDERICK;

        return TILEP_MONS_FREDERICK;

        return TILE_MONS_MARGERY;

        return TILEP_MONS_MARGERY;

        return TILE_MONS_POLYPHEMUS;

        return TILEP_MONS_POLYPHEMUS;

        return TILE_MONS_BORIS;

        return TILEP_MONS_BORIS;

        return TILE_MONS_MURRAY;

        return TILEP_MONS_MURRAY;

        return TILE_MONS_TIAMAT;

        return TILEP_MONS_TIAMAT;

        return TILE_MONS_DEEP_ELF_BLADEMASTER;

        return TILEP_MONS_DEEP_ELF_BLADEMASTER;

        return TILE_MONS_DEEP_ELF_MASTER_ARCHER;

        return TILEP_MONS_DEEP_ELF_MASTER_ARCHER;

        return TILE_MONS_GERYON;

        return TILEP_MONS_GERYON;

        return TILE_MONS_DISPATER;

        return TILEP_MONS_DISPATER;

        return TILE_MONS_ASMODEUS;

        return TILEP_MONS_ASMODEUS;

        return TILE_MONS_ANTAEUS;

        return TILEP_MONS_ANTAEUS;

        return TILE_MONS_ERESHKIGAL;

        return TILEP_MONS_ERESHKIGAL;

        return TILE_MONS_ANCIENT_LICH;

        return TILEP_MONS_ANCIENT_LICH;

        return TILE_MONS_OOZE;

        return TILEP_MONS_OOZE;