Text:DngnX=19
Text:DngnY=17
Text:MapPx=4
Text:MsgX=73
Text:MsgY=10
Text:WindowTop=54
Text:WindowLeft=121
Text:FontName=8x13
Text:FontSize=19
Tile:DngnX=19
Tile:DngnY=17
Tile:MapPx=4
Tile:MsgX=73
Tile:MsgY=10
Tile:WindowTop=40
Tile:WindowLeft=193
Tile:FontName=8x13
Tile:FontSize=16
Iso:DngnX=17
Iso:DngnY=17
Iso:MapPx=1
Iso:MsgX=40
Iso:MsgY=8
Iso:WindowTop=10
Iso:WindowLeft=73
Iso:FontName=8x16
Iso:FontSize=24

#if defined(WIN32CONSOLE) || defined(DOS)

#if defined(WIN32CONSOLE) || defined(DOS) || defined(USE_TILE)

#include "tiles.h"

#ifdef USE_TILE
    int glyph = env.map[x][y].glyph();
    GmapUpdate(x,y,glyph);
#endif

#ifdef USE_TILE
    int glyph = env.map[x][y].glyph();
    if (glyph)
        GmapUpdate(x,y,glyph);
#endif

#ifdef USE_TILE
    env.map[x][y].flags &= ~(MAP_DETECTED_ITEM);
    env.map[x][y].flags &= ~(MAP_DETECTED_MONSTER);
#endif

#if defined(WIN32CONSOLE) || defined(DOS)

#if defined(WIN32CONSOLE) || defined(DOS) || defined(USE_TILE)

#if defined(WIN32CONSOLE) || defined(DOS)

#if defined(WIN32CONSOLE) || defined(DOS) || defined(USE_TILE)

#if defined(WIN32CONSOLE) || defined(DOS)

#if defined(WIN32CONSOLE) || defined(DOS) || defined(USE_TILE)

#ifdef USE_TILE
            set_envmap_obj(x, y, is_terrain_known(x, y)? grd[x][y] : 0);
            env.tile_bk_fg[x][y] = 0;
            env.tile_bk_bg[x][y] = is_terrain_known(x, y) ?
                tile_idx_unseen_terrain(x, y, grd[x][y]) : 
                tileidx_feature(DNGN_UNSEEN);
#endif

#ifdef USE_TILE
            tile_place_monster(monster->x, monster->y, s, true);
#endif

#ifdef USE_TILE
    int idx = igrd(gp);
    if (is_stair(grid))
        tile_place_item_marker(ep.x, ep.y, idx);
    else
        tile_place_item(ep.x, ep.y, idx);
#endif

#ifdef USE_TILE
    tile_place_cloud(ex, ey, env.cloud[cloudno].type, 
        env.cloud[cloudno].decay);
#endif

    const int xcol = crawl_view.hudp.x;
    
    gotoxy(xcol, 2);

    gotoxy(1, 2, GOTO_STAT);

    gotoxy(xcol,  3); cprintf("HP:");
    gotoxy(xcol,  4); cprintf("Magic:");
    gotoxy(xcol,  5); cprintf("AC:");
    gotoxy(xcol,  6); cprintf("EV:");
    gotoxy(xcol,  7); cprintf("Str:");
    gotoxy(xcol,  8); cprintf("Int:");
    gotoxy(xcol,  9); cprintf("Dex:");
    gotoxy(xcol, 10); cprintf("Gold:");

    gotoxy(1,  3, GOTO_STAT); cprintf("HP:");
    gotoxy(1,  4, GOTO_STAT); cprintf("Magic:");
    gotoxy(1,  5, GOTO_STAT); cprintf("AC:");
    gotoxy(1,  6, GOTO_STAT); cprintf("EV:");
    gotoxy(1,  7, GOTO_STAT); cprintf("Str:");
    gotoxy(1,  8, GOTO_STAT); cprintf("Int:");
    gotoxy(1,  9, GOTO_STAT); cprintf("Dex:");
    gotoxy(1, 10, GOTO_STAT); cprintf("Gold:");

        gotoxy(xcol + 15, 10);

        gotoxy(1 + 15, 10, GOTO_STAT);

    gotoxy(xcol, 11); cprintf("Experience:");
    gotoxy(xcol, 12); cprintf("Level");

    gotoxy(1, 11, GOTO_STAT); cprintf("Experience:");
    gotoxy(1, 12, GOTO_STAT); cprintf("Level");

#ifndef USE_TILE

#endif // USE_TILE

#ifndef USE_TILE

#endif

        {
#ifdef USE_TILE
            // Note: Tile versions just center on the current cursor
            // location.  It silently ignores everything else going
            // on in this function.  --Enne
            unsigned int cx = start_x + curs_x - 1;
            unsigned int cy = start_y + curs_y - 1;
            TileDrawMap(cx, cy);
            GmapDisplay(cx, cy);
        }
#else

        redraw_map = true;

        }

#endif
        redraw_map = true;

#ifdef USE_TILE
        if (getty == CK_MOUSE_B4) getty = '-';
        if (getty == CK_MOUSE_B5) getty = '+';
#endif

#ifdef USE_TILE
            if (!wizard_map && is_terrain_known(i,j))
            {
                // can't use set_envmap_obj because that
                // will overwrite the gmap.
                env.tile_bk_bg[i][j] =
                    tile_idx_unseen_terrain(i, j, grd[i][j]);
            }
#endif

#ifdef USE_TILE
    GmapInit(true); // re-draw tile backup
    tile_clear_buf();
#endif

#ifndef USE_TILE

#endif

#ifdef USE_TILE
    std::vector<unsigned short> tileb( 
        crawl_view.viewsz.y * crawl_view.viewsz.x * 2);
#endif

#ifdef USE_TILE
    tile_draw_floor();
    TileMcacheUnlock();
#endif

#ifdef USE_TILE
    tile_draw_rays(true);
#endif

#ifdef USE_TILE
                    tileb[bufcount] = 0;
                    tileb[bufcount+1] = tileidx_unseen(' ', gc);
#endif

#ifdef USE_TILE
                    unsigned short bg = env.tile_bk_bg[gc.x][gc.y];
                    unsigned short fg = env.tile_bk_fg[gc.x][gc.y];
                    if (bg == 0 && fg == 0)
                    {
                        bg = tileidx_unseen(get_envmap_char(gc.x,gc.y), gc);
                        env.tile_bk_bg[gc.x][gc.y] = bg;
                    }
                    tileb[bufcount] = fg;
                    tileb[bufcount+1] = bg | tile_unseen_flag(gc);
#endif

                    }
#ifdef USE_TILE
                    if (map)
                    {
                        env.tile_bk_bg[gc.x][gc.y] = 
                            env.tile_bg[ep.x-1][ep.y-1];

                    tileb[bufcount] = env.tile_fg[ep.x-1][ep.y-1] =
                        tileidx_player(you.char_class);
                    tileb[bufcount+1] = env.tile_bg[ep.x-1][ep.y-1];
#endif

#ifdef USE_TILE
                    tileb[bufcount]= env.tile_fg[ep.x-1][ep.y-1];
                    tileb[bufcount+1]= env.tile_bg[ep.x-1][ep.y-1];
#endif

                            set_envmap_glyph( gc.x, gc.y, object, colour );

                            set_envmap_glyph( gc.x, gc.y, object, colour );

#ifdef USE_TILE
                            // We remove any references to mcache when
                            // writing to the background.
                            if (Options.clean_map)
                            {
                                env.tile_bk_fg[gc.x][gc.y] =
                                    get_clean_map_idx(
                                    env.tile_fg[ep.x-1][ep.y-1]);
                            }
                            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_bk_bg[gc.x][gc.y] =
                                env.tile_bg[ep.x-1][ep.y-1];
#endif

#ifdef USE_TILE
                            if(env.tile_bk_fg[gc.x][gc.y] != 0
                                || env.tile_bk_bg[gc.x][gc.y] != 0)
                            {
                                tileb[bufcount] =
                                    env.tile_bk_fg[gc.x][gc.y];
                                tileb[bufcount + 1] =
                                    env.tile_bk_bg[gc.x][gc.y] 
                                    | tile_unseen_flag(gc);
                            }
                            else
                            {
                                tileb[bufcount] = 0;
                                tileb[bufcount + 1] =
                                    tileidx_unseen(
                                    get_envmap_char( gc.x, gc.y ), gc);
                            }
#endif

#ifdef USE_TILE
            tile_draw_dungeon(&tileb[0]);
            GmapDisplay(you.x_pos, you.y_pos);
#else

#endif

#ifndef USE_TILE

#endif

#ifdef USE_TILE
    // libgui may redefine these based on its own settings
    gui_init_view_params(termsz, viewsz, msgp, msgsz, hudp, hudsz);
#endif

#ifdef USE_TILE
    return crawl_view.msgsz.x;
#else

#endif

#ifdef USE_TILE
#include "tiledef.h"
#include "beam.h"
//*tile1.cc: get data from core part and drives tile drawing codes
//**convert in-game data to tile index
int tileidx(unsigned int object, int extra);
int tileidx_feature(int object);
int tileidx_player(int job);
int tileidx_unseen(int ch, const coord_def& gc);
int tileidx_item(const item_def &item);
int tileidx_item_throw(const item_def &item, int dx, int dy);
int tileidx_bolt(const bolt &bolt);
int tileidx_zap(int color);
int tile_idx_unseen_terrain(int x, int y, int what);
int tile_unseen_flag(const coord_def& gc);
#define simple_iso_tile(x) (x)
// 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_part_to_str(int number, char *buf);
int  tilep_str_to_part(char *str);
void tilep_scan_parts(char *fbuf, int *parts);
void tilep_print_parts(char *fbuf, int *parts);
int tilep_equ_weapon(const item_def &item);
int tilep_equ_shield(const item_def &item);
int tilep_equ_armour(const item_def &item);
int tilep_equ_cloak(const item_def &item);
int tilep_equ_helm(const item_def &item);
int tilep_equ_gloves(const item_def &item);
int tilep_equ_boots(const item_def &item);
// Tile display related
void tile_draw_floor();
void tile_place_monster(int gx, int gy, int idx, bool foreground = true);
void tile_place_item(int x, int y, int idx);
void tile_place_item_bk(int gx, int gy, int idx);
void tile_place_tile_bk(int gx, int gy, int tileidx);
void tile_place_item_marker(int x, int y, int idx);
void tile_place_cloud(int x, int y, int type, int decay);
void tile_place_ray(const coord_def& gc);
void tile_draw_rays(bool resetCount);
void tile_clear_buf();
void tile_finish_dngn(short unsigned int *tileb, int cx, int cy);
void tile_draw_dungeon(short unsigned int *tileb);
// Tile Inventry display
void tile_draw_inv(int item_type = -1, int flag = -1);
// Multiple pickup
void tile_pick_menu();
int get_num_wall_flavors();
int get_num_floor_flavors();
int get_num_floor_special_flavors();
int get_wall_tile_idx();
int get_floor_tile_idx();
int get_floor_special_tile_idx();
void tile_init_flavor();
/**************************************/
/* tile2.cc  image manipulation       */
/**************************************/
// init them all
void TileInit();
void TileResizeScreen(int x, int y);
// display tile cursor, returns old cursor value there
int TileDrawCursor(int x, int y, int flag);
// display bolts
void TileDrawBolt(int x, int y, int fg);
// display dungeon: tileb = { fg(0,0),bg(0,0),fg(1,0),bg(1,0), ..
void TileDrawDungeon(short unsigned int *tileb);
// display memorized dungeon
void TileDrawFarDungeon(int cx, int cy);
// display map centered on grid coords
void TileDrawMap(int gx, int gy);
void LoadDungeonView(short unsigned int *tileb);
void StoreDungeonView(short unsigned int *tileb);
void TileNewLevel(bool first_time);
// display inventry
void TileDrawInvData(int n, int flag, int *tiles, int *num,
	int *idx, int *iflags);
void TileDrawOneItem(int region, int i, char key, int idx,
    int tile, int num, bool floor,
    bool select, bool equip, bool tried, bool cursed);
void TileRedrawInv(int region);
void TileClearInv(int region);
void TileMoveInvCursor(int ix);
int TileInvIdx(int i);
// refresh player tile
void TilePlayerRefresh();
// edit player tile
void TilePlayerEdit();
// init player tile
void TilePlayerInit();
// init ghost tile
void TileGhostInit(struct ghost_demon &gs);
// init pandem demon tile (only in iso mode)
void TilePandemInit(struct ghost_demon &gs);
// edit pandem tile (debug)
void TileEditPandem();
// init id-ed item tiles
void TileInitItems();
// load wall tiles
void TileLoadWall(bool wizard);
//�^�C�g��
void TileDrawTitle();
// monster+weapon tile
void TileMcacheUnlock();
int  TileMcacheFind(int mon_tile, int eq_tile, int draco = 0);
int get_base_idx_from_mcache(int tile_idx);
int get_clean_map_idx(int tile_idx);
/* Flags for drawing routines */
// MAY_STAB, FLAG_STAB, and FLAG_PET are mutually exclusive
#define TILE_FLAG_MAY_STAB 0xC000 // May stab brand is always fg
#define TILE_FLAG_STAB    0x8000 // Stab brand is always fg
#define TILE_FLAG_PET     0x4000 //pet is always fg
#define TILE_FLAG_NET     0x2000 //nets are always in fg
#define TILE_FLAG_FLYING  0x1000 //flying object is always fg
#define TILE_FLAG_S_UNDER 0x800 //fg
#define TILE_FLAG_CURSOR  0xc000 //cursor is always bg
#define TILE_FLAG_CURSOR1 0x8000 //cursor is always bg
#define TILE_FLAG_CURSOR2 0x4000 //cursor is always bg
#define TILE_FLAG_CURSOR3 0xc000 //cursor is always bg
#define TILE_FLAG_CURSOR0 0x0000 //cursor is always bg
#define TILE_FLAG_UNSEEN 0x2000 //unseen flag is set to bg
#define TILE_FLAG_MM_UNSEEN 0x1000
#define TILE_FLAG_RAY    0x800
#define TILE_FLAG_MASK   0x07ff
#define TILEI_FLAG_SELECT 0x100
#define TILEI_FLAG_TRIED  0x200
#define TILEI_FLAG_EQUIP  0x400
#define TILEI_FLAG_FLOOR  0x800
#define TILEI_FLAG_CURSE  0x1000
#define TILEI_FLAG_CURSOR 0x2000
#define TILEP_GENDER_MALE 0
#define TILEP_GENDER_FEMALE 1
#define TILEP_M_DEFAULT   0
#define TILEP_M_LOADING   1
#define TILEP_SHOW_EQUIP 0x1000
enum TilePlayerFlagCut
{
    TILEP_FLAG_HIDE,
    TILEP_FLAG_NORMAL,
    TILEP_FLAG_CUT_CENTAUR,
    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
// Dungeon view window size
#define TILE_DAT_XMAX 35
#define TILE_DAT_YMAX 35
// normal tile size in px
#define TILE_X 32
#define TILE_Y 32
// Unit size
// iso mode screen size
#define TILE_XMAX_ISO 24
#define TILE_YMAX_ISO 13
// iso tile size in px
#define TILE_X_EX_ISO 64
#define TILE_Y_EX_ISO 64
// iso mode  unit grid size in px
#define TILE_UX_ISO (TILE_X_EX_ISO/2)
#define TILE_UY_ISO (TILE_X_EX_ISO/2)
// screen size in grids
#define TILE_XMAX_NORMAL 17
#define TILE_YMAX_NORMAL 17
// grid size in px
#define TILE_UX_NORMAL TILE_X
#define TILE_UY_NORMAL TILE_Y
#define TILEP_BOOTS_NAGA_BARDING (N_PART_BOOTS + 1)
#define TILEP_BOOTS_CENTAUR_BARDING (N_PART_BOOTS + 2)
#endif // USE_TILES

#ifdef USE_TILE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "AppHdr.h"
#include "describe.h"
#include "direct.h"
#include "dungeon.h"
#include "files.h"
#include "guic.h"
#include "itemprop.h"
#include "it_use2.h"
#include "stuff.h"
#include "tiles.h"
#include "tilecount-w2d.h"
#include "tiledef-p.h"
#include "transfor.h"
// normal tile count + iso tile count
#define TILE_TOTAL2 (TILE_TOTAL)
// normal tile count
#define TILE_NORMAL TILE_TOTAL
extern void TileDrawDungeonAux();
// Raw tile images
extern img_type TileImg;
extern img_type TileIsoImg;
extern img_type PlayerImg;
extern img_type WallImg;
extern img_type ScrBufImg;
extern WinClass *win_main;
// Regions
extern TileRegionClass *region_tile;
extern TextRegionClass *region_crt;
extern TextRegionClass *region_stat;
extern TextRegionClass *region_tip;
extern TextRegionClass *region_msg;
extern TileRegionClass *region_item;
extern TileRegionClass *region_item2;
#define ScrBufImg (region_tile->backbuf)
//Internal
static img_type DollCacheImg;
static void tile_draw_grid(int kind, int xx, int yy);
static void clear_tcache();
static void init_tcache();
static void init_tileflag();
static void register_tile_mask(int tile, int region, int *cp,
    char *ms, bool smalltile = false);
static void tcache_compose_normal(int ix, int *fg, int *bg);
#if 1 // TILE_MON_EQUIP
static void mcache_init();
#endif
//Internal variables
bool force_redraw_tile;
bool force_redraw_inv = false;
static unsigned short int t1buf[TILE_DAT_XMAX+2][TILE_DAT_YMAX+2],
                          t2buf[TILE_DAT_XMAX+2][TILE_DAT_YMAX+2];
static short unsigned int tb_bk[TILE_DAT_YMAX*TILE_DAT_XMAX*2];
#define MAX_ITEMLIST 200
int itemlist[MAX_ITEMLIST];
int itemlist_num[MAX_ITEMLIST];
int itemlist_idx[MAX_ITEMLIST];
char itemlist_key[MAX_ITEMLIST];
int itemlist_iflag[MAX_ITEMLIST];
int itemlist_flag = -1;
int itemlist_n=0;
static int wall_flavors = 0;
static int floor_flavors = 0;
static int special_flavors = 0;
static int wall_tile_idx = 0;
static int floor_tile_idx = 0;
static int special_tile_idx = 0;
int get_num_wall_flavors()
{
    return wall_flavors;
}
int get_num_floor_flavors()
{
    return floor_flavors;
}
int get_num_floor_special_flavors()
{
    return special_flavors;
}
int get_wall_tile_idx()
{
    return wall_tile_idx;
}
int get_floor_tile_idx()
{
    return floor_tile_idx;
}
int get_floor_special_tile_idx()
{
    return special_tile_idx;
}
/******** Cache buffer for transparency operation *****/
static int tcache_kind;
#if 1  // ISO
#define TCACHE_KIND_ISO 2
#define TCACHE0_ISO 0
#define TCACHE1_ISO 1
#endif
#define TCACHE_KIND_NORMAL 1
#define TCACHE0_NORMAL 0
static int last_cursor = -1;
//Internal cache Image buffer
static img_type *tcache_image;
//Start of a pointer string
static int *tcache_head;
typedef struct tile_cache
{
    unsigned int id[4];
    int idx;
    tile_cache *next;
    tile_cache *prev;
} tile_cache;
// number of tile grids
static int tile_xmax;
static int tile_ymax;
static int max_tcache;
static int tc_hash;
// [kind * tc_hash][max_tcache]
static tile_cache **tcache;
// [kind][x*y]
static int **screen_tcach_idx;
#if 1 //ISO
/*
 screen grid arrangement. (x,y,kind)
 (0,0,B) (1,0,A) (2,0,B)
 (0,0,A) (1,0,B) (2,0,A) ...
 (0,1,B) (1,1,A) (2,1,B)
 (0,1,A) (1,1,B) (2,1,A)
       ....
*/
const int tcache_wx_iso[TCACHE_KIND_ISO] = {TILE_X_EX_ISO/2, TILE_X_EX_ISO/2};
const int tcache_wy_iso[TCACHE_KIND_ISO] = {TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4};
const int tcache_ox_iso[TCACHE_KIND_ISO] = {0,0};
const int tcache_oy_iso[TCACHE_KIND_ISO] = {0,TILE_Y_EX_ISO/4};
const int tcache_nlayer_iso[TCACHE_KIND_ISO] = {4,4};
#endif
const int tcache_wx_normal[TCACHE_KIND_NORMAL] = {TILE_X};
const int tcache_wy_normal[TCACHE_KIND_NORMAL] = {TILE_Y};
const int tcache_ox_normal[TCACHE_KIND_NORMAL] = {0};
const int tcache_oy_normal[TCACHE_KIND_NORMAL] = {0};
const int tcache_nlayer_normal[TCACHE_KIND_NORMAL] = {1};
unsigned char tile_flag[TILE_TOTAL2];
#define TFLAG_A 0x80
#define TFLAG_B 0x40
#define TFLAG_C 0x20
#define TFLAG_D 0x10
#define TFLAG_F 0x08
#define TFLAG_G 0x04
#define TFLAG_H 0x02
#define TFLAG_I 0x01
#define tile_check_blank(tile,region) \
    if( (tile_flag[tile & TILE_FLAG_MASK]&(region))==0) (tile) &= ~TILE_FLAG_MASK;
#if 1 //ISO
#define TREGION_A_ISO 0
#define TREGION_B_ISO 1
#define TREGION_C_ISO 2
#define TREGION_D_ISO 3
#define TREGION_E_ISO 4
#define TREGION_F_ISO 5
#define TREGION_G_ISO 6
#define TREGION_H_ISO 7
/*
<-64->
 AAEE |
 BBFF 64
 CCGG |
 DDHH |
*/
const int region_sx_iso[8]=
    {0, 0, 0, 0,
    TILE_X_EX_ISO/2, TILE_X_EX_ISO/2, TILE_X_EX_ISO/2, TILE_X_EX_ISO/2};
const int region_sy_iso[8]=
    {0, TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/2, (TILE_Y_EX_ISO*3)/4,
     0, TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/2, (TILE_Y_EX_ISO*3)/4};
const int region_wx_iso[8]=
    {TILE_X_EX_ISO/2, TILE_X_EX_ISO/2, TILE_X_EX_ISO/2, TILE_X_EX_ISO/2,
     TILE_X_EX_ISO/2, TILE_X_EX_ISO/2, TILE_X_EX_ISO/2, TILE_X_EX_ISO/2};
const int region_wy_iso[8]=
    {TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4,
     TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4, TILE_Y_EX_ISO/4};
/* 32x32 �̏ꍇ  �^�C����(sx,sy)����wx*wy �̗̈��� ox,oy ���炵�ăR�s�[ */
#ifdef ISO48
//�傫��BMP��48x48 �̏ꍇ
const int region_sx_small_iso[8]=
    {0, 0, 0, 0,
     TILE_X/2, TILE_X/2, TILE_X/2, TILE_X/2};
const int region_sy_small_iso[8]=
    {0, 2, 14, 26, 0, 2, 14, 26};
const int region_wx_small_iso[8]=
    {16,16,16,16, 16,16,16,16};
const int region_wy_small_iso[8]=
    {2, 12, 12, 6, 2, 12, 12, 6};
const int region_ox_small_iso[8]=
    {8,8,8, 8, 0, 0, 0, 0};
const int region_oy_small_iso[8]=
    {14,0,0,0, 14,0,0,0};
#else
//�傫��BMP��64x64 �̏ꍇ
const int region_sx_small_iso[8]=
    {0, 0, 0, 0,
     TILE_X/2, TILE_X/2, TILE_X/2, TILE_X/2};
const int region_sy_small_iso[8]=
    {0, 0, 8,24, 0, 0, 8,24};
const int region_wx_small_iso[8]={0,16,16,16, 0,16,16,16};
const int region_wy_small_iso[8]={0, 8,16, 8, 0, 8,16, 8};
const int region_ox_small_iso[8]={16,16,16, 16, 0, 0, 0, 0};
const int region_oy_small_iso[8]={0,8,0,0,0,8,0,0};
#endif
#endif // ISO
#define TREGION_0_NORMAL 0
const int region_sx_normal[1]={0};
const int region_sy_normal[1]={0};
const int region_wx_normal[1]={TILE_X};
const int region_wy_normal[1]={TILE_Y};
// ISO mode sink mask
static char *sink_mask;
/* BG tile priority */
static unsigned char tile_prio[TILE_TOTAL2];
#define PRIO_WALL 10
#define tile_is_wall(tile) (tile_prio[(tile)&TILE_FLAG_MASK]==PRIO_WALL)
/********* Image manipulation subroutines ****************/
img_type ImgLoadFileSimple(const char *name)
{
    char fname[512];
#ifdef USE_X11
    sprintf(fname,"tiles/%s.png", name);
    std::string path = datafile_path(fname, true, true);
    return ImgLoadFile(path.c_str());
#endif
#ifdef WIN32TILES
    sprintf(fname,"tiles/%s.bmp", name);
    std::string path = datafile_path(fname, true, true);
    return ImgLoadFile(path.c_str());
#endif
}
// TileImg macro
void ImgCopyFromTileImg(int idx, img_type dest, int dx, int dy, int copy,
                        char *mask = NULL, bool hilite = false)
{
    int sx = (idx % TILE_PER_ROW)*TILE_X;
    int sy = (idx / TILE_PER_ROW)*TILE_Y;
    if (hilite)
    {
        if (mask != NULL)
            ImgCopyMaskedH(TileImg, sx, sy, TILE_X, TILE_Y,
                           dest, dx, dy, mask);
        else
            ImgCopyH(TileImg, sx, sy, TILE_X, TILE_Y, dest, dx, dy, copy);
    }
    else
    {
        if (mask != NULL)
            ImgCopyMasked(TileImg, sx, sy, TILE_X, TILE_Y,
                           dest, dx, dy, mask);
        else
            ImgCopy(TileImg, sx, sy, TILE_X, TILE_Y, dest, dx, dy, copy);
    }
}
void ImgCopyToTileImg(int idx, img_type src, int sx, int sy, int copy,
                        char *mask = NULL, bool hilite = false)
{
    int dx = (idx % TILE_PER_ROW)*TILE_X;
    int dy = (idx / TILE_PER_ROW)*TILE_Y;
    if (hilite)
    {
        if (mask != NULL)
            ImgCopyMaskedH(src, sx, sy, TILE_X, TILE_Y,
                           TileImg, dx, dy, mask);
        else
            ImgCopyH(src, sx, sy, TILE_X, TILE_Y, TileImg, dx, dy, copy);
    }
    else
    {
        if (mask != NULL)
            ImgCopyMasked(src, sx, sy, TILE_X, TILE_Y,
                           TileImg, dx, dy, mask);
        else
            ImgCopy(src, sx, sy, TILE_X, TILE_Y, TileImg, dx, dy, copy);
    }
}
void TileInit()
{
    int x, y, k;
    textcolor(WHITE);
    TileImg = ImgLoadFileSimple("tile");
    PlayerImg = ImgLoadFileSimple("player");
    WallImg = ImgLoadFileSimple("wall2d");
    if (!TileImg)
    {
    cprintf("Main tile not initialized\n");
    getch();
    end(-1);
    }
    ImgSetTransparentPix(TileImg);
    if (ImgWidth(TileImg)!= TILE_X * TILE_PER_ROW ||
    ImgHeight(TileImg) < TILE_Y*( (TILE_TOTAL + TILE_PER_ROW -1)/TILE_PER_ROW))
    {
        cprintf("Main tile size invalid\n");
        getch();
        end(-1);
    }
    if (!PlayerImg)
    {
        cprintf("Player tile not initialized\n");
        getch();
        end(-1);
    }
    if (ImgWidth(PlayerImg)!= TILE_X * TILEP_PER_ROW)
    {
        cprintf("Player tile size invalid\n");
        getch();
        end(-1);
    }
    if (!WallImg)
    {
        cprintf("wall2d tile not initialized\n");
        getch();
        end(-1);
    }
    tcache_kind = TCACHE_KIND_NORMAL;
    tc_hash = 1;
    tile_xmax = tile_dngn_x;
    tile_ymax = tile_dngn_y;
    max_tcache = 4*tile_xmax*tile_ymax;
    screen_tcach_idx = (int **)malloc(sizeof(int *) * tcache_kind);
    tcache = (tile_cache **)malloc(sizeof(tile_cache *)*tcache_kind);
    tcache_head = (int *)malloc(sizeof(int)*tcache_kind*tc_hash);
    for(k=0;k<tcache_kind;k++)
    {
        screen_tcach_idx[k]= (int *)malloc(sizeof(int)* tile_xmax * tile_ymax);
	tcache[k] = (tile_cache *)malloc(sizeof(tile_cache)*max_tcache);
	for(x=0;x<tile_xmax * tile_ymax;x++)
	    screen_tcach_idx[k][x] = -1;
    }
    sink_mask = (char *)malloc(TILE_X*TILE_Y);
    init_tileflag();
    init_tcache();
    DollCacheImg = ImgCreateSimple(TILE_X, TILE_Y);
    for(x=0;x<TILE_DAT_XMAX+2;x++){
    for(y=0;y<TILE_DAT_YMAX+2;y++){
        t1buf[x][y]=0;
        t2buf[x][y]=simple_iso_tile(TILE_DNGN_UNSEEN)|TILE_FLAG_UNSEEN;
    }}
    force_redraw_tile = false;
#if 1 // TILE_MON_EQUIP
    mcache_init();
#endif
    for(x=0; x<MAX_ITEMLIST;x++)
    {
         itemlist[x]=itemlist_num[x]=itemlist_key[x]=itemlist_idx[x]=0;
    }
}
void TileResizeScreen(int x0, int y0)
{
    int k, x;
    tile_xmax = x0;
    tile_ymax = y0;
    max_tcache = 4*tile_xmax*tile_ymax;
    for(k=0;k<tcache_kind;k++)
    {
	free(screen_tcach_idx[k]);
        screen_tcach_idx[k]= (int *)malloc(sizeof(int)* tile_xmax * tile_ymax);
	free(tcache[k]);
        tcache[k] = (tile_cache *)malloc(sizeof(tile_cache)*max_tcache);
        for(x=0;x<tile_xmax * tile_ymax;x++)
        {
            screen_tcach_idx[k][x] = -1;
        }
    }
    clear_tcache();
    crawl_view.viewsz.x = tile_xmax;
    crawl_view.viewsz.y = tile_ymax;
    crawl_view.vbuf.size(crawl_view.viewsz);
}
/*** Investigate a region of specific tile whether it contains any
     picture, or it is blank ***/
int init_tileflag_aux(int tile, int xs, int ys, int wx, int wy){
    int x,y, sx,sy;
    img_type src=TileImg;
    ASSERT(tile<TILE_TOTAL2);
    sx = tile % TILE_PER_ROW;
    sx *= TILE_X;
    sy = tile / TILE_PER_ROW;
    sy *= TILE_Y;
    for(x=xs;x<xs+wx;x++){
    for(y=ys;y<ys+wy;y++){
        if(!ImgIsTransparentAt(src, sx+x, sy+y))
            return 1;
    }}
    return 0;
}
void init_tileflag(){
    int tile, flag;
    for(tile=0;tile<TILE_TOTAL2;tile++){
        flag = 0;
        tile_flag[tile]=flag;
        tile_prio[tile]=0;
    }
    for(tile=0;tile<4;tile++)
    {
        tile_prio[simple_iso_tile(TILE_DNGN_LAVA)+tile]=2;
        tile_prio[simple_iso_tile(TILE_DNGN_SHALLOW_WATER)+tile]=2;
        tile_prio[simple_iso_tile(TILE_DNGN_DEEP_WATER)+tile]=3;
    }
}
void clear_tcache(){
    int i, k, h;
    for(k=0;k<tcache_kind;k++)
    {
        tile_cache *tc =  tcache[k];
    // Decompose pointer string tcache[k] into tc_hash segments
        for (h=0; h<tc_hash;h++)
        {
        int i_start = (max_tcache*h)/tc_hash;
        int i_end   = (max_tcache*(h+1))/tc_hash -1;
            tcache_head[k*tc_hash + h] = i_start;
            for(i=i_start;i<=i_end;i++)
            {
                tc[i].id[3] = tc[i].id[2] =
                tc[i].id[1] = tc[i].id[0] = 0;
            tc[i].idx = i;
                if (i==i_start) tc[i].prev =  NULL;
                   else tc[i].prev = &tc[i-1];
                if (i==i_end) tc[i].next = NULL;
                   else tc[i].next = &tc[i+1];
            }
        }
    }
}
void init_tcache(){
    int k;
    clear_tcache();
    tcache_image = (img_type *)malloc(sizeof(img_type)*tcache_kind);
    for(k=0;k<tcache_kind;k++)
    {
        int wx = tcache_wx_normal[k];
        int wy = tcache_wy_normal[k];
        tcache_image[k] = ImgCreateSimple(wx, max_tcache*wy);
    }
}
// Move a cache to the top of pointer string
// to shorten the search time
void lift_tcache(int ix, int kind, int hash){
    int kind_n_hash = kind * tc_hash + hash;
    int head_old=tcache_head[kind_n_hash];
    tile_cache *tc = tcache[kind];
    tile_cache *p  = tc[ix].prev;
    tile_cache *n  = tc[ix].next;
    ASSERT(ix<max_tcache);
    ASSERT(head_old<max_tcache);
    ASSERT(kind<tcache_kind);
    ASSERT(hash<tc_hash);
    if(ix == head_old) return;
    if(p!=NULL) p->next = n;
    if(n!=NULL) n->prev = p;
    tcache_head[kind_n_hash] = ix;
    tc[head_old].prev = &tc[ix];
    tc[ix].next       = &tc[head_old];
}
// Find cached image of fg+bg
// If not found, compose and cache it
static int tcache_find_id_normal(int kind, int *fg, int *bg, int *is_new)
{
    unsigned int id[4];
    int i;
    int hash = 0; // Don't use hash
    int kind_n_hash = kind*tc_hash + hash;
    int nlayer = tcache_nlayer_normal[kind];
    tile_cache *tc = tcache[kind];
    tile_cache *tc0 = &tc[tcache_head[kind_n_hash]];
#if DEBUG
    int search_count =0;
#endif
    *is_new=0;
    for(i=0;i<nlayer;i++) id[i]= (fg[i]<<16)+bg[i]+1;
    while(1){
        tile_cache *next = tc0->next;
        if(tc0->id[0] == id[0]) break;
        if(tc0->id[0]==0 || next == NULL)
        {
        //end of used cache
            *is_new = 1;
            tcache_compose_normal(tc0->idx, fg, bg);
            for(i=0;i<nlayer;i++) tc0->id[i] = id[i];
            break;
        }
        tc0 = next;
#if DEBUG
        search_count++;
#endif
    }
    lift_tcache(tc0->idx, kind, hash);
#if DEBUG
//DEBUGLOG("%d\n",search_count);
#endif
    return tc0->idx;
}
/*** overlay a tile onto an exsisting image with transpalency operation */
void tcache_overlay(img_type img, int idx,
                     int tile, int region, int *copy, char *mask)
{
    int x0, y0;
    int sx= region_sx_normal[region];
    int sy= region_sy_normal[region];
    int wx= region_wx_normal[region];
    int wy= region_wy_normal[region];
    int ox=0;
    int oy=0;
    img_type src = TileImg;
    int uy=wy;
    tile &= TILE_FLAG_MASK;
    x0 = (tile % TILE_PER_ROW)*TILE_X;
    y0 = (tile / TILE_PER_ROW)*TILE_Y;
    if (mask != NULL)
    {
        if(*copy ==2)
            ImgCopyMaskedH(src, x0 + sx, y0 + sy, wx, wy,
                          img, ox, oy + idx*uy, mask);
        else
            ImgCopyMasked(src, x0 + sx, y0 + sy, wx, wy,
                          img, ox, oy + idx*uy, mask);
    *copy = 0;
        return;
    }
    // Hack: hilite rim color
    else if(*copy ==2)
    {
        *copy=0;
        ImgCopyH(src, x0 + sx, y0 + sy, wx, wy,
                      img, ox, oy + idx*uy, *copy);
        return;
    } else
    {
        ImgCopy(src, x0 + sx, y0 + sy, wx, wy,
                      img, ox, oy + idx*uy, *copy);
    }
    *copy = 0;
}
void tcache_overlay_player(img_type img, int dx, int dy,
                        int part, int idx, int ymax, int *copy)
{
    int xs, ys;
    int tidx = tilep_parts_start[part];
    int nx = tilep_parts_nx[part];
    int ny = tilep_parts_ny[part];
    int ox = tilep_parts_ox[part];
    int oy = tilep_parts_oy[part];
    int wx = TILE_X/nx;
    int wy = TILE_Y/ny;
    if(!idx)return;
    idx--;
    tidx += idx/(nx*ny);
    if (oy+wy > ymax) wy -= oy + wy - ymax;
    if (wy<=0) return;
    xs = (tidx % TILEP_PER_ROW)*TILE_X;
    ys = (tidx / TILEP_PER_ROW)*TILE_Y;
    xs += (idx % nx)*(TILE_X/nx);
    ys += ((idx/nx) % ny)*(TILE_Y/ny);
    ImgCopy(PlayerImg, xs, ys, wx, wy,
                  img, dx+ox, dy+oy, *copy);
    *copy = 0;
}
/** overlay a tile onto an exsisting image with transpalency operation */
void register_tile_mask(int tile, int region, int *copy,
	char *mask, bool smalltile)
{
    int x0, y0, x, y;
    int sx= region_sx_normal[region];
    int sy= region_sy_normal[region];
    int wx= region_wx_normal[region];
    int wy= region_wy_normal[region];
    int ox=0;
    int oy=0;
    img_type src = TileImg;
    int ux=wx;
    int uy=wy;
    tile &= TILE_FLAG_MASK;
    x0 = (tile % TILE_PER_ROW)*TILE_X;
    y0 = (tile / TILE_PER_ROW)*TILE_Y;
    if (*copy!=0) memset(mask, 0, ux*uy);
    if (*copy == 2)
    {
        if (smalltile)
        {
            ux = wx;
        }
        for(x=0;x<wx;x++){
        for(y=0;y<wy;y++){
            if(! ImgIsTransparentAt(src, x0+sx+x, y0+sy+y))
              mask[(y+oy)*ux+(x+ox)]=1;
        }}
    }
    else
    {
        for(x=0;x<wx;x+=2){
        for(y=0;y<wy;y+=2){
            if(! ImgIsTransparentAt(src, x0+sx+x, y0+sy+y))
          mask[(y+oy)*ux+(x+ox)]=1;
        }}
    }
    *copy = 0;
}
void tile_draw_grid(int kind, int xx, int yy){
    int fg[4],bg[4],ix, ix_old, is_new;
    if (xx < 0 || yy < 0 || xx >= tile_xmax || yy>= tile_ymax) return;
    fg[0] = t1buf[xx+1][yy+1];
    bg[0] = t2buf[xx+1][yy+1];
    ix_old = screen_tcach_idx[kind][xx+yy*tile_xmax];
    ix = tcache_find_id_normal(kind, fg, bg, &is_new);
    screen_tcach_idx[kind][xx+yy*tile_xmax]=ix;
    if(is_new || ix!=ix_old || force_redraw_tile)
    {
        int x_dest = tcache_ox_normal[kind]+xx* TILE_UX_NORMAL;
        int y_dest = tcache_oy_normal[kind]+yy* TILE_UY_NORMAL;
        int wx = tcache_wx_normal[kind];
        int wy = tcache_wy_normal[kind];
        ImgCopy(tcache_image[kind],
                   0, ix*wy,   wx, wy,
                   ScrBufImg, x_dest, y_dest, 1);
    }
}
void update_single_grid(int x, int y)
{
    int sx, sy, wx, wy;
    tile_draw_grid(TCACHE0_NORMAL, x, y);
    sx = x*TILE_UX_NORMAL;
    sy = y*TILE_UY_NORMAL;
    wx = TILE_UX_NORMAL;
    wy = TILE_UY_NORMAL;
    region_tile->redraw(sx, sy, sx+wx-1, sy+wy-1);
}
// Discard cache containing specific tile
void redraw_spx_tcache(int tile)
{
    int kind, idx, layer, redraw;
    int fg[4], bg[4];
    for(kind = 0; kind < tcache_kind; kind++)
    {
        int nlayer = tcache_nlayer_normal[kind];
        for(idx = 0; idx < max_tcache; idx++)
        {
            redraw = 0;
            for(layer = 0; layer < nlayer; layer++)
            {
                fg[layer] = (tcache[kind][idx].id[layer]-1)>>16;
                bg[layer] = (tcache[kind][idx].id[layer]-1)&0xffff;
                if((fg[layer]&TILE_FLAG_MASK) == tile) redraw = 1;
                if((bg[layer]&TILE_FLAG_MASK) == tile) redraw = 1;
            }
            if (redraw)
            {
                tcache_compose_normal(idx, fg, bg);
            }
        }
    }
}
void get_bbg(int bg, int *new_bg, int *bbg)
{
    int bg0 = bg & TILE_FLAG_MASK;
    *bbg=simple_iso_tile(TILE_DNGN_FLOOR);
    *new_bg= bg0;
    if(bg0 == TILE_DNGN_UNSEEN ||
      (bg0 >= TILE_DNGN_ROCK_WALL_OFS && bg0 < TILE_DNGN_WAX_WALL) ||
       bg0 == 0)
        *bbg = 0;
    else
    if( bg0 >= TILE_DNGN_FLOOR && bg0 <= TILE_DNGN_SHALLOW_WATER)
    {
        *bbg = bg;
        *new_bg = 0;
    }
}
int sink_mask_tile(int bg, int fg)
{
    int bg0 = bg & TILE_FLAG_MASK;
    if (fg == 0 || (fg & TILE_FLAG_FLYING)!=0) return 0;
/*
    if ( bg0 == simple_iso_tile(TILE_DNGN_SHALLOW_WATER))
        return TILE_MASK_SHALLOW_WATER;
    if ( bg0 == simple_iso_tile(TILE_DNGN_DEEP_WATER))
        return TILE_MASK_DEEP_WATER;
    if ( bg0 >= simple_iso_tile(TILE_DNGN_LAVA) &&
         bg0 <= simple_iso_tile(TILE_DNGN_LAVA)+3)
        return TILE_MASK_LAVA;
*/
    if ( bg0 >= simple_iso_tile(TILE_DNGN_LAVA) &&
         bg0 <= simple_iso_tile(TILE_DNGN_SHALLOW_WATER) + 3)
    {
        int result = TILE_SINK_MASK;//simple_iso_tile(TILE_SINK_MASK);
        if ((fg & TILE_FLAG_MASK) >= TILE_NORMAL)
            result = simple_iso_tile(TILE_SINK_MASK);
        //if ((fg & TILE_FLAG_MASK) >= TILE_NORMAL) result++;
        return result;
    }
    return 0;
}
//normal
void tcache_compose_normal(int ix, int *fg, int *bg){
    int bbg;
    int new_bg;
    int c=1;
    int fg0=fg[0];
    int bg0=bg[0];
    int sink;
    img_type tc_img = tcache_image[TCACHE0_NORMAL];
    get_bbg(bg0, &new_bg, &bbg);
    if(bbg) tcache_overlay(tc_img, ix, bbg, TREGION_0_NORMAL, &c, NULL);
    if(new_bg) tcache_overlay(tc_img, ix, new_bg, TREGION_0_NORMAL, &c, NULL);
    //Tile cursor
    if(bg0&TILE_FLAG_CURSOR)
    {
       int type = ((bg0&TILE_FLAG_CURSOR) == TILE_FLAG_CURSOR1) ?
            TILE_CURSOR : TILE_CURSOR2;
       if ((bg0&TILE_FLAG_CURSOR) == TILE_FLAG_CURSOR3) type = TILE_CURSOR3;
       tcache_overlay(tc_img, ix, type, TREGION_0_NORMAL, &c, NULL);
       if (type != TILE_CURSOR3) c = 2;// Hilite
    }
    if (bg0 & TILE_FLAG_RAY)
        tcache_overlay(tc_img, ix, TILE_RAY_MESH, TREGION_0_NORMAL, &c, NULL);
    if(fg0)
    {
        sink = sink_mask_tile(bg0, fg0);
        if (sink)
        {
            int flag=2;
            register_tile_mask(sink, TREGION_0_NORMAL, &flag, sink_mask);
            tcache_overlay(tc_img, ix, fg0, TREGION_0_NORMAL, &c, sink_mask);
        }
        else
            tcache_overlay(tc_img, ix, fg0, TREGION_0_NORMAL, &c, NULL);
    }
    if (fg0 & TILE_FLAG_NET)
        tcache_overlay(tc_img, ix, TILE_TRAP_NET, TREGION_0_NORMAL, &c, NULL);
    if(fg0 & TILE_FLAG_S_UNDER)
        tcache_overlay(tc_img, ix, TILE_SOMETHING_UNDER,
                        TREGION_0_NORMAL, &c, NULL);
    //Pet mark
    if((fg0&TILE_FLAG_MAY_STAB) == TILE_FLAG_PET)
         tcache_overlay(tc_img, ix, TILE_HEART, TREGION_0_NORMAL, &c, NULL);
    if((fg0&TILE_FLAG_MAY_STAB) == TILE_FLAG_STAB)
        tcache_overlay(tc_img, ix, TILE_STAB_BRAND, TREGION_0_NORMAL, &c, NULL);
    else if((fg0&TILE_FLAG_MAY_STAB) == TILE_FLAG_MAY_STAB)
        tcache_overlay(tc_img, ix, TILE_MAY_STAB_BRAND, TREGION_0_NORMAL, &c,
            NULL);
    if(bg0&TILE_FLAG_UNSEEN)
        tcache_overlay(tc_img, ix, TILE_MESH, TREGION_0_NORMAL, &c, NULL);
    if(bg0&TILE_FLAG_MM_UNSEEN)
        tcache_overlay(tc_img, ix, TILE_MAGIC_MAP_MESH, TREGION_0_NORMAL, &c, NULL);
}
// Tile cursor
int TileDrawCursor(int x, int y, int cflag)
{
    int oldc = t2buf[x+1][y+1] & TILE_FLAG_CURSOR;
    t2buf[x+1][y+1] &= ~ TILE_FLAG_CURSOR;
    t2buf[x+1][y+1] |= cflag;
    update_single_grid(x, y);
    return oldc;
}
void TileDrawBolt(int x, int y, int fg){
    t1buf[x+1][y+1]=fg | TILE_FLAG_FLYING;
    update_single_grid(x, y);
}
void StoreDungeonView(short unsigned int *tileb)
{
    int x, y;
    int count = 0;
    if (tileb == NULL)
	tileb = tb_bk;
    for(y=0;y<tile_dngn_y;y++){
    for(x=0;x<tile_dngn_x;x++){
        tileb[count] = t1buf[x+1][y+1];
        count ++;
        tileb[count] = t2buf[x+1][y+1];
        count ++;
    }}
}
void LoadDungeonView(short unsigned int *tileb)
{
    int x, y;
    int count = 0;
    if (tileb == NULL)
        tileb = tb_bk;
    for(y=0;y<tile_dngn_y;y++)
    {
        for(x=0;x<tile_dngn_x;x++)
        {
            if(tileb[count]==tileb[count+1])
                tileb[count]=0;
            t1buf[x+1][y+1] = tileb[count];
            count ++;
            t2buf[x+1][y+1] = tileb[count];
            count ++;
        }
    }
}
//Draw the tile screen once and for all
void TileDrawDungeon(short unsigned int *tileb)
{
    int x, y, kind;
    if(!TileImg)return;
    LoadDungeonView(tileb);
    extern int tile_cursor_x;
    tile_cursor_x = -1;
    for(kind=0;kind<tcache_kind;kind++)
    {
        for(x=0;x<tile_xmax;x++)
        {
            for(y=0;y<tile_ymax;y++)
            {
                tile_draw_grid(kind, x, y);
            }
        }
    }
    force_redraw_tile = false;
    TileDrawDungeonAux();
    region_tile->redraw();
}
void TileDrawFarDungeon(int cx, int cy)
{
    short unsigned int tb[TILE_DAT_YMAX*TILE_DAT_XMAX*2];
    int count = 0;
    for(int y=0; y<tile_dngn_y; y++)
    {
        for(int x=0; x<tile_dngn_x; x++)
        {
            int fg;
            int bg;
            const coord_def gc(
                cx + x - tile_dngn_x/2,
                cy + y - tile_dngn_y/2 );
            const coord_def ep = view2show(grid2view(gc));
            // mini "viewwindow" routine
            if (!map_bounds(gc))
            {
                fg = 0;
                bg = TILE_DNGN_UNSEEN;
            }
            else if (!crawl_view.in_grid_los(gc) || !env.show(ep))
            {
                fg = env.tile_bk_fg[gc.x][gc.y];
                bg = env.tile_bk_bg[gc.x][gc.y];
                if (bg == 0)
                    bg |= TILE_DNGN_UNSEEN;
                bg |=  tile_unseen_flag(gc);
            }
            else
            {
                fg = env.tile_fg[ep.x-1][ep.y-1];
                bg = env.tile_bg[ep.x-1][ep.y-1];
            }
            if (gc.x == cx && gc.y == cy)
                bg |= TILE_FLAG_CURSOR1;
            tb[count++]=fg;
            tb[count++]=bg;
        }
    }
    tile_finish_dngn(tb, cx, cy);
    TileDrawDungeon(tb);
    region_tile->redraw();
}
void TileDrawMap(int gx, int gy)
{
    TileDrawFarDungeon(gx, gy);
}
// Load optional wall tile
static void TileLoadWallAux(int idx_src, int idx_dst, img_type wall)
{
    int tile_per_row = ImgWidth(wall) / TILE_X;
    int sx = idx_src % tile_per_row;
    int sy = idx_src / tile_per_row;
    sx *= TILE_X;
    sy *= TILE_Y;
    ImgCopyToTileImg(idx_dst, wall, sx, sy, 1);
}
void WallIdx(int &wall, int &floor, int &special)
{
    special = -1;
    if (you.level_type == LEVEL_PANDEMONIUM)
    {
        switch (mcolour[env.mons_alloc[8]])
        {
        case BLUE:
        case LIGHTBLUE:
            wall = IDX_WALL_ZOT_BLUE;
            floor = IDX_FLOOR_ZOT_BLUE;
            return;
        case RED:
        case LIGHTRED:
            wall = IDX_WALL_ZOT_RED;
            floor = IDX_FLOOR_ZOT_RED;
            return;
        case MAGENTA:
        case LIGHTMAGENTA:
            wall = IDX_WALL_ZOT_MAGENTA;
            floor = IDX_FLOOR_ZOT_MAGENTA;
            return;
        case GREEN:
        case LIGHTGREEN:
            wall = IDX_WALL_ZOT_GREEN;
            floor = IDX_FLOOR_ZOT_GREEN;
            return;
        case CYAN:
        case LIGHTCYAN:
            wall = IDX_WALL_ZOT_CYAN;
            floor = IDX_FLOOR_ZOT_CYAN;
            return;
        case BROWN:
        case YELLOW:
            wall = IDX_WALL_ZOT_YELLOW;
            floor = IDX_FLOOR_ZOT_YELLOW;
            return;
        case BLACK:
        case WHITE:
        default:
            wall = IDX_WALL_ZOT_GRAY;
            floor = IDX_FLOOR_ZOT_GRAY;
            return;
        }
    }
    else if (you.level_type == LEVEL_ABYSS)
    {
        wall = IDX_WALL_UNDEAD;
        floor = IDX_FLOOR_UNDEAD;
        return;
    }
    else if (you.level_type == LEVEL_LABYRINTH)
    {
        wall = IDX_WALL_UNDEAD;
        floor = IDX_FLOOR_UNDEAD;
        return;
    }
    else if (you.level_type == LEVEL_PORTAL_VAULT)
    {
        if (you.level_type_name == "bazaar")
        {
            // Bazaar tiles here lean towards grass and dirt to emphasize
            // both the non-hostile and other-wordly aspects of the
            // portal vaults (i.e. they aren't in the dungeon, necessarily.)
            int colour = env.floor_colour;
            switch (colour)
            {
                case BLUE:
                    wall = IDX_WALL_BAZAAR_GRAY;
                    floor = IDX_FLOOR_BAZAAR_GRASS;
                    special = IDX_FLOOR_BAZAAR_GRASS1_SPECIAL;
                    return;
                case RED:
                    // Reds often have lava, which looks ridiculous
                    // next to grass or dirt, so we'll use existing
                    // floor and wall tiles here.
                    wall = IDX_WALL_ZOT_RED;
                    floor = IDX_FLOOR_VAULT;
                    special = IDX_FLOOR_BAZAAR_VAULT_SPECIAL;
                    return;
                case LIGHTBLUE:
                    wall = IDX_WALL_HIVE;
                    floor = IDX_FLOOR_BAZAAR_GRASS;
                    special = IDX_FLOOR_BAZAAR_GRASS2_SPECIAL;
                    return;
                case GREEN:
                    wall = IDX_WALL_BAZAAR_STONE;
                    floor = IDX_FLOOR_BAZAAR_GRASS;
                    special = IDX_FLOOR_BAZAAR_GRASS1_SPECIAL;
                    return;
                case MAGENTA:
                    wall = IDX_WALL_BAZAAR_STONE;
                    floor = IDX_FLOOR_BAZAAR_DIRT;
                    special = IDX_FLOOR_BAZAAR_DIRT_SPECIAL;
                    return;
                default:
                    wall = IDX_WALL_VAULT;
                    floor = IDX_FLOOR_VAULT;
                    special = IDX_FLOOR_BAZAAR_VAULT_SPECIAL;
                    return;
            }
        }
    }
    
    switch (you.where_are_you)
    {
        case BRANCH_MAIN_DUNGEON:
            wall = IDX_WALL_NORMAL;
            floor = IDX_FLOOR_NORMAL;
            return;
        case BRANCH_HIVE:
            wall = IDX_WALL_HIVE;
            floor = IDX_FLOOR_HIVE;
            return;
        case BRANCH_VAULTS:
            wall = IDX_WALL_VAULT;
            floor = IDX_FLOOR_VAULT;
            return;
        case BRANCH_ELVEN_HALLS:
        case BRANCH_HALL_OF_BLADES:
        case BRANCH_ECUMENICAL_TEMPLE:
            wall = IDX_WALL_HALL;
            floor = IDX_FLOOR_HALL;
            return;
        case BRANCH_TARTARUS:
        case BRANCH_CRYPT:
        case BRANCH_VESTIBULE_OF_HELL:
            wall = IDX_WALL_UNDEAD;
            floor = IDX_FLOOR_UNDEAD;
            return;
        case BRANCH_TOMB:
            wall = IDX_WALL_TOMB;
            floor = IDX_FLOOR_TOMB;
            return;
        case BRANCH_DIS:
            wall = IDX_WALL_ZOT_CYAN;
            floor = IDX_FLOOR_ZOT_CYAN;
            return;
        case BRANCH_GEHENNA:
        case BRANCH_INFERNO:
        case BRANCH_THE_PIT:
            wall = IDX_WALL_ZOT_RED;
            floor = IDX_FLOOR_ZOT_RED;
            return;
        case BRANCH_COCYTUS:
            wall = IDX_WALL_ICE;
            floor = IDX_FLOOR_ICE;
            return;
        case BRANCH_ORCISH_MINES:
            wall = IDX_WALL_ORC;
            floor = IDX_FLOOR_ORC;
            return;
        case BRANCH_LAIR:
            wall = IDX_WALL_LAIR;
            floor = IDX_FLOOR_LAIR;
            return;
        case BRANCH_SLIME_PITS:
            wall = IDX_WALL_SLIME;
            floor = IDX_FLOOR_SLIME;
            return;
        case BRANCH_SNAKE_PIT:
            wall = IDX_WALL_SNAKE;
            floor = IDX_FLOOR_SNAKE;
            return;
        case BRANCH_SWAMP:
            wall = IDX_WALL_SWAMP;
            floor = IDX_FLOOR_SWAMP;
            return;
        case BRANCH_SHOALS:
            wall = IDX_WALL_SWAMP;
            floor = IDX_FLOOR_SWAMP;
            return;
        case BRANCH_CAVERNS:
            wall = IDX_WALL_ORC;
            floor = IDX_FLOOR_ORC;
            return;
        case BRANCH_HALL_OF_ZOT:
            if (you.your_level - you.branch_stairs[7] <= 1)
            {
                wall = IDX_WALL_ZOT_YELLOW;
                floor = IDX_FLOOR_ZOT_YELLOW;
                return;
            }
            switch (you.your_level - you.branch_stairs[7])
            {
                case 2:
                    wall = IDX_WALL_ZOT_GREEN;
                    floor = IDX_FLOOR_ZOT_GREEN;
                    return;
                case 3:
                    wall = IDX_WALL_ZOT_CYAN;
                    floor = IDX_WALL_ZOT_CYAN;
                    return;
                case 4:
                    wall = IDX_WALL_ZOT_BLUE;
                    floor = IDX_FLOOR_ZOT_GREEN;
                    return;
                case 5:
                default:
                    wall = IDX_WALL_ZOT_MAGENTA;
                    floor = IDX_FLOOR_ZOT_MAGENTA;
                    return;
            }
        case NUM_BRANCHES:
            break;
        // NOTE: there is no default case in this switch statement so that
        // the compiler will issue a warning when new branches are created.
    }
    wall = IDX_WALL_NORMAL;
    floor = IDX_FLOOR_NORMAL;
}
void TileLoadWall(bool wizard)
{
    clear_tcache();
    force_redraw_tile = true;
    int wall_idx;
    int floor_idx;
    int special_idx;
    WallIdx(wall_idx, floor_idx, special_idx);
    // Number of flavors are generated automatically...
    floor_tile_idx = TILE_DNGN_FLOOR;
    floor_flavors = tile_W2D_count[floor_idx];
    int offset = floor_tile_idx;
    for (int i = 0; i < floor_flavors; i++)
    {
        int idx_src = tile_W2D_start[floor_idx] + i;
        int idx_dst = offset++;
        TileLoadWallAux(idx_src, idx_dst, WallImg);
    }
    wall_tile_idx = offset;
    wall_flavors = tile_W2D_count[wall_idx];
    for (int i = 0; i < wall_flavors; i++)
    {
        int idx_src = tile_W2D_start[wall_idx] + i;
        int idx_dst = offset++;
        TileLoadWallAux(idx_src, idx_dst, WallImg);
    }
    if (special_idx != -1)
    {
        special_tile_idx = offset;
        special_flavors = tile_W2D_count[special_idx];
        for (int i = 0; i < special_flavors; i++)
        {
            int idx_src = tile_W2D_start[special_idx] + i;
            int idx_dst = offset++;
            TileLoadWallAux(idx_src, idx_dst, WallImg);
        }
    }
    else
    {
        special_flavors = 0;
    }
}
#define DOLLS_MAX 11
#define PARTS_DISP_MAX 11
#define PARTS_ITEMS 12
#define TILEP_SELECT_DOLL 20
typedef struct dolls_data
{
    int parts[TILEP_PARTS_TOTAL];
} dolls_data;
static dolls_data current_doll;
static int current_gender = 0;
static int current_parts[TILEP_PARTS_TOTAL];
static bool draw_doll(img_type img, dolls_data *doll, bool force_redraw = false, bool your_doll = true)
{
    const int p_order[TILEP_PARTS_TOTAL]=
      {
        TILEP_PART_SHADOW,
        TILEP_PART_DRCWING,
        TILEP_PART_CLOAK,
        TILEP_PART_BASE,
        TILEP_PART_BOOTS,
        TILEP_PART_LEG,
        TILEP_PART_BODY,
        TILEP_PART_ARM,
        TILEP_PART_HAND1,
        TILEP_PART_HAND2,
        TILEP_PART_HAIR,
        TILEP_PART_BEARD,
        TILEP_PART_HELM,
        TILEP_PART_DRCHEAD
      };
    int p_order2[TILEP_PARTS_TOTAL];
    int i;
    int flags[TILEP_PARTS_TOTAL];
    int parts2[TILEP_PARTS_TOTAL];
    int *parts = doll->parts;
    int c=1;
    bool changed = false;
    int default_parts[TILEP_PARTS_TOTAL];
    memset(default_parts, 0, sizeof(default_parts));
    if (your_doll)
    {
        tilep_race_default(you.species, parts[TILEP_PART_BASE] % 2,
            you.experience_level, default_parts);
        if (default_parts[TILEP_PART_BASE] != parts[TILEP_PART_BASE])
            force_redraw = true;
        parts[TILEP_PART_BASE] = default_parts[TILEP_PART_BASE];
        // TODO enne - make these configurable.
        parts[TILEP_PART_DRCHEAD] = default_parts[TILEP_PART_DRCHEAD];
        parts[TILEP_PART_DRCWING] = default_parts[TILEP_PART_DRCWING];
    }
    // convert TILEP_SHOW_EQUIP into real parts number
    for(i = 0; i < TILEP_PARTS_TOTAL; i++)
    {
        parts2[i] = parts[i];
        if (parts2[i] == TILEP_SHOW_EQUIP)
        {
            switch (i)
            {
                int item;
                case TILEP_PART_HAND1:
                    item = you.equip[EQ_WEAPON];
                    if (you.attribute[ATTR_TRANSFORMATION] ==
                        TRAN_BLADE_HANDS)
                    {
                        parts2[i] = TILEP_HAND1_BLADEHAND;
                    }
                    else if (item == -1)
                    {
                        parts2[i] = 0;
                    }
                    else
                    {
                        parts2[i] = tilep_equ_weapon(you.inv[item]);
                    }
                   break;
                case TILEP_PART_HAND2:
                    item = you.equip[EQ_SHIELD];
                    if (you.attribute[ATTR_TRANSFORMATION] ==
                        TRAN_BLADE_HANDS)
                    {
                        parts2[i] = TILEP_HAND2_BLADEHAND;
                    }
                    else if (item == -1)
                    {
                        parts2[i] = 0;
                    }
                    else
                    {
                        parts2[i] = tilep_equ_shield(you.inv[item]);
                    }
                    break;
                case TILEP_PART_BODY:
                    item = you.equip[EQ_BODY_ARMOUR];
                    if (item == -1)
                        parts2[i] = 0;
                else
                        parts2[i] = tilep_equ_armour(you.inv[item]);
                    break;
                case TILEP_PART_CLOAK:
                    item = you.equip[EQ_CLOAK];
                    if (item == -1)
                        parts2[i] = 0;
                    else
                        parts2[i] = tilep_equ_cloak(you.inv[item]);
                    break;
                case TILEP_PART_HELM:
                    item = you.equip[EQ_HELMET];
                    if (item == -1)
                        parts2[i] = 0;
                    else
                        parts2[i] = tilep_equ_helm(you.inv[item]);
                    if (parts2[i] == 0 && you.mutation[MUT_HORNS] > 0)
                    {
                        switch (you.mutation[MUT_HORNS])
                        {
                            case 1:
                                parts2[i] = TILEP_HELM_HORNS1;
                                break;
                            case 2:
                                parts2[i] = TILEP_HELM_HORNS2;
                                break;
                            case 3:
                                parts2[i] = TILEP_HELM_HORNS3;
                                break;
                        }
                    }
                    break;
                case TILEP_PART_BOOTS:
                    item = you.equip[EQ_BOOTS];
                    if (item == -1)
                        parts2[i] = 0;
                    else
                        parts2[i] = tilep_equ_boots(you.inv[item]);
                    if (parts2[i] == 0 && you.mutation[MUT_HOOVES])
                        parts2[i] = TILEP_BOOTS_HOOVES;
                    break;
                case TILEP_PART_ARM:
                    item = you.equip[EQ_GLOVES];
                    if (item == -1)
                        parts2[i] = 0;
                    else
                        parts2[i] = tilep_equ_gloves(you.inv[item]);
                    // There is player_has_claws() but it is not equivalent.
                    // Claws appear if they're big enough to not wear gloves
                    // or on races that have claws.
                    if (parts2[i] == 0 && (you.mutation[MUT_CLAWS] >= 3 || 
                        you.species == SP_TROLL || you.species == SP_GHOUL))
                    {
                        parts2[i] = TILEP_ARM_CLAWS;
                    }
                    break;
                case TILEP_PART_HAIR:
                case TILEP_PART_BEARD:
                    parts2[i] = default_parts[i];
                    break;
                case TILEP_PART_LEG:
                default:
                   parts2[i] = 0;
            }
        }
        if (parts2[i] != current_parts[i])
            changed = true;
        current_parts[i] = parts2[i];
    }
    if (!changed && !force_redraw)
    {
        return false;
    }
    tilep_calc_flags(parts2, flags);
    ImgClear(img);
    // Hack: change overlay order of boots/skirts
    for(i = 0; i < TILEP_PARTS_TOTAL; i++)
        p_order2[i]=p_order[i];
    // swap boot and leg-armor
    if (parts2[TILEP_PART_LEG] < TILEP_LEG_SKIRT_OFS)
    {
        p_order2[5] = TILEP_PART_LEG;
        p_order2[4] = TILEP_PART_BOOTS;
    }
    for(i = 0; i < TILEP_PARTS_TOTAL; i++)
    {
        int p = p_order2[i];
        int ymax = TILE_Y;
        if (flags[p]==TILEP_FLAG_CUT_CENTAUR) ymax=18;
        if (flags[p]==TILEP_FLAG_CUT_NAGA) ymax=18;
        if (parts2[p] && p == TILEP_PART_BOOTS && 
            (parts2[p] == TILEP_BOOTS_NAGA_BARDING ||
            parts2[p] == TILEP_BOOTS_CENTAUR_BARDING))
        {
            // Special case for barding.  They should be in "boots" but because
            // they're double-wide, they're stored in a different part.  We just
            // intercept it here before drawing.
            char tile = parts2[p] == TILEP_BOOTS_NAGA_BARDING ?
                TILEP_SHADOW_NAGA_BARDING : TILEP_SHADOW_CENTAUR_BARDING;
            tcache_overlay_player(img, 0, 0, TILEP_PART_SHADOW, tile, 
                TILE_Y, &c);
        }
        else if(parts2[p] && flags[p])
        {
            tcache_overlay_player(img, 0, 0, p, parts2[p], ymax, &c);
        }
    }
    return true;
}
static void load_doll_data(const char *fn, dolls_data *dolls, int max,
    int *mode, int *cur)
{
    char fbuf[1024];
    int cur0 = 0;
    int mode0 = TILEP_M_DEFAULT;
    FILE *fp = NULL;
    std::string dollsTxtString = datafile_path(fn, false, true);
    const char *dollsTxt = dollsTxtString.c_str()[0] == 0 ?
        "dolls.txt" : dollsTxtString.c_str();
    if ( (fp = fopen(dollsTxt, "r")) == NULL )
    {
        // File doesn't exist.  By default, use show equipment defaults.
        // This will be saved out (if possible.)
        for (int i = 0; i < max; i++)
        {
            // Don't take gender too seriously.  -- Enne
            tilep_race_default(you.species, coinflip() ? 1 : 0,
                you.experience_level, dolls[i].parts);
            dolls[i].parts[TILEP_PART_SHADOW] = 1;
            dolls[i].parts[TILEP_PART_CLOAK] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_BOOTS] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_LEG] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_BODY] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_ARM] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_HAND1] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_HAND2] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_HAIR] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_BEARD] = TILEP_SHOW_EQUIP;
            dolls[i].parts[TILEP_PART_HELM] = TILEP_SHOW_EQUIP;
        }
    }
    else
    {
        memset(fbuf, 0, sizeof(fbuf));
        if (fscanf(fp, "%s", fbuf) != EOF)
        {
            if (strcmp(fbuf, "MODE=LOADING") == 0)
                mode0 = TILEP_M_LOADING;
        }
        if (fscanf(fp, "%s", fbuf) != EOF)
        {
            if (strncmp(fbuf, "NUM=", 4) == 0)
            {
		sscanf(fbuf, "NUM=%d",&cur0);
                if ( (cur0 < 0)||(cur0 > 10) )
                    cur0 = 0;
            }
        }
        if (max == 1)
        {
            for(int j = 0; j <= cur0; j++)
            {
                if (fscanf(fp, "%s", fbuf) != EOF)
                {
                    tilep_scan_parts(fbuf, dolls[0].parts);
                }
                else
                {
                    break;
                }
            }
        }
        else
        {
            for(int j = 0; j < max; j++)
            {
                if (fscanf(fp, "%s", fbuf) != EOF)
                {
                    tilep_scan_parts(fbuf, dolls[j].parts);
                }
                else
                {
                    break;
                }
            }
        }
        fclose(fp);
    }
    *mode = mode0;
    *cur = cur0;
    current_gender = dolls[cur0].parts[TILEP_PART_BASE] % 2;
}
void TilePlayerEdit()
{
    const int p_lines[PARTS_ITEMS]=
      {
        TILEP_SELECT_DOLL,
        TILEP_PART_BASE,
        TILEP_PART_HELM,
        TILEP_PART_HAIR,
        TILEP_PART_BEARD,
        TILEP_PART_HAND1,
        TILEP_PART_HAND2,
        TILEP_PART_ARM,
        TILEP_PART_BODY,
        TILEP_PART_LEG,
        TILEP_PART_BOOTS,
        TILEP_PART_CLOAK
      };
    const char *p_names[PARTS_ITEMS]=
    {
        "  Index:",
        "  Gendr:",
        "  Helm :",
        "  Hair :",
        "  Beard:",
        "  Weapn:",
        "  Shild:",
        "  Glove:",
        "  Armor:",
        "  Legs :",
        "  Boots:",
        "  Cloak:"
    };
    const char *gender_name[2] ={
        "Male",
        "Fem "
    };
#define display_parts_idx(part) \
{                               \
    gotoxy(10 , part + 1, GOTO_STAT);    \
    tilep_part_to_str(dolls[cur_doll].parts[ p_lines[part] ], ibuf);\
    cprintf(ibuf);\
}
    dolls_data dolls[DOLLS_MAX], undo_dolls[DOLLS_MAX];
    int copy_doll[TILEP_PARTS_TOTAL];
    //int parts[TILEP_PARTS_TOTAL];
    int i, j, k, x, y, kin, done = 0;
    int cur_doll = 0;
    int pre_part = 0;
    int cur_part = 0;
    int mode = TILEP_M_DEFAULT;
    int  d = 0;
    FILE *fp;
    char fbuf[80], ibuf[8];
    int tile_str, sx, sy;
    img_type PartsImg = ImgCreateSimple(TILE_X * PARTS_DISP_MAX, TILE_Y * 1);
    img_type DollsListImg = ImgCreateSimple( TILE_X * DOLLS_MAX, TILE_Y * 1);
    ImgClear(ScrBufImg);
    memset( copy_doll, 0, sizeof(dolls_data) );
    tilep_race_default(you.species, current_gender,
        you.experience_level, copy_doll);
    for(j = 0; j < DOLLS_MAX; j++)
    {
        memset( dolls[j].parts, 0, sizeof(dolls_data) );
        memset( undo_dolls[j].parts, 0, sizeof(dolls_data) );
        tilep_race_default(you.species, current_gender, you.experience_level,
            dolls[j].parts);
        tilep_race_default(you.species, current_gender, you.experience_level,
            undo_dolls[j].parts);
    }
    // load settings
    load_doll_data("dolls.txt", dolls, DOLLS_MAX, &mode, &cur_doll);
    for(j = 0; j < DOLLS_MAX; j++)
    {
        undo_dolls[j] = dolls[j];
    }
    clrscr();
    gotoxy(1,1, GOTO_MSG);
    mpr("Select Part              : [j][k]or[up][down]");
    mpr("Change Part/Page         : [h][l]or[left][right]/[H][L]");
    mpr("Class-Default            : [CTRL]+[D]");
    mpr("Toggle Equipment Mode    : [*]");
    mpr("Take off/Take off All    : [t]/[CTRL]+[T]");
    mpr("Copy/Paste/Undo          : [CTRL]+[C]/[CTRL]+[V]/[CTRL]+[Z]");
    mpr("Randomize                : [CTRL]+[R]");
    gotoxy(1, 8, GOTO_MSG);
    cprintf("Toggle Startup mode      : [m] (Current mode:%s)",
        ( (mode == TILEP_M_LOADING) ? "Load User's Settings":"Class Default" ));
    for (j=0; j < PARTS_ITEMS; j++)
    {
        gotoxy(1, 1+j, GOTO_STAT);
        cprintf(p_names[j]);
    }
#define PARTS_Y (TILE_Y*11)
// draw strings "Dolls/Parts" into backbuffer
    tile_str = TILE_TEXT_PARTS_E;
    sx = (tile_str % TILE_PER_ROW)*TILE_X;
    sy = (tile_str / TILE_PER_ROW)*TILE_Y;
    ImgCopy(TileImg, sx, sy, TILE_X, TILE_Y/2,
                ScrBufImg, (TILE_X * 3) - 8,(TILE_Y * 4) - 8-24, 0);
    ImgCopy(TileImg, sx, sy+ TILE_Y/2, TILE_X, TILE_Y/2,
                ScrBufImg, (TILE_X * 4) - 8,(TILE_Y * 4) - 8-24, 0);
    tile_str = TILE_TEXT_DOLLS_E;
    sx = (tile_str % TILE_PER_ROW)*TILE_X;
    sy = (tile_str / TILE_PER_ROW)*TILE_Y;
    ImgCopy(TileImg, sx, sy, TILE_X, TILE_Y/2,
                ScrBufImg, (TILE_X * 3) - 8,PARTS_Y - 8 -24, 0);
    ImgCopy(TileImg, sx, sy+ TILE_Y/2, TILE_X, TILE_Y/2,
                ScrBufImg, (TILE_X * 4) - 8,PARTS_Y - 8 -24, 0);
    ImgClear(DollsListImg);
    for(j = 0; j < DOLLS_MAX; j++)
    {
        draw_doll(DollCacheImg, &dolls[j], true);
        ImgCopy(DollCacheImg, 0, 0,
        ImgWidth(DollCacheImg), ImgHeight(DollCacheImg),
            DollsListImg, j * TILE_X, 0, 1);
    }
    done = 0;
    while (!done)
    {
        static int inc = 1;
        static int cur_inc = 1;
        ImgClear(PartsImg);
        region_tile->DrawPanel((TILE_X * 3) - 8, (TILE_Y * 4) - 8,
                   ImgWidth(PartsImg) + 16, ImgHeight(PartsImg) + 16);
        region_tile->DrawPanel((TILE_X * 3) - 8, PARTS_Y - 8,
                   ImgWidth(DollsListImg) + 16, ImgHeight(DollsListImg) + 16);
        region_tile->DrawPanel(8*TILE_X - 8, 8*TILE_Y - 8,
                   TILE_X + 16, TILE_Y + 16);
        if (cur_part == 0)
        {
            // now selecting doll index
            gotoxy(10 , 1, GOTO_STAT);
            cprintf("%02d", cur_doll);
            gotoxy(10 , 2, GOTO_STAT);
            current_gender = dolls[cur_doll].parts[TILEP_PART_BASE] % 2;
            cprintf("%s", gender_name[ current_gender ]);
            for (i = 2; i<PARTS_ITEMS; i++)
            {
                gotoxy(10 , i + 1, GOTO_STAT);
                tilep_part_to_str(dolls[cur_doll].parts[ p_lines[i] ], ibuf);
                cprintf("%s / %03d", ibuf, tilep_parts_total[ p_lines[i] ]);
            }
        }
        else
        {
            for(i = 0; i < PARTS_DISP_MAX; i++)
            {
                int index;
                if (dolls[cur_doll].parts[ p_lines[cur_part] ] 
                    == TILEP_SHOW_EQUIP)
                    index = 0;
                else
                    index = i + dolls[cur_doll].parts[ p_lines[cur_part] ] 
                      - (PARTS_DISP_MAX / 2);
                if (index < 0)
                    index = index + tilep_parts_total[ p_lines[cur_part] ] + 1;
                if (index > tilep_parts_total[ p_lines[cur_part] ])
                    index = index - tilep_parts_total[ p_lines[cur_part] ] - 1;
                tcache_overlay_player(PartsImg, i * TILE_X, 0, 
                p_lines[cur_part], index, TILE_Y, &d);
            }
            ImgCopy(PartsImg, 0, 0, ImgWidth(PartsImg), ImgHeight(PartsImg),
                          ScrBufImg, 3 * TILE_X, 4 * TILE_Y, 0);
            ImgCopyFromTileImg( TILE_CURSOR, ScrBufImg,
                  (3 + PARTS_DISP_MAX / 2) * TILE_X, 4 * TILE_Y, 0);
        }
        draw_doll(DollCacheImg, &dolls[cur_doll], true);
        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);
        ImgCopy(DollsListImg, 0, 0,
                      ImgWidth(DollsListImg), ImgHeight(DollsListImg),
                      ScrBufImg, 3 * TILE_X, PARTS_Y, 0);
        ImgCopyFromTileImg( TILE_CURSOR, ScrBufImg,
                            (3 + cur_doll) * TILE_X, PARTS_Y, 0);
        region_tile->redraw();
        gotoxy(10 , cur_part + 1, GOTO_STAT);
        if (cur_part == 1)
        {
            current_gender = dolls[cur_doll].parts[p_lines[cur_part] ]%2;
            cprintf("%s", gender_name[ current_gender ]);
        }
        else if (cur_part != 0)
        {
            tilep_part_to_str(dolls[cur_doll].parts[ p_lines[cur_part] ], ibuf);
            cprintf("%s", ibuf);
        }
        gotoxy(1, pre_part + 1, GOTO_STAT);cprintf("  ");
        gotoxy(1, cur_part + 1, GOTO_STAT);cprintf("->");
        pre_part = cur_part;
        /* Get a key */
        kin = getch();
        inc = cur_inc = 0;
        /* Analyze the key */
        switch (kin)
        {
            case 0x1B: //ESC
                done = 1;
                break;
            case 'h':
                inc = -1;
                break;
            case 'l':
                inc = +1;
                break;
            case 'H':
                inc = -PARTS_DISP_MAX;
                break;
            case 'L':
                inc = +PARTS_DISP_MAX;
                break;
            case 'j':
            {
                if (cur_part < (PARTS_ITEMS-1) )
                    cur_part += 1;
                else
                    cur_part = 0;
                break;
            }
            case 'k':
            {
                if (cur_part > 0)
                    cur_part -= 1;
                else
                    cur_part = (PARTS_ITEMS-1);
                break;
            }
            case 'm':
            {
                if (mode == TILEP_M_LOADING)
                    mode = TILEP_M_DEFAULT;
                else
                    mode = TILEP_M_LOADING;
                gotoxy(1, 8, GOTO_MSG);
                cprintf("Toggle Startup mode      : [m] (Current mode:%s)",
                    ( (mode == TILEP_M_LOADING) ? "Load User's Settings":"Class Default" ));
                break;
            }
            case 't':
            {
                if (cur_part >= 2)
                {
                    dolls[cur_doll].parts[ p_lines[cur_part] ] = 0;
                    display_parts_idx(cur_part);
                }
                break;
            }
            case CONTROL('D'):
            {
                tilep_job_default(you.char_class, current_gender,
                dolls[cur_doll].parts);
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    display_parts_idx(i);
                }
                break;
            }
            case CONTROL('T'):
            {
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    undo_dolls[cur_doll].parts[ p_lines[i] ] = dolls[cur_doll].parts[ p_lines[i] ];
                    dolls[cur_doll].parts[ p_lines[i] ] = 0;
                    display_parts_idx(i);
                }
                break;
            }
            case CONTROL('C'):
            {
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    copy_doll[ p_lines[i] ] = dolls[cur_doll].parts[ p_lines[i] ];
                }
                break;
            }
            case CONTROL('V'):
            {
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    undo_dolls[cur_doll].parts[ p_lines[i] ] = dolls[cur_doll].parts[ p_lines[i] ];
                    dolls[cur_doll].parts[ p_lines[i] ] = copy_doll[ p_lines[i] ];
                    display_parts_idx(i);
                }
                break;
            }
            case CONTROL('Z'):
            {
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    dolls[cur_doll].parts[ p_lines[i] ] = undo_dolls[cur_doll].parts[ p_lines[i] ];
                    display_parts_idx(i);
                }
                break;
            }
            case CONTROL('R'):
            {
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    undo_dolls[cur_doll].parts[ p_lines[i] ] = dolls[cur_doll].parts[ p_lines[i] ];
                }
                dolls[cur_doll].parts[TILEP_PART_CLOAK] =
                    one_chance_in(2) * ( random2(tilep_parts_total[ TILEP_PART_CLOAK ]) + 1);
                dolls[cur_doll].parts[TILEP_PART_BOOTS] =
                    ( random2(tilep_parts_total[ TILEP_PART_BOOTS ] + 1) );
                dolls[cur_doll].parts[TILEP_PART_LEG] =
                    ( random2(tilep_parts_total[ TILEP_PART_LEG ] + 1) );
                dolls[cur_doll].parts[TILEP_PART_BODY] =
                    ( random2(tilep_parts_total[ TILEP_PART_BODY ] + 1) );
                dolls[cur_doll].parts[TILEP_PART_ARM] =
                    one_chance_in(2) * ( random2(tilep_parts_total[ TILEP_PART_ARM ]) + 1);
                dolls[cur_doll].parts[TILEP_PART_HAND1] =
                    ( random2(tilep_parts_total[ TILEP_PART_HAND1 ] + 1) );
                dolls[cur_doll].parts[TILEP_PART_HAND2] =
                    one_chance_in(2) * ( random2(tilep_parts_total[ TILEP_PART_HAND2 ]) + 1);
                dolls[cur_doll].parts[TILEP_PART_HAIR] =
                    ( random2(tilep_parts_total[ TILEP_PART_HAIR ] + 1) );
                dolls[cur_doll].parts[TILEP_PART_BEARD] =
                    ( (dolls[cur_doll].parts[TILEP_PART_BASE] + 1) % 2) *
                    one_chance_in(4) * ( random2(tilep_parts_total[ TILEP_PART_BEARD ]) + 1 );
                dolls[cur_doll].parts[TILEP_PART_HELM] =
                    one_chance_in(2) * ( random2(tilep_parts_total[ TILEP_PART_HELM ]) + 1 );
                for(i = 2; i < PARTS_ITEMS; i++)
                {
                    display_parts_idx(i);
                }
                break;
            }
            case '*':
            {
                int part = p_lines[cur_part];
                int *target = &dolls[cur_doll].parts[part];
                if (part == TILEP_PART_BASE)
                      continue;
                if (*target == TILEP_SHOW_EQUIP)
                    *target = 0;
                else
                    *target = TILEP_SHOW_EQUIP;
                display_parts_idx(cur_part);
                break;
            }
#ifdef WIZARD
            case '1':
                dolls[cur_doll].parts[TILEP_PART_DRCHEAD]++;
                dolls[cur_doll].parts[TILEP_PART_DRCHEAD] %=
                tilep_parts_total[TILEP_PART_DRCHEAD] -1;
                break;
            case '2':
                dolls[cur_doll].parts[TILEP_PART_DRCWING]++;
                dolls[cur_doll].parts[TILEP_PART_DRCWING] %=
                tilep_parts_total[TILEP_PART_DRCWING] -1;
                break;
#endif
            default:
            {
            }
        }
        if (inc != 0)
        {
            int *target = &dolls[cur_doll].parts[ p_lines[cur_part] ];
            if (cur_part == 0)
            {
                if (inc > 0)
                    cur_doll++;
                else
                    cur_doll--;
                if (cur_doll < 0)
                    cur_doll = DOLLS_MAX -1;
                else if (cur_doll == DOLLS_MAX)
                    cur_doll = 0;
            }
            else if (cur_part == 1)
            {
                if (*target % 2)
                    (*target)++;
                else
                    (*target)--;
            }
            else
            {
                if (*target == TILEP_SHOW_EQUIP) continue;
                (*target) += inc;
                (*target) += tilep_parts_total[ p_lines[cur_part] ]+1;
                (*target) %= tilep_parts_total[ p_lines[cur_part] ]+1;
            }
        }
        delay(20);
    }
    current_doll = dolls[cur_doll];
    draw_doll(DollCacheImg, &current_doll);
    ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
    std::string dollsTxtString = datafile_path("dolls.txt", false, true);
    const char *dollsTxt = dollsTxtString.c_str()[0] == 0 ?
        "dolls.txt" : dollsTxtString.c_str();
    if ( (fp = fopen(dollsTxt, "w+")) == NULL )
    {
    }
    else
    {
        fprintf(fp, "MODE=%s\n", ( (mode == TILEP_M_LOADING) ? "LOADING":"DEFAULT" ) );
        fprintf(fp, "NUM=%02d\n", cur_doll);
        for(j = 0; j < DOLLS_MAX; j++)
        {
            tilep_print_parts(fbuf, dolls[j].parts);
            fprintf(fp, "%s\n", fbuf);
        }
        fclose(fp);
    }
    ImgDestroy(PartsImg);
    ImgDestroy(DollsListImg);
    ImgClear(ScrBufImg);
    redraw_spx_tcache(TILE_PLAYER);
    for(x=0;x<TILE_DAT_XMAX+2;x++){
    for(y=0;y<TILE_DAT_YMAX+2;y++){
        t1buf[x][y]=0;
    t2buf[x][y]=simple_iso_tile(TILE_DNGN_UNSEEN)|TILE_FLAG_UNSEEN;
    }}
    for(k=0;k<tcache_kind;k++)
        for(x=0;x<tile_xmax*tile_ymax;x++)
            screen_tcach_idx[k][x] = -1;
    clrscr();
    redraw_screen();
}
void TilePlayerRefresh()
{
    if (!draw_doll(DollCacheImg, &current_doll))
        return; // Not changed
    ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
    redraw_spx_tcache(TILE_PLAYER);
    force_redraw_tile = true;
    const coord_def ep = grid2view(you.pos());
    update_single_grid(ep.x-1, ep.y-1);
}
void TilePlayerInit()
{
    int i;
    int cur_doll = 0;
    int mode = TILEP_M_DEFAULT;
    dolls_data doll;
    int gender = 0;
    for(i = 0; i < TILEP_PARTS_TOTAL; i++)
        doll.parts[i] = 0;
    tilep_race_default(you.species, gender, you.experience_level, doll.parts);
    tilep_job_default(you.char_class, gender, doll.parts);
    load_doll_data("dolls.txt", &doll, 1, &mode, &cur_doll); 
    current_doll = doll;
    draw_doll(DollCacheImg, &doll);
    ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
}
void TileGhostInit(struct ghost_demon &ghost)
{
    dolls_data doll;
    int x, y;
    unsigned int pseudo_rand = ghost.values[GVAL_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_PARTS_TOTAL; x++)
    {
        doll.parts[x] = 0;
        current_parts[x] = 0;
    }
    tilep_race_default(ghost.values[GVAL_SPECIES], g_gender,
        ghost.values[GVAL_EXP_LEVEL], doll.parts);
    tilep_job_default (ghost.values[GVAL_CLASS], g_gender,  doll.parts);
    for(x = TILEP_PART_CLOAK; x < TILEP_PARTS_TOTAL; 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.values[GVAL_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.values[GVAL_BEST_SKILL];
    int dam = ghost.values[GVAL_DAMAGE];
    int p = 0;
    dam *= (5 + pseudo_rand % 11);
    dam /= 10;
    if (sk == 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;
    }
    else
    if (sk == 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;
    }
    else
    if (sk == SK_LONG_SWORDS)
    {
        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;
    }
    else
    if (sk == 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;
    }
    else
    if (sk == 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;
    }
    else
    if (sk == SK_BOWS)
        doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_BOW2;
    else
    if (sk == SK_CROSSBOWS)
        doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_CROSSBOW;
    else
    if (sk == SK_SLINGS)
        doll.parts[TILEP_PART_HAND1] = TILEP_HAND1_SLING;
    else
    if (sk == SK_UNARMED_COMBAT)
        doll.parts[TILEP_PART_HAND1] = doll.parts[TILEP_PART_HAND2] = 0;
    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);
}
void TileInitItems()
{
    for(int i=0; i<NUM_POTIONS; i++)
    {
        int special = you.item_description[IDESC_POTIONS][i];
        int tile0 = TILE_POTION_OFFSET + special % 14;
        int tile1 = TILE_POT_HEALING + i;
        ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        ImgCopyToTileImg  (tile1, DollCacheImg, 0, 0, 1);
    }
    for(int i=0; i<NUM_WANDS; i++)
    {
        int special = you.item_description[IDESC_WANDS][i];
        int tile0 = TILE_WAND_OFFSET + special % 12;
        int tile1 = TILE_WAND_FLAME + i;
        ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        ImgCopyToTileImg  (tile1, DollCacheImg, 0, 0, 1);
    }
    //Hack: call it again
    init_tileflag();
}
// Monster weapon tile
#define N_MCACHE (TILE_MCACHE_END - TILE_MCACHE_START +1)
typedef struct mcache mcache;
struct mcache
{
  bool lock_flag;
  mcache *next;
  int mon_tile;
  int equ_tile;
  int draco;
  int idx;
};
mcache mc_data[N_MCACHE];
mcache *mc_head = NULL;
static void ImgCopyDoll(int equ_tile, int hand, int ofs_x, int ofs_y)
{
    int handidx = hand == 1 ? TILEP_PART_HAND1 : TILEP_PART_HAND2;
    int nx = tilep_parts_nx[handidx];
    int ny = tilep_parts_ny[handidx];
    int ox = tilep_parts_ox[handidx];
    int oy = tilep_parts_oy[handidx];
    int wx = std::min(TILE_X/nx + ofs_x, TILE_X/nx);
    int wy = std::min(TILE_Y/ny + ofs_y, TILE_Y/ny);
    int idx = equ_tile -1;
    int tidx = tilep_parts_start[handidx] +
        idx/(nx*ny);
    //Source pos
    int xs = (tidx % TILEP_PER_ROW)*TILE_X + 
        (idx % nx)*(TILE_X/nx) - ofs_x;
    int ys = (tidx / TILEP_PER_ROW)*TILE_Y + 
        ((idx/nx) % ny)*(TILE_Y/ny) - ofs_y;
    ImgCopy(PlayerImg, xs, ys, wx, wy,
                  DollCacheImg, ox, oy, 0);
}
static void mcache_compose(int tile_idx, int mon_tile, int equ_tile)
{
    int ofs_x=0;
    int 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;
    }
    // Copy monster tile
    ImgCopyFromTileImg(mon_tile, DollCacheImg, 0, 0, 1);
    // Overlay weapon tile
    ImgCopyDoll(equ_tile, 1, ofs_x, ofs_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;
        };
        ImgCopyDoll(eq2, 2, -ofs_x, ofs_y);
    }
    // Copy to the buffer
    ImgCopyToTileImg(tile_idx, DollCacheImg, 0, 0, 1);
    redraw_spx_tcache(tile_idx);
}
static void mcache_compose_draco(int tile_idx, int race, int cls, int w)
{
    extern int draconian_color(int race, int level);
    dolls_data doll;
    int x;
    int color = draconian_color(race, -1);
    int armour = 0;
    int armour2 = 0;
    int weapon = 0;
    int weapon2 = 0;
    int arm = 0;
    for(x = 0; x < TILEP_PARTS_TOTAL; x++)
    {
        doll.parts[x] = 0;
        current_parts[x] = 0;
    }
    doll.parts[TILEP_PART_SHADOW] = 1;
    doll.parts[TILEP_PART_BASE] = TILEP_BASE_DRACONIAN + color *2;
    doll.parts[TILEP_PART_DRCWING] = 1 + color;
    doll.parts[TILEP_PART_DRCHEAD] = 1 + color;
    switch(cls)
    {
        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 = w;
            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 = w;
            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;
    ImgClear(DollCacheImg);
    draw_doll(DollCacheImg, &doll, true, false);
    // Copy to the buffer
    ImgCopyToTileImg(tile_idx, DollCacheImg, 0, 0, 1);
    redraw_spx_tcache(tile_idx);
}
static void mcache_init()
{
    int i;
    for(i=0;i<N_MCACHE;i++)
    {
        mc_data[i].lock_flag = false;
        mc_data[i].next = NULL;
        if (i!=N_MCACHE-1)
            mc_data[i].next = &mc_data[i+1];
        mc_data[i].idx = TILE_MCACHE_START + i;
        mc_data[i].mon_tile = 0;
        mc_data[i].equ_tile = 0;
        mc_data[i].draco = 0;
    }
    mc_head = &mc_data[0];
}
int get_base_idx_from_mcache(int tile_idx)
{
    for (mcache *mc = mc_head; mc != NULL; mc = mc->next)
    {
        if (mc->idx == tile_idx)
            return mc->mon_tile;
    }
    return tile_idx;
}
int get_clean_map_idx(int tile_idx)
{
    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 <= TILE_MCACHE_END)
    {
        return 0;
    }
    else
    {
        return tile_idx;
    }
}
void TileMcacheUnlock()
{
    int i;
    for(i=0;i<N_MCACHE;i++)
    {
        mc_data[i].lock_flag = false;
    }
}
int TileMcacheFind(int mon_tile, int equ_tile, int draco)
{
    mcache *mc = mc_head;
    mcache *prev = NULL;
    mcache *empty = NULL;
#ifdef DEBUG_DIAGNOSTICS
    int count = 0;
    char cache_info[40];
#endif
    int best2 = -1;
    int best3 = -1;
    while(1){
        if(mon_tile == mc->mon_tile && equ_tile == mc->equ_tile
            && draco == mc->draco)
        {
             // match found
             // move cache to the head to reduce future search time
             if (prev != NULL) prev->next = mc->next;
             if (mc != mc_head) mc->next = mc_head;
             mc_head = mc;
             // lock it
             mc->lock_flag=true;
             // return cache index
             return mc->idx;
        }
        else if(draco != 0 && mon_tile == mc->mon_tile && draco == mc->draco)
            // second best for draconian: only weapon differ
            best2 = mc->idx;
        else if(draco != 0 && mon_tile == mc->mon_tile)
            // third best for draconian: only class matches
            best3 = mc->idx;
        if (!mc->lock_flag)
            empty = mc;
        if (mc->next == NULL)
            break;
        prev = mc;
        mc = mc->next;
#ifdef DEBUG_DIAGNOSTICS
        count++;
#endif
    }//while
    // cache image not found and no room do draw it
    if(empty == NULL)
    {
#ifdef DEBUG_DIAGNOSTICS
        snprintf( cache_info, 39, "mcache (M %d, E %d) cache full",
            mon_tile, equ_tile);
        mpr(cache_info, MSGCH_DIAGNOSTICS );
#endif
        if (best2 != -1)
            return best2;
        if (best3 != -1)
            return best3;
        if (draco != 0)
            return TILE_ERROR;
        else
            return mon_tile;
    }
    mc = empty;
#ifdef DEBUG_DIAGNOSTICS
             snprintf( cache_info, 39, "mcache (M %d, E %d) newly composed",
                        mon_tile, equ_tile);
             mpr(cache_info, MSGCH_DIAGNOSTICS );
#endif
    // compose new image
    if (draco != 0)
        // race, class, weapon
        mcache_compose_draco(mc->idx, draco, mon_tile, equ_tile);
    else
        mcache_compose(mc->idx, mon_tile, equ_tile);
    mc->mon_tile = mon_tile;
    mc->equ_tile = equ_tile;
    mc->draco = draco;
    // move cache to the head to reduce future search time
    if (prev)
        prev->next = mc->next;
    if(mc != mc_head)
        mc->next = mc_head;
    mc_head = mc;
    mc->lock_flag=true;
    return mc->idx;
}
void TileDrawTitle()
{
    int winx, winy, tx, ty, x, y;
    img_type TitleImg = ImgLoadFileSimple("title");
    img_type pBuf = region_tile->backbuf;
    if (!TitleImg || !pBuf) return;
    tx  = ImgWidth(TitleImg);
    ty  = ImgHeight(TitleImg);
    winx = ImgWidth(pBuf);
    winy = ImgHeight(pBuf);
    if (tx > winx)
    {
        x = 0;
        tx = winx;
    }
    else
    {
        x = (winx - tx)/2;
    }
    if (ty > winy)
    {
        y = 0;
        ty = winy;
    }
    else
    {
        y = (winy - ty)/2;
    }
    ImgCopy(TitleImg, 0, 0, tx, ty, pBuf, x, y, 1);
    region_tile->make_active();
    region_tile->redraw();
    ImgDestroy(TitleImg);
}
static void TilePutch(int c, img_type Dest, int dx, int dy)
{
    int tidx = TILE_CHAR00 + (c-32)/8;
    int tidx2 = c & 7;
    int sx = (tidx % TILE_PER_ROW)*TILE_X + (tidx2 % 4)*(TILE_X/4);
    int sy = (tidx / TILE_PER_ROW)*TILE_Y + (tidx2 / 4)*(TILE_Y/2);;
    ImgCopy(TileImg, sx, sy, TILE_X/4, TILE_Y/2,
              Dest, dx, dy, 0);
}
void TileRedrawInv(int region)
{
    TileRegionClass *r = (region == REGION_INV1) ? region_item:region_item2;
    r->flag = true;
    r->make_active();
    r->redraw();
}
void TileClearInv(int region)
{
    TileRegionClass *r = (region == REGION_INV1) ? region_item:region_item2;
    for (int i = 0; i < r->mx * r->my; i++)
    {
        TileDrawOneItem(region, i, 0, -1, -1, -1, false, false, false, false, false);
    }
    last_cursor = -1;
    itemlist_n = 0;
}
void TileDrawOneItem(int region, int i, char key, int idx,
    int tile, int num, bool floor,
    bool select, bool equip, bool tried, bool cursed)
{
    ASSERT(idx >= -1 && idx < MAX_ITEMS);
    TileRegionClass *r = (region == REGION_INV1) ? region_item:region_item2;
    int item_x = r->mx;
    int dx = (i % item_x)*TILE_X;
    int dy = (i / item_x)*TILE_Y;
    if (tile == -1)
    {
        ImgCopyFromTileImg(TILE_DNGN_UNSEEN, r->backbuf, dx, dy, 1);
        return;
    }
    if (floor)
        ImgCopyFromTileImg(TILE_DNGN_FLOOR, r->backbuf, dx, dy, 1);
    else
        ImgCopyFromTileImg(TILE_ITEM_SLOT, r->backbuf, dx, dy, 1);
    if (equip)
    {
        if (cursed)
            ImgCopyFromTileImg(TILE_ITEM_SLOT_EQUIP_CURSED, r->backbuf, 
                dx, dy, 0);
        else
            ImgCopyFromTileImg(TILE_ITEM_SLOT_EQUIP, r->backbuf, dx, dy, 0);
    }
    else if (cursed)
    {
        ImgCopyFromTileImg(TILE_ITEM_SLOT_CURSED, r->backbuf, dx, dy, 0);
    }
    if (select)
        ImgCopyFromTileImg(TILE_RAY_MESH, r->backbuf, dx, dy, 0);
    if (itemlist_iflag[i] & TILEI_FLAG_CURSOR)
        ImgCopyFromTileImg(TILE_CURSOR, r->backbuf, dx, dy, 0);
    // Item tile
    ImgCopyFromTileImg(tile, r->backbuf, dx, dy, 0);
    // quantity/charge
    if (num != -1)
    {
        // If you have that many, who cares.
        if (num > 999)
            num = 999;
        const int offset_amount = TILE_X/4;
        int offset = 0;
        int c100 = num/100;
        num -= c100*100;
        if (c100)
        {
            TilePutch('0'+ c100, r->backbuf, dx+offset, dy);
            offset += offset_amount;
        }
        int c10 = num/10;
        if (c10 || c100)
        {
            TilePutch('0'+ c10, r->backbuf, dx+offset, dy);
            offset += offset_amount;
        }
        int c1 = num % 10;
        TilePutch('0'+ c1, r->backbuf, dx+offset, dy);
    }
    // '?' mark
    if (tried)
    {
        TilePutch('?', r->backbuf, dx, dy + TILE_Y/2);
    }
    // record tile information as we draw it so that we can re-draw it at will
    itemlist[i] = tile;
    itemlist_num[i] = num;
    itemlist_key[i] = key;
    itemlist_idx[i] = idx;
    itemlist_iflag[i] = 0;
    if (floor)
        itemlist_iflag[i] |= TILEI_FLAG_FLOOR;
    if (tried)
        itemlist_iflag[i] |= TILEI_FLAG_TRIED;
    if (equip)
        itemlist_iflag[i] |= TILEI_FLAG_EQUIP;
    if (cursed)
        itemlist_iflag[i] |= TILEI_FLAG_CURSE;
    if (select)
        itemlist_iflag[i] |= TILEI_FLAG_SELECT;
    if (i >= itemlist_n)
        itemlist_n = i+1;
}
void TileDrawInvData(int n, int flag, int *tiles, int *num, int *idx,
    int *iflags)
{
    int i;
    TileRegionClass *r = (flag == REGION_INV1) ? region_item:region_item2;
    r->flag = true;
    last_cursor = -1;
    int old_itemlist_n = itemlist_n;
    itemlist_n = n;
    int item_x = r->mx;
    int item_y = r->my;
    for (i=0;i<item_x*item_y;i++)
    {
        if (i==MAX_ITEMLIST) break;
        int tile0 = (i>=n) ? -1 : tiles[i];
        int idx0 = (i>=n) ? -1 : idx[i];
        char key = (iflags[i]&TILEI_FLAG_FLOOR) ? 0 : index_to_letter(idx[i]);
        if ( flag == itemlist_flag
             && tile0  == itemlist[i]
             && num[i] == itemlist_num[i]
             && key   == itemlist_key[i]
             && idx0   == itemlist_idx[i]
             && iflags[i] == itemlist_iflag[i]
             && !force_redraw_inv
             && i < old_itemlist_n)
        {
            continue;
        }
        TileDrawOneItem(flag, i, key, idx0, tile0, num[i],
            ((iflags[i]&TILEI_FLAG_FLOOR) != 0),
            ((iflags[i]&TILEI_FLAG_SELECT) != 0),
            ((iflags[i]&TILEI_FLAG_EQUIP) != 0),
            ((iflags[i]&TILEI_FLAG_TRIED) != 0),
            ((iflags[i]&TILEI_FLAG_CURSE) != 0));
    }
    r->make_active();
    r->redraw();
    itemlist_flag = flag;
    force_redraw_inv = false;
}
void TileDrawInvCursor(int ix, bool flag)
{
    TileRegionClass *r =
        (itemlist_flag == REGION_INV1) ? region_item:region_item2;
    int tile0 = itemlist[ix];
    int num0 = itemlist_num[ix];
    if (flag)
        itemlist_iflag[ix] |= TILEI_FLAG_CURSOR;
    else
        itemlist_iflag[ix] &= ~TILEI_FLAG_CURSOR;
    TileDrawOneItem(itemlist_flag, ix, itemlist_key[ix], itemlist_idx[ix], tile0, num0,
            ((itemlist_iflag[ix]&TILEI_FLAG_FLOOR) != 0),
            ((itemlist_iflag[ix]&TILEI_FLAG_SELECT) != 0),
            ((itemlist_iflag[ix]&TILEI_FLAG_EQUIP) != 0),
            ((itemlist_iflag[ix]&TILEI_FLAG_TRIED) != 0),
            ((itemlist_iflag[ix]&TILEI_FLAG_CURSE) != 0)
            );
    r->redraw();
}
void TileMoveInvCursor(int ix)
{
    if (last_cursor != -1)
        TileDrawInvCursor(last_cursor, false);
    if (ix != -1) TileDrawInvCursor(ix, true);
    last_cursor = ix;
}
int TileInvIdx(int i)
{
    if (i >= itemlist_n)
        return -1;
    else
        return itemlist_idx[i];
}
#endif

#ifdef USE_TILE
#include <stdio.h>
#include "AppHdr.h"
#include "direct.h"
#include "externs.h"
#include "food.h"
#include "itemname.h"
#include "items.h"
#include "itemprop.h"
#include "macro.h"
#include "monstuff.h"
#include "mon-util.h"
#include "player.h"
#include "randart.h"
#include "stuff.h"
#include "terrain.h"
#include "tiles.h"
#include "tiledef-p.h"
#include "view.h"
#ifdef TILEP_DEBUG
#include "tilep-cmt.h"
#endif
/* external */
extern short get_helmet_type( const item_def &item );
extern bool player_is_airborne(void);
extern bool item_cursed( const item_def &item );
extern bool item_ident( const item_def &item, unsigned long flags );
// tile index cache to reduce tileidx() calls
static FixedArray < unsigned short, GXM, GYM > tile_dngn;
// // gv backup
static FixedArray < unsigned char, GXM, GYM > gv_now;
static FixedArray < unsigned char, GXM, GYM > wall_flag;
#define WFLAG_L 1
#define WFLAG_U 2
#define WFLAG_D 4
#define WFLAG_R 8
void TileNewLevel(bool first_time)
{
    GmapInit(false);
    TileLoadWall(false);
    tile_clear_buf();
    if (first_time)
        tile_init_flavor();
}
const int TILE_TODO = TILE_ERROR;
/**** tile index routines ****/
int tile_unseen_flag(const coord_def& gc)
{
    if (!map_bounds(gc))
        return TILE_FLAG_UNSEEN;
    else if (is_terrain_known(gc.x,gc.y)
        && !is_terrain_seen(gc.x,gc.y)
        || is_envmap_detected_item(gc.x,gc.y)
        || is_envmap_detected_mons(gc.x,gc.y))
    {
        return TILE_FLAG_MM_UNSEEN;
    }
    else
    {
        return TILE_FLAG_UNSEEN;
    }
}
int tileidx_monster(int mon_idx)
{
  int ch = TILE_ERROR;
  int mons = menv[mon_idx].type;
  switch(mons)
  {
  case MONS_GIANT_ANT: ch=TILE_MONS_GIANT_ANT; break;
  case MONS_GIANT_BAT: ch=TILE_MONS_GIANT_BAT; break;
  case MONS_CENTAUR: ch=TILE_MONS_CENTAUR; break;
  case MONS_RED_DEVIL: ch=TILE_MONS_RED_DEVIL; break;
  case MONS_ETTIN: ch=TILE_MONS_ETTIN; break;
  case MONS_FUNGUS: ch=TILE_MONS_FUNGUS; break;
  case MONS_GOBLIN: ch=TILE_MONS_GOBLIN; break;
  case MONS_HOUND: ch=TILE_MONS_HOUND; break;
  case MONS_IMP: ch=TILE_MONS_IMP; break;
  case MONS_JACKAL: ch=TILE_MONS_JACKAL; break;
  case MONS_KILLER_BEE: ch=TILE_MONS_KILLER_BEE; break;
  case MONS_KILLER_BEE_LARVA: ch=TILE_MONS_KILLER_BEE_LARVA; break;
  case MONS_MANTICORE: ch=TILE_MONS_MANTICORE; break;
  case MONS_NECROPHAGE: ch=TILE_MONS_NECROPHAGE; break;
  case MONS_ORC: ch=TILE_MONS_ORC; break;
  case MONS_PHANTOM: ch=TILE_MONS_PHANTOM; break;
  case MONS_QUASIT: ch=TILE_MONS_QUASIT; break;
  case MONS_RAT: ch=TILE_MONS_RAT; break;
  case MONS_SCORPION: ch=TILE_MONS_SCORPION; break;
  case MONS_UGLY_THING : ch=TILE_MONS_UGLY_THING ; break;
  case MONS_FIRE_VORTEX: ch=TILE_MONS_FIRE_VORTEX; break;
  case MONS_WORM: ch=TILE_MONS_WORM; break;
  case MONS_ABOMINATION_SMALL: ch=TILE_MONS_ABOMINATION_SMALL; break;
  case MONS_YELLOW_WASP: ch=TILE_MONS_YELLOW_WASP; break;
  case MONS_ZOMBIE_SMALL: ch=TILE_MONS_ZOMBIE_SMALL; break;
  case MONS_ANGEL: ch=TILE_MONS_ANGEL; break;
  case MONS_GIANT_BEETLE: ch=TILE_MONS_GIANT_BEETLE; break;
  case MONS_CYCLOPS: ch=TILE_MONS_CYCLOPS; break;
  case MONS_DRAGON: ch=TILE_MONS_DRAGON; break;
  case MONS_TWO_HEADED_OGRE: ch=TILE_MONS_TWO_HEADED_OGRE; break;
  case MONS_FIEND: ch=TILE_MONS_FIEND; break;
  case MONS_GIANT_SPORE: ch=TILE_MONS_GIANT_SPORE; break;
  case MONS_HOBGOBLIN: ch=TILE_MONS_HOBGOBLIN; break;
  case MONS_ICE_BEAST: ch=TILE_MONS_ICE_BEAST; break;
  case MONS_JELLY: ch=TILE_MONS_JELLY; break;
  case MONS_KOBOLD: ch=TILE_MONS_KOBOLD; break;
  case MONS_LICH: ch=TILE_MONS_LICH; break;
  case MONS_MUMMY: ch=TILE_MONS_MUMMY; break;
  case MONS_GUARDIAN_NAGA: ch=TILE_MONS_GUARDIAN_NAGA; break;
  case MONS_OGRE: ch=TILE_MONS_OGRE; break;
  case MONS_PLANT: ch=TILE_MONS_PLANT; break;
  case MONS_QUEEN_BEE: ch=TILE_MONS_QUEEN_BEE; break;
  case MONS_RAKSHASA: ch=TILE_MONS_RAKSHASA; break;
  case MONS_SNAKE: ch=TILE_MONS_SNAKE; break;
  case MONS_TROLL: ch=TILE_MONS_TROLL; break;
  case MONS_UNSEEN_HORROR: ch=TILE_MONS_UNSEEN_HORROR; break;
  case MONS_VAMPIRE: ch=TILE_MONS_VAMPIRE; break;
  case MONS_WRAITH: ch=TILE_MONS_WRAITH; break;
  case MONS_ABOMINATION_LARGE: 
  {
      // 7 different colours
      struct monsters *mon = &menv[mon_idx];
      ch = TILE_MONS_ABOMINATION_LARGE + ((mon->colour)%7);
      break;
  }
  case MONS_YAK: ch=TILE_MONS_YAK; break;
  case MONS_ZOMBIE_LARGE: ch=TILE_MONS_ZOMBIE_LARGE; break;
  case MONS_ORC_WARRIOR: ch=TILE_MONS_ORC_WARRIOR; break;
  case MONS_KOBOLD_DEMONOLOGIST: ch=TILE_MONS_KOBOLD_DEMONOLOGIST; break;
  case MONS_ORC_WIZARD: ch=TILE_MONS_ORC_WIZARD; break;
  case MONS_ORC_KNIGHT: ch=TILE_MONS_ORC_KNIGHT; break;
  case MONS_WYVERN: ch=TILE_MONS_WYVERN; break;
  case MONS_BIG_KOBOLD: ch=TILE_MONS_BIG_KOBOLD; break;
  case MONS_GIANT_EYEBALL: ch=TILE_MONS_GIANT_EYEBALL; break;
  case MONS_WIGHT: ch=TILE_MONS_WIGHT; break;
  case MONS_OKLOB_PLANT: ch=TILE_MONS_OKLOB_PLANT; break;
  case MONS_WOLF_SPIDER: ch=TILE_MONS_WOLF_SPIDER; break;
  case MONS_SHADOW: ch=TILE_MONS_SHADOW; break;
  case MONS_HUNGRY_GHOST: ch=TILE_MONS_HUNGRY_GHOST; break;
  case MONS_EYE_OF_DRAINING: ch=TILE_MONS_EYE_OF_DRAINING; break;
  case MONS_BUTTERFLY: 
  {
      // 7 different colours
      struct monsters *mon = &menv[mon_idx];
      ch = TILE_MONS_BUTTERFLY + ((mon->colour)%7);
      break;
  }
  case MONS_WANDERING_MUSHROOM: ch=TILE_MONS_WANDERING_MUSHROOM; break;
  case MONS_EFREET: ch=TILE_MONS_EFREET; break;
  case MONS_BRAIN_WORM: ch=TILE_MONS_BRAIN_WORM; break;
  case MONS_GIANT_ORANGE_BRAIN: ch=TILE_MONS_GIANT_ORANGE_BRAIN; break;
  case MONS_BOULDER_BEETLE: ch=TILE_MONS_BOULDER_BEETLE; break;
  case MONS_FLYING_SKULL: ch=TILE_MONS_FLYING_SKULL; break;
  case MONS_HELL_HOUND: ch=TILE_MONS_HELL_HOUND; break;
  case MONS_MINOTAUR: ch=TILE_MONS_MINOTAUR; break;
  case MONS_ICE_DRAGON: ch=TILE_MONS_ICE_DRAGON; break;
  case MONS_SLIME_CREATURE: ch=TILE_MONS_SLIME_CREATURE; break;
  case MONS_FREEZING_WRAITH: ch=TILE_MONS_FREEZING_WRAITH; break;
  case MONS_RAKSHASA_FAKE: ch=TILE_MONS_RAKSHASA_FAKE; break;
  case MONS_GREAT_ORB_OF_EYES: ch=TILE_MONS_GREAT_ORB_OF_EYES; break;
  case MONS_HELLION: ch=TILE_MONS_HELLION; break;
  case MONS_ROTTING_DEVIL: ch=TILE_MONS_ROTTING_DEVIL; break;
  case MONS_TORMENTOR: ch=TILE_MONS_TORMENTOR; break;
  case MONS_REAPER: ch=TILE_MONS_REAPER; break;
  case MONS_SOUL_EATER: ch=TILE_MONS_SOUL_EATER; break;
  case MONS_HAIRY_DEVIL: ch=TILE_MONS_HAIRY_DEVIL; break;
  case MONS_ICE_DEVIL: ch=TILE_MONS_ICE_DEVIL; break;
  case MONS_BLUE_DEVIL: ch=TILE_MONS_BLUE_DEVIL; break;
  case MONS_BEAST: ch=TILE_MONS_BEAST; break;
  case MONS_IRON_DEVIL: ch=TILE_MONS_IRON_DEVIL; break;
  case MONS_GLOWING_SHAPESHIFTER: ch=TILE_MONS_GLOWING_SHAPESHIFTER; break;
  case MONS_SHAPESHIFTER: ch=TILE_MONS_SHAPESHIFTER; break;
  case MONS_GIANT_MITE: ch=TILE_MONS_GIANT_MITE; break;
  case MONS_STEAM_DRAGON: ch=TILE_MONS_STEAM_DRAGON; break;
  case MONS_VERY_UGLY_THING: ch=TILE_MONS_VERY_UGLY_THING; break;
  case MONS_ORC_SORCERER: ch=TILE_MONS_ORC_SORCERER; break;
  case MONS_HIPPOGRIFF: ch=TILE_MONS_HIPPOGRIFF; break;
  case MONS_GRIFFON: ch=TILE_MONS_GRIFFON; break;
  case MONS_HYDRA: 
  {
      // Number of heads
      struct monsters *mon = &menv[mon_idx];
      int  heads = mon->number;
      if (heads > 7) heads = 7;
      ch = TILE_MONS_HYDRA + heads - 1;
      break;
  }
  case MONS_SKELETON_SMALL: ch=TILE_MONS_SKELETON_SMALL; break;
  case MONS_SKELETON_LARGE: ch=TILE_MONS_SKELETON_LARGE; break;
  case MONS_HELL_KNIGHT: ch=TILE_MONS_HELL_KNIGHT; break;
  case MONS_NECROMANCER: ch=TILE_MONS_NECROMANCER; break;
  case MONS_WIZARD: ch=TILE_MONS_WIZARD; break;
  case MONS_ORC_PRIEST: ch=TILE_MONS_ORC_PRIEST; break;
  case MONS_ORC_HIGH_PRIEST: ch=TILE_MONS_ORC_HIGH_PRIEST; break;
  case MONS_HUMAN: ch=TILE_MONS_HUMAN; break;
  case MONS_GNOLL: ch=TILE_MONS_GNOLL; break;
  case MONS_CLAY_GOLEM: ch=TILE_MONS_CLAY_GOLEM; break;
  case MONS_WOOD_GOLEM: ch=TILE_MONS_WOOD_GOLEM; break;
  case MONS_STONE_GOLEM: ch=TILE_MONS_STONE_GOLEM; break;
  case MONS_IRON_GOLEM: ch=TILE_MONS_IRON_GOLEM; break;
  case MONS_CRYSTAL_GOLEM: ch=TILE_MONS_CRYSTAL_GOLEM; break;
  case MONS_TOENAIL_GOLEM: ch=TILE_MONS_TOENAIL_GOLEM; break;
  case MONS_MOTTLED_DRAGON: ch=TILE_MONS_MOTTLED_DRAGON; break;
  case MONS_EARTH_ELEMENTAL: ch=TILE_MONS_EARTH_ELEMENTAL; break;
  case MONS_FIRE_ELEMENTAL: ch=TILE_MONS_FIRE_ELEMENTAL; break;
  case MONS_AIR_ELEMENTAL: ch=TILE_MONS_AIR_ELEMENTAL; break;
  case MONS_ICE_FIEND: ch=TILE_MONS_ICE_FIEND; break;
  case MONS_SHADOW_FIEND: ch=TILE_MONS_SHADOW_FIEND; break;
  case MONS_BROWN_SNAKE: ch=TILE_MONS_BROWN_SNAKE; break;
  case MONS_GIANT_LIZARD: ch=TILE_MONS_GIANT_LIZARD; break;
  case MONS_SPECTRAL_WARRIOR: ch=TILE_MONS_SPECTRAL_WARRIOR; break;
  case MONS_PULSATING_LUMP: ch=TILE_MONS_PULSATING_LUMP; break;
  case MONS_STORM_DRAGON: ch=TILE_MONS_STORM_DRAGON; break;
  case MONS_YAKTAUR: ch=TILE_MONS_YAKTAUR; break;
  case MONS_DEATH_YAK: ch=TILE_MONS_DEATH_YAK; break;
  case MONS_ROCK_TROLL: ch=TILE_MONS_ROCK_TROLL; break;
  case MONS_STONE_GIANT: ch=TILE_MONS_STONE_GIANT; break;
  case MONS_FLAYED_GHOST: ch=TILE_MONS_FLAYED_GHOST; break;
  case MONS_BUMBLEBEE: ch=TILE_MONS_BUMBLEBEE; break;
  case MONS_REDBACK: ch=TILE_MONS_REDBACK; break;
  case MONS_INSUBSTANTIAL_WISP: ch=TILE_MONS_INSUBSTANTIAL_WISP; break;
  case MONS_VAPOUR: ch=TILE_MONS_VAPOUR; break;
  case MONS_OGRE_MAGE: ch=TILE_MONS_OGRE_MAGE; break;
  case MONS_SPINY_WORM: ch=TILE_MONS_SPINY_WORM; break;
  case MONS_DANCING_WEAPON: 
  {
      // Use item tile
      item_def item = mitm[menv[mon_idx].inv[MSLOT_WEAPON]];
      ch = tileidx_item(item);
      break;
  }
  case MONS_TITAN: ch=TILE_MONS_TITAN; break;
  case MONS_GOLDEN_DRAGON: ch=TILE_MONS_GOLDEN_DRAGON; break;
  case MONS_ELF: ch=TILE_MONS_ELF; break;
  case MONS_LINDWURM: ch=TILE_MONS_LINDWURM; break;
  case MONS_ELEPHANT_SLUG: ch=TILE_MONS_ELEPHANT_SLUG; break;
  case MONS_WAR_DOG: ch=TILE_MONS_WAR_DOG; break;
  case MONS_GREY_RAT: ch=TILE_MONS_GREY_RAT; break;
  case MONS_GREEN_RAT: ch=TILE_MONS_GREEN_RAT; break;
  case MONS_ORANGE_RAT: ch=TILE_MONS_ORANGE_RAT; break;
  case MONS_BLACK_SNAKE: ch=TILE_MONS_BLACK_SNAKE; break;
  case MONS_SHEEP: ch=TILE_MONS_SHEEP; break;
  case MONS_GHOUL: ch=TILE_MONS_GHOUL; break;
  case MONS_HOG: ch=TILE_MONS_HOG; break;
  case MONS_GIANT_MOSQUITO: ch=TILE_MONS_GIANT_MOSQUITO; break;
  case MONS_GIANT_CENTIPEDE: ch=TILE_MONS_GIANT_CENTIPEDE; break;
  case MONS_IRON_TROLL: ch=TILE_MONS_IRON_TROLL; break;
  case MONS_NAGA: ch=TILE_MONS_NAGA; break;
  case MONS_FIRE_GIANT: ch=TILE_MONS_FIRE_GIANT; break;
  case MONS_FROST_GIANT: ch=TILE_MONS_FROST_GIANT; break;
  case MONS_FIREDRAKE: ch=TILE_MONS_FIREDRAKE; break;
  case MONS_SHADOW_DRAGON: ch=TILE_MONS_SHADOW_DRAGON; break;
  case MONS_YELLOW_SNAKE: ch=TILE_MONS_YELLOW_SNAKE; break;
  case MONS_GREY_SNAKE: ch=TILE_MONS_GREY_SNAKE; break;
  case MONS_DEEP_TROLL: ch=TILE_MONS_DEEP_TROLL; break;
  case MONS_GIANT_BLOWFLY: ch=TILE_MONS_GIANT_BLOWFLY; break;
  case MONS_RED_WASP: ch=TILE_MONS_RED_WASP; break;
  case MONS_SWAMP_DRAGON: ch=TILE_MONS_SWAMP_DRAGON; break;
  case MONS_SWAMP_DRAKE: ch=TILE_MONS_SWAMP_DRAKE; break;
  case MONS_SOLDIER_ANT: ch=TILE_MONS_SOLDIER_ANT; break;
  case MONS_HILL_GIANT: ch=TILE_MONS_HILL_GIANT; break;
  case MONS_QUEEN_ANT: ch=TILE_MONS_QUEEN_ANT; break;
  case MONS_ANT_LARVA: ch=TILE_MONS_ANT_LARVA; break;
  case MONS_GIANT_FROG: ch=TILE_MONS_GIANT_FROG; break;
  case MONS_GIANT_BROWN_FROG: ch=TILE_MONS_GIANT_BROWN_FROG; break;
  case MONS_SPINY_FROG: ch=TILE_MONS_SPINY_FROG; break;
  case MONS_BLINK_FROG: ch=TILE_MONS_BLINK_FROG; break;
  case MONS_GIANT_COCKROACH: ch=TILE_MONS_GIANT_COCKROACH; break;
  case MONS_SMALL_SNAKE: ch=TILE_MONS_SMALL_SNAKE; break;
  case MONS_SHUGGOTH: ch=TILE_TODO; break;
  case MONS_WOLF: ch=TILE_MONS_WOLF; break;
  case MONS_WARG: ch=TILE_MONS_WARG; break;
  case MONS_BEAR: ch=TILE_MONS_BEAR; break;
  case MONS_GRIZZLY_BEAR: ch=TILE_MONS_GRIZZLY_BEAR; break;
  case MONS_POLAR_BEAR: ch=TILE_MONS_POLAR_BEAR; break;
  case MONS_BLACK_BEAR: ch=TILE_MONS_BLACK_BEAR; break;
  case MONS_SIMULACRUM_SMALL: ch=TILE_MONS_SIMULACRUM_SMALL; break;
  case MONS_SIMULACRUM_LARGE: ch=TILE_MONS_SIMULACRUM_LARGE; break;
  case MONS_WHITE_IMP: ch=TILE_MONS_WHITE_IMP; break;
  case MONS_LEMURE: ch=TILE_MONS_LEMURE; break;
  case MONS_UFETUBUS: ch=TILE_MONS_UFETUBUS; break;
  case MONS_MANES: ch=TILE_MONS_MANES; break;
  case MONS_MIDGE: ch=TILE_MONS_MIDGE; break;
  case MONS_NEQOXEC: ch=TILE_MONS_NEQOXEC; break;
  case MONS_ORANGE_DEMON: ch=TILE_MONS_ORANGE_DEMON; break;
  case MONS_HELLWING: ch=TILE_MONS_HELLWING; break;
  case MONS_SMOKE_DEMON: ch=TILE_MONS_SMOKE_DEMON; break;
  case MONS_YNOXINUL: ch=TILE_MONS_YNOXINUL; break;
  case MONS_EXECUTIONER: ch=TILE_MONS_EXECUTIONER; break;
  case MONS_GREEN_DEATH: ch=TILE_MONS_GREEN_DEATH; break;
  case MONS_BLUE_DEATH: ch=TILE_MONS_BLUE_DEATH; break;
  case MONS_BALRUG: ch=TILE_MONS_BALRUG; break;
  case MONS_CACODEMON: ch=TILE_MONS_CACODEMON; break;
  case MONS_DEMONIC_CRAWLER: ch=TILE_MONS_DEMONIC_CRAWLER; break;
  case MONS_SUN_DEMON: ch=TILE_MONS_SUN_DEMON; break;
  case MONS_SHADOW_IMP: ch=TILE_MONS_SHADOW_IMP; break;
  case MONS_SHADOW_DEMON: ch=TILE_MONS_SHADOW_DEMON; break;
  case MONS_LOROCYPROCA: ch=TILE_MONS_LOROCYPROCA; break;
  case MONS_SHADOW_WRAITH: ch=TILE_MONS_SHADOW_WRAITH; break;
  case MONS_GIANT_AMOEBA: ch=TILE_MONS_GIANT_AMOEBA; break;
  case MONS_GIANT_SLUG: ch=TILE_MONS_GIANT_SLUG; break;
  case MONS_GIANT_SNAIL: ch=TILE_MONS_GIANT_SNAIL; break;
  case MONS_SPATIAL_VORTEX: ch=TILE_MONS_SPATIAL_VORTEX; break;
  case MONS_PIT_FIEND: ch=TILE_MONS_PIT_FIEND; break;
  case MONS_BORING_BEETLE: ch=TILE_MONS_BORING_BEETLE; break;
  case MONS_GARGOYLE: ch=TILE_MONS_GARGOYLE; break;
  case MONS_METAL_GARGOYLE: ch=TILE_MONS_METAL_GARGOYLE; break;
  case MONS_MOLTEN_GARGOYLE: ch=TILE_MONS_MOLTEN_GARGOYLE; break;
  case MONS_PROGRAM_BUG: ch=TILE_MONS_PROGRAM_BUG; break;
  case MONS_MNOLEG: ch=TILE_MONS_MNOLEG; break;
  case MONS_LOM_LOBON: ch=TILE_MONS_LOM_LOBON; break;
  case MONS_CEREBOV: ch=TILE_MONS_CEREBOV; break;
  case MONS_GLOORX_VLOQ: ch=TILE_MONS_GLOORX_VLOQ; break;
  case MONS_MOLLUSC_LORD: ch=TILE_TODO; break;
  case MONS_NAGA_MAGE: ch=TILE_MONS_NAGA_MAGE; break;
  case MONS_NAGA_WARRIOR: ch=TILE_MONS_NAGA_WARRIOR; break;
  case MONS_ORC_WARLORD: ch=TILE_MONS_ORC_WARLORD; break;
  case MONS_DEEP_ELF_SOLDIER: ch=TILE_MONS_DEEP_ELF_SOLDIER; break;
  case MONS_DEEP_ELF_FIGHTER: ch=TILE_MONS_DEEP_ELF_FIGHTER; break;
  case MONS_DEEP_ELF_KNIGHT: ch=TILE_MONS_DEEP_ELF_KNIGHT; break;
  case MONS_DEEP_ELF_MAGE: ch=TILE_MONS_DEEP_ELF_MAGE; break;
  case MONS_DEEP_ELF_SUMMONER: ch=TILE_MONS_DEEP_ELF_SUMMONER; break;
  case MONS_DEEP_ELF_CONJURER: ch=TILE_MONS_DEEP_ELF_CONJURER; break;
  case MONS_DEEP_ELF_PRIEST: ch=TILE_MONS_DEEP_ELF_PRIEST; break;
  case MONS_DEEP_ELF_HIGH_PRIEST: ch=TILE_MONS_DEEP_ELF_HIGH_PRIEST; break;
  case MONS_DEEP_ELF_DEMONOLOGIST: ch=TILE_MONS_DEEP_ELF_DEMONOLOGIST; break;
  case MONS_DEEP_ELF_ANNIHILATOR: ch=TILE_MONS_DEEP_ELF_ANNIHILATOR; break;
  case MONS_DEEP_ELF_SORCERER: ch=TILE_MONS_DEEP_ELF_SORCERER; break;
  case MONS_DEEP_ELF_DEATH_MAGE: ch=TILE_MONS_DEEP_ELF_DEATH_MAGE; break;
  case MONS_BROWN_OOZE: ch=TILE_MONS_BROWN_OOZE; break;
  case MONS_AZURE_JELLY: ch=TILE_MONS_AZURE_JELLY; break;
  case MONS_DEATH_OOZE: ch=TILE_MONS_DEATH_OOZE; break;
  case MONS_ACID_BLOB: ch=TILE_MONS_ACID_BLOB; break;
  case MONS_ROYAL_JELLY: ch=TILE_MONS_ROYAL_JELLY; break;
  case MONS_TERENCE: ch=TILE_MONS_TERENCE; break;
  case MONS_JESSICA: ch=TILE_MONS_JESSICA; break;
  case MONS_IJYB: ch=TILE_MONS_IJYB; break;
  case MONS_SIGMUND: ch=TILE_MONS_SIGMUND; break;
  case MONS_BLORK_THE_ORC: ch=TILE_MONS_BLORK_THE_ORC; break;
  case MONS_EDMUND: ch=TILE_MONS_EDMUND; break;
  case MONS_PSYCHE: ch=TILE_MONS_PSYCHE; break;
  case MONS_EROLCHA: ch=TILE_MONS_EROLCHA; break;
  case MONS_DONALD: ch=TILE_MONS_DONALD; break;
  case MONS_URUG: ch=TILE_MONS_URUG; break;
  case MONS_MICHAEL: ch=TILE_MONS_MICHAEL; break;
  case MONS_JOSEPH: ch=TILE_MONS_JOSEPH; break;
  case MONS_SNORG: ch=TILE_MONS_SNORG; break;
  case MONS_ERICA: ch=TILE_MONS_ERICA; break;
  case MONS_JOSEPHINE: ch=TILE_MONS_JOSEPHINE; break;
  case MONS_HAROLD: ch=TILE_MONS_HAROLD; break;
  case MONS_NORBERT: ch=TILE_MONS_NORBERT; break;
  case MONS_JOZEF: ch=TILE_MONS_JOZEF; break;
  case MONS_AGNES: ch=TILE_MONS_AGNES; break;
  case MONS_MAUD: ch=TILE_MONS_MAUD; break;
  case MONS_LOUISE: ch=TILE_MONS_LOUISE; break;
  case MONS_FRANCIS: ch=TILE_MONS_FRANCIS; break;
  case MONS_FRANCES: ch=TILE_MONS_FRANCES; break;
  case MONS_RUPERT: ch=TILE_MONS_RUPERT; break;
  case MONS_WAYNE: ch=TILE_MONS_WAYNE; break;
  case MONS_DUANE: ch=TILE_MONS_DUANE; break;
  case MONS_XTAHUA: ch=TILE_MONS_XTAHUA; break;
  case MONS_NORRIS: ch=TILE_MONS_NORRIS; break;
  case MONS_FREDERICK: ch=TILE_MONS_FREDERICK; break;
  case MONS_MARGERY: ch=TILE_MONS_MARGERY; break;
  case MONS_POLYPHEMUS: ch=TILE_MONS_POLYPHEMUS; break;
  case MONS_BORIS: ch=TILE_MONS_BORIS; break;
  // Draconians handled above
  case MONS_MURRAY: ch=TILE_MONS_MURRAY; break;
  case MONS_TIAMAT: ch=TILE_MONS_TIAMAT; break;
  case MONS_DEEP_ELF_BLADEMASTER: ch=TILE_MONS_DEEP_ELF_BLADEMASTER; break;
  case MONS_DEEP_ELF_MASTER_ARCHER: ch=TILE_MONS_DEEP_ELF_MASTER_ARCHER; break;
  case MONS_GERYON: ch=TILE_MONS_GERYON; break;
  case MONS_DISPATER: ch=TILE_MONS_DISPATER; break;
  case MONS_ASMODEUS: ch=TILE_MONS_ASMODEUS; break;
  case MONS_ANTAEUS: ch=TILE_MONS_ANTAEUS; break;
  case MONS_ERESHKIGAL: ch=TILE_MONS_ERESHKIGAL; break;
  case MONS_ANCIENT_LICH: ch=TILE_MONS_ANCIENT_LICH; break;
  case MONS_OOZE: ch=TILE_MONS_OOZE; break;
  case MONS_VAULT_GUARD: ch=TILE_MONS_VAULT_GUARD; break;
  case MONS_CURSE_SKULL: ch=TILE_MONS_CURSE_SKULL; break;
  case MONS_VAMPIRE_KNIGHT: ch=TILE_MONS_VAMPIRE_KNIGHT; break;
  case MONS_VAMPIRE_MAGE: ch=TILE_MONS_VAMPIRE_MAGE; break;
  case MONS_SHINING_EYE: ch=TILE_MONS_SHINING_EYE; break;
  case MONS_ORB_GUARDIAN: ch=TILE_MONS_ORB_GUARDIAN; break;
  case MONS_DAEVA: ch=TILE_MONS_DAEVA; break;
  case MONS_SPECTRAL_THING: ch=TILE_MONS_SPECTRAL_THING; break;
  case MONS_GREATER_NAGA: ch=TILE_MONS_GREATER_NAGA; break;
  case MONS_SKELETAL_DRAGON: ch=TILE_MONS_SKELETAL_DRAGON; break;
  case MONS_TENTACLED_MONSTROSITY: ch=TILE_MONS_TENTACLED_MONSTROSITY; break;
  case MONS_SPHINX: ch=TILE_MONS_SPHINX; break;
  case MONS_ROTTING_HULK: ch=TILE_MONS_ROTTING_HULK; break;
  case MONS_GUARDIAN_MUMMY: ch=TILE_MONS_GUARDIAN_MUMMY; break;
  case MONS_GREATER_MUMMY: ch=TILE_MONS_GREATER_MUMMY; break;
  case MONS_MUMMY_PRIEST: ch=TILE_MONS_MUMMY_PRIEST; break;
  case MONS_CENTAUR_WARRIOR: ch=TILE_MONS_CENTAUR_WARRIOR; break;
  case MONS_YAKTAUR_CAPTAIN: ch=TILE_MONS_YAKTAUR_CAPTAIN; break;
  case MONS_KILLER_KLOWN: ch=TILE_MONS_KILLER_KLOWN; break;
  case MONS_ELECTRIC_GOLEM: ch=TILE_MONS_ELECTRIC_GOLEM; break;
  case MONS_BALL_LIGHTNING: ch=TILE_MONS_BALL_LIGHTNING; break;
  case MONS_ORB_OF_FIRE: ch=TILE_MONS_ORB_OF_FIRE; break;
  case MONS_QUOKKA: ch=TILE_MONS_QUOKKA; break;
  case MONS_EYE_OF_DEVASTATION: ch=TILE_MONS_EYE_OF_DEVASTATION; break;
  case MONS_MOTH_OF_WRATH: ch=TILE_MONS_MOTH_OF_WRATH; break;
  case MONS_DEATH_COB: ch=TILE_MONS_DEATH_COB; break;
  case MONS_CURSE_TOE: ch=TILE_MONS_CURSE_TOE; break;
//  case MONS_GOLD_MIMIC: ch=TILE_MONS_GOLD_MIMIC; break;
  case MONS_GOLD_MIMIC:
  case MONS_WEAPON_MIMIC:
  case MONS_ARMOUR_MIMIC:
  case MONS_SCROLL_MIMIC:
  case MONS_POTION_MIMIC:
  {
      // Use item tile
      item_def  item;
      struct monsters *mon = &menv[mon_idx];
      get_mimic_item( mon, item );
      ch = tileidx_item(item);
      break;
  }
  case MONS_HELL_HOG: ch=TILE_MONS_HELL_HOG; break;
  case MONS_SERPENT_OF_HELL: ch=TILE_MONS_SERPENT_OF_HELL; break;
  case MONS_BOGGART: ch=TILE_MONS_BOGGART; break;
  case MONS_QUICKSILVER_DRAGON: ch=TILE_MONS_QUICKSILVER_DRAGON; break;
  case MONS_IRON_DRAGON: ch=TILE_MONS_IRON_DRAGON; break;
  case MONS_SKELETAL_WARRIOR: ch=TILE_MONS_SKELETAL_WARRIOR; break;
  case MONS_PLAYER_GHOST: ch=TILE_MONS_PLAYER_GHOST; break;
  case MONS_PANDEMONIUM_DEMON: ch=TILE_MONS_PANDEMONIUM_DEMON; break;
  case MONS_GIANT_NEWT: ch=TILE_MONS_GIANT_NEWT; break;
  case MONS_GIANT_GECKO: ch=TILE_MONS_GIANT_GECKO; break;
  case MONS_GIANT_IGUANA: ch=TILE_MONS_GIANT_IGUANA; break;
  case MONS_GILA_MONSTER: ch=TILE_MONS_GILA_MONSTER; break;
  case MONS_KOMODO_DRAGON: ch=TILE_MONS_KOMODO_DRAGON; break;
  case MONS_LAVA_WORM: ch=TILE_MONS_LAVA_WORM; break;
  case MONS_LAVA_FISH: ch=TILE_MONS_LAVA_FISH; break;
  case MONS_LAVA_SNAKE: ch=TILE_MONS_LAVA_SNAKE; break;
  case MONS_SALAMANDER: ch=TILE_MONS_SALAMANDER; break;
  case MONS_BIG_FISH: ch=TILE_MONS_BIG_FISH; break;
  case MONS_GIANT_GOLDFISH: ch=TILE_MONS_GIANT_GOLDFISH; break;
  case MONS_ELECTRICAL_EEL: ch=TILE_MONS_ELECTRICAL_EEL; break;
  case MONS_JELLYFISH: ch=TILE_MONS_JELLYFISH; break;
  case MONS_WATER_ELEMENTAL: ch=TILE_MONS_WATER_ELEMENTAL; break;
  case MONS_SWAMP_WORM: ch=TILE_MONS_SWAMP_WORM; break;
  case MONS_ORANGE_STATUE: ch = TILE_DNGN_ORANGE_CRYSTAL_STATUE; break;
  case MONS_SILVER_STATUE: ch = TILE_DNGN_SILVER_STATUE; break;
  case MONS_ICE_STATUE: ch = TILE_DNGN_ICE_STATUE; break;
  case MONS_DEATH_DRAKE: ch=TILE_MONS_DEATH_DRAKE; break;
}
    if(mons_flies(&menv[mon_idx])) ch |= TILE_FLAG_FLYING;
    if(menv[mon_idx].has_ench(ENCH_HELD)) ch |= TILE_FLAG_NET;
    if(mons_friendly(&menv[mon_idx]))
    {
        ch |= TILE_FLAG_PET;
    }
    else if (Options.stab_brand != CHATTR_NORMAL && 
        mons_looks_stabbable(&menv[mon_idx]))
    {
        ch |= TILE_FLAG_STAB;
    }
    else if (Options.may_stab_brand != CHATTR_NORMAL && 
        mons_looks_distracted(&menv[mon_idx]))
    {
        ch |= TILE_FLAG_MAY_STAB;
    }
    return ch;
}
int tileidx_fixed_artifact(int special)
{
  int ch = TILE_ERROR;
  switch(special)
  {
  case SPWPN_SINGING_SWORD: ch=TILE_SPWPN_SINGING_SWORD; break;
  case SPWPN_WRATH_OF_TROG: ch=TILE_SPWPN_WRATH_OF_TROG; break;
  case SPWPN_SCYTHE_OF_CURSES: ch=TILE_SPWPN_SCYTHE_OF_CURSES; break;
  case SPWPN_MACE_OF_VARIABILITY: ch=TILE_SPWPN_MACE_OF_VARIABILITY; break;
  case SPWPN_GLAIVE_OF_PRUNE: ch=TILE_SPWPN_GLAIVE_OF_PRUNE; break;
  case SPWPN_SCEPTRE_OF_TORMENT: ch=TILE_SPWPN_SCEPTRE_OF_TORMENT; break;
  case SPWPN_SWORD_OF_ZONGULDROK: ch=TILE_SPWPN_SWORD_OF_ZONGULDROK; break;
  case SPWPN_SWORD_OF_CEREBOV: ch=TILE_SPWPN_SWORD_OF_CEREBOV; break;
  case SPWPN_STAFF_OF_DISPATER: ch=TILE_SPWPN_STAFF_OF_DISPATER; break;
  case SPWPN_SCEPTRE_OF_ASMODEUS: ch=TILE_SPWPN_SCEPTRE_OF_ASMODEUS; break;
  case SPWPN_SWORD_OF_POWER: ch=TILE_SPWPN_SWORD_OF_POWER; break;
  case SPWPN_KNIFE_OF_ACCURACY: ch=TILE_SPWPN_KNIFE_OF_ACCURACY; break;
  case SPWPN_STAFF_OF_OLGREB: ch=TILE_SPWPN_STAFF_OF_OLGREB; break;
  case SPWPN_VAMPIRES_TOOTH: ch=TILE_SPWPN_VAMPIRES_TOOTH; break;
  case SPWPN_STAFF_OF_WUCAD_MU: ch=TILE_SPWPN_STAFF_OF_WUCAD_MU; break;
  }
  return ch;
}
int tileidx_unrand_artifact(int idx)
{
    switch (idx)
    {
        case 1: return TILE_URAND_BLOODBANE;
        case 2: return TILE_URAND_SHADOWS;
        case 3: return TILE_URAND_FLAMING_DEATH;
        case 4: return TILE_URAND_IGNORANCE;
        case 5: return TILE_URAND_ZIN;
        case 6: return TILE_URAND_AUGMENTATION;
        case 7: return TILE_URAND_BRILLIANCE;
        case 8: return TILE_URAND_THIEF;
        case 9: return TILE_URAND_BULLSEYE;
        case 10: return TILE_URAND_DYROVEPREVA;
        case 11: return TILE_URAND_LEECH;
        case 12: return TILE_URAND_CEKUGOB;
        case 13: return TILE_URAND_MISFORTUNE;
        case 14: return TILE_URAND_CHILLY_DEATH;
        case 15: return TILE_URAND_FOUR_WINDS;
        case 16: return TILE_URAND_MORG;
        case 17: return TILE_URAND_FINISHER;
        case 18: return TILE_URAND_PUNK;
        case 19: return TILE_URAND_KRISHNA;
        case 20: return TILE_URAND_FLASH;
        case 21: return TILE_URAND_SKULLCRUSHER;
        case 22: return TILE_URAND_ASSASSIN;
        case 23: return TILE_URAND_GUARD;
        case 24: return TILE_URAND_JIHAD;
        case 25: return TILE_URAND_LEAR;
        case 26: return TILE_URAND_ZHOR;
        case 27: return TILE_URAND_FIERY_DEVIL;
        case 28: return TILE_URAND_SALAMANDER;
        case 29: return TILE_URAND_WAR;
        case 30: return TILE_URAND_DOOM_KNIGHT;
        case 31: return TILE_URAND_RESISTANCE;
        case 32: return TILE_URAND_FOLLY;
        case 33: return TILE_URAND_BLOODLUST;
        case 34: return TILE_URAND_EOS;
        case 35: return TILE_URAND_SHAOLIN;
        case 36: return TILE_URAND_ROBUSTNESS;
        case 37: return TILE_URAND_EDISON;
        case 38: return TILE_URAND_VOO_DOO;
        case 39: return TILE_URAND_OCTOPUS_KING;
        case 40: return TILE_URAND_DRAGONMASK;
        case 41: return TILE_URAND_ARGA;
        case 42: return TILE_URAND_ELEMENTAL;
        case 43: return TILE_URAND_SNIPER;
        case 44: return TILE_URAND_ERCHIDEL;
        case 45: return TILE_URAND_NIGHT;
        case 46: return TILE_URAND_PLUTONIUM;
        case 47: return TILE_URAND_UNDERADHUNTER;
        case 48: return TILE_URAND_DRAGON_KING;
        case 49: return TILE_URAND_ALCHEMIST;
        case 50: return TILE_URAND_FENCER;
        case 51: return TILE_URAND_MAGE;
        case 52: return TILE_URAND_BLOWGUN;
    }
    return 0;
}
int get_etype(const item_def &item)
{
    int etype;
    switch (item.flags & ISFLAG_COSMETIC_MASK)
    {
        case ISFLAG_EMBROIDERED_SHINY:
            etype = 1;
            break;
        case ISFLAG_RUNED:
            etype = 2;
            break;
        case ISFLAG_GLOWING:
            etype = 3;
            break;
        default:
            etype = is_random_artefact(item) ? 4 : 0;
            break;
    }
    return etype;
}
int tileidx_weapon(const item_def &item)
{
  int ch = TILE_ERROR;
  int race = item.flags & ISFLAG_RACIAL_MASK;
  int etype = get_etype(item);
  static const int etable[4][4] = {
    {0, 0, 0, 0}, // No ego tile
    {0, 1, 1, 1}, // One ego tile
    {0, 1, 1, 2}, // Two ego tile
    {0, 1, 2, 3}
  };
    if (etype > 1)
        etype--;
  switch(item.sub_type)
  {
    case WPN_KNIFE: ch=TILE_WPN_KNIFE; break;
    case WPN_DAGGER: 
      ch=TILE_WPN_DAGGER;
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_DAGGER_ORC;
      if (race == ISFLAG_ELVEN ) ch = TILE_WPN_DAGGER_ELF;
      break;
    case WPN_SHORT_SWORD: 
      ch=TILE_WPN_SHORT_SWORD + etable[1][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_SHORT_SWORD_ORC;
      if (race == ISFLAG_ELVEN ) ch = TILE_WPN_SHORT_SWORD_ELF;
      break;
    case WPN_QUICK_BLADE: ch=TILE_WPN_QUICK_BLADE; break;
    case WPN_SABRE: 
      ch=TILE_WPN_SABRE + etable[1][etype];
      break;
    case WPN_FALCHION: ch=TILE_WPN_FALCHION; break;
    case WPN_KATANA: 
      ch=TILE_WPN_KATANA + etable[1][etype];
      break;
    case WPN_LONG_SWORD:
      ch=TILE_WPN_LONG_SWORD + etable[1][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_LONG_SWORD_ORC;
      break;
    case WPN_GREAT_SWORD:
      ch=TILE_WPN_GREAT_SWORD + etable[1][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_GREAT_SWORD_ORC;
      break;
    case WPN_SCIMITAR:
      ch=TILE_WPN_SCIMITAR + etable[1][etype];
      break;
    case WPN_DOUBLE_SWORD: ch=TILE_WPN_DOUBLE_SWORD; break;
    case WPN_TRIPLE_SWORD: ch=TILE_WPN_TRIPLE_SWORD; break;
    case WPN_HAND_AXE: ch=TILE_WPN_HAND_AXE; break;
    case WPN_WAR_AXE: ch=TILE_WPN_WAR_AXE; break;
    case WPN_BROAD_AXE:
      ch=TILE_WPN_BROAD_AXE + etable[1][etype];
      break;
    case WPN_BATTLEAXE:
      ch=TILE_WPN_BATTLEAXE + etable[1][etype];
      break;
    case WPN_EXECUTIONERS_AXE:
      ch=TILE_WPN_EXECUTIONERS_AXE + etable[1][etype];
      break;
    case WPN_BLOWGUN:
      ch=TILE_WPN_BLOWGUN + etable[1][etype];
      break;
    case WPN_SLING: ch=TILE_WPN_SLING; break;
    case WPN_BOW:
      ch=TILE_WPN_BOW + etable[1][etype];
      break;
    case WPN_CROSSBOW:
      ch=TILE_WPN_CROSSBOW + etable[1][etype];
      break;
    case WPN_HAND_CROSSBOW:
      ch=TILE_WPN_HAND_CROSSBOW + etable[1][etype];
      break;
    case WPN_SPEAR: 
      ch=TILE_WPN_SPEAR + etable[1][etype]; 
      break;
    case WPN_TRIDENT:
      ch=TILE_WPN_TRIDENT + etable[1][etype]; 
      break;
    case WPN_HALBERD:
      ch=TILE_WPN_HALBERD + etable[1][etype]; 
      break;
    case WPN_SCYTHE:
      ch=TILE_WPN_SCYTHE + etable[1][etype]; 
      break;
    case WPN_GLAIVE:
      ch=TILE_WPN_GLAIVE + etable[1][etype]; 
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_GLAIVE_ORC;
      break;
    case WPN_QUARTERSTAFF: ch=TILE_WPN_QUARTERSTAFF; break;
    case WPN_CLUB: ch=TILE_WPN_CLUB; break;
    case WPN_HAMMER: 
      ch=TILE_WPN_HAMMER + etable[1][etype];
      break;
    case WPN_MACE:
      ch=TILE_WPN_MACE + etable[1][etype];
      break;
    case WPN_FLAIL: 
      ch=TILE_WPN_FLAIL + etable[1][etype];
      break;
    case WPN_SPIKED_FLAIL:
      ch=TILE_WPN_SPIKED_FLAIL + etable[1][etype];
      break;
    case WPN_GREAT_MACE: 
      ch=TILE_WPN_GREAT_MACE + etable[1][etype];
      break;
    case WPN_DIRE_FLAIL: 
      ch=TILE_WPN_GREAT_FLAIL + etable[1][etype];
      break;
    case WPN_MORNINGSTAR: 
      ch=TILE_WPN_MORNINGSTAR + etable[1][etype];
      break;
    case WPN_EVENINGSTAR:
      ch=TILE_WPN_EVENINGSTAR + etable[1][etype];
      break;
    case WPN_GIANT_CLUB: ch=TILE_WPN_GIANT_CLUB; break;
    case WPN_GIANT_SPIKED_CLUB: ch=TILE_WPN_GIANT_SPIKED_CLUB; break;
    case WPN_ANCUS: ch=TILE_WPN_ANCUS; break;
    case WPN_WHIP: ch=TILE_WPN_WHIP; break;
    case WPN_DEMON_BLADE: ch=TILE_WPN_DEMON_BLADE; break;
    case WPN_DEMON_WHIP: ch=TILE_WPN_DEMON_WHIP; break;
    case WPN_DEMON_TRIDENT: ch=TILE_WPN_DEMON_TRIDENT; break;
    case WPN_BLESSED_BLADE: ch=TILE_WPN_BLESSED_BLADE; break;
    case WPN_LONGBOW: ch=TILE_WPN_LONGBOW; break;
    case WPN_LAJATANG: ch=TILE_WPN_LAJATANG; break;
    case WPN_BARDICHE: ch=TILE_WPN_LOCHABER_AXE; break;
  }
  return ch;
}
int tileidx_missile(const item_def &item)
{
  int ch = TILE_ERROR;
  int brand = item.special;
  switch(item.sub_type)
  {
    case MI_STONE: ch=TILE_MI_STONE; break;
    case MI_ARROW: ch=TILE_MI_ARROW; break;
    case MI_BOLT: ch=TILE_MI_BOLT; break;
    case MI_DART: 
      ch=TILE_MI_DART; 
      if (brand == SPMSL_POISONED || brand == SPMSL_POISONED_II)
          ch = TILE_MI_DART_P;
      break;
    case MI_NEEDLE: 
      ch=TILE_MI_NEEDLE; 
      if (brand == SPMSL_POISONED || brand == SPMSL_POISONED_II)
          ch = TILE_MI_NEEDLE_P;
      break;
    case MI_LARGE_ROCK: ch=TILE_MI_LARGE_ROCK; break;
    case MI_SLING_BULLET: ch=TILE_MI_SLING_BULLET; break;
    case MI_JAVELIN: ch=TILE_MI_JAVELIN; break;
    case MI_THROWING_NET: ch=TILE_MI_THROWING_NET; break;
  }
  return ch;
}
int tileidx_armour(const item_def &item)
{
  int ch = TILE_ERROR;
  int race = item.flags & ISFLAG_RACIAL_MASK;
  int type=item.sub_type;
  int etype = get_etype(item);
  static const int etable[5][5] = {
    {0, 0, 0, 0, 0}, // No ego tile
    {0, 1, 1, 1, 1}, // One ego tile
    {0, 1, 1, 1, 2}, // Two ego tile
    {0, 1, 1, 2, 3},
    {0, 1, 2, 3, 4}
  };
  switch(type)
  {
    case ARM_ROBE: 
      ch= TILE_ARM_ROBE + etable[2][etype];
      break;
    case ARM_LEATHER_ARMOUR:
      ch=TILE_ARM_LEATHER_ARMOUR  + etable[2][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_ARM_LEATHER_ARMOUR_ORC;
      if (race == ISFLAG_ELVEN ) ch = TILE_ARM_LEATHER_ARMOUR_ELF;
      break;
    case ARM_RING_MAIL:
      ch=TILE_ARM_RING_MAIL + etable[1][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_ARM_RING_MAIL_ORC;
      if (race == ISFLAG_ELVEN ) ch = TILE_ARM_RING_MAIL_ELF;
      if (race == ISFLAG_DWARVEN ) ch = TILE_ARM_RING_MAIL_DWA;
      break;
    case ARM_SCALE_MAIL:
      ch=TILE_ARM_SCALE_MAIL + etable[1][etype];
      if (race == ISFLAG_ELVEN ) ch = TILE_ARM_SCALE_MAIL_ELF;
      break;
    case ARM_CHAIN_MAIL:
      ch=TILE_ARM_CHAIN_MAIL + etable[1][etype];
      if (race == ISFLAG_ELVEN) ch = TILE_ARM_CHAIN_MAIL_ELF;
      if (race == ISFLAG_ORCISH) ch = TILE_ARM_CHAIN_MAIL_ORC;
      break;
    case ARM_SPLINT_MAIL: ch=TILE_ARM_SPLINT_MAIL; break;
    case ARM_BANDED_MAIL: ch=TILE_ARM_BANDED_MAIL; break;
    case ARM_PLATE_MAIL:
      ch=TILE_ARM_PLATE_MAIL;
      if (race == ISFLAG_ORCISH) ch = TILE_ARM_PLATE_MAIL_ORC;
      break;
    case ARM_CRYSTAL_PLATE_MAIL: ch=TILE_ARM_CRYSTAL_PLATE_MAIL; break;
    case ARM_SHIELD: ch=TILE_ARM_SHIELD  + etable[2][etype]; break;
    case ARM_CLOAK: 
      ch=TILE_ARM_CLOAK + etable[3][etype];
      break;
    case ARM_WIZARD_HAT:
      ch=TILE_THELM_WIZARD_HAT + etable[1][etype]; break;
    case ARM_CAP:
      ch=TILE_THELM_CAP; break;
    case ARM_HELMET:
      ch=TILE_THELM_HELM  + etable[3][etype]; break;
    case ARM_GLOVES:
      ch=TILE_ARM_GLOVES  + etable[3][etype];
      break;
    case ARM_BOOTS: 
      ch=TILE_ARM_BOOTS + etable[3][etype];
      break;
    case ARM_BUCKLER: 
      ch=TILE_ARM_BUCKLER + etable[1][etype]; 
      break;
    case ARM_LARGE_SHIELD:
      ch=TILE_ARM_LARGE_SHIELD + etable[2][etype];
      break;
    case ARM_CENTAUR_BARDING: ch=TILE_ARM_CENTAUR_BARDING; break;
    case ARM_NAGA_BARDING: ch=TILE_ARM_NAGA_BARDING; break;
    case ARM_ANIMAL_SKIN: ch=TILE_ARM_ANIMAL_SKIN + etable[1][etype]; break;
    case ARM_TROLL_HIDE: ch=TILE_ARM_TROLL_HIDE; break;
    case ARM_TROLL_LEATHER_ARMOUR: ch=TILE_ARM_TROLL_LEATHER_ARMOUR; break;
    case ARM_DRAGON_HIDE: ch=TILE_ARM_DRAGON_HIDE; break;
    case ARM_DRAGON_ARMOUR: ch=TILE_ARM_DRAGON_ARMOUR; break;
    case ARM_ICE_DRAGON_HIDE: ch=TILE_ARM_ICE_DRAGON_HIDE; break;
    case ARM_ICE_DRAGON_ARMOUR: ch=TILE_ARM_ICE_DRAGON_ARMOUR; break;
    case ARM_STEAM_DRAGON_HIDE: ch=TILE_ARM_STEAM_DRAGON_HIDE; break;
    case ARM_STEAM_DRAGON_ARMOUR: ch=TILE_ARM_STEAM_DRAGON_ARMOUR; break;
    case ARM_MOTTLED_DRAGON_HIDE: ch=TILE_ARM_MOTTLED_DRAGON_HIDE; break;
    case ARM_MOTTLED_DRAGON_ARMOUR: ch=TILE_ARM_MOTTLED_DRAGON_ARMOUR; break;
    case ARM_STORM_DRAGON_HIDE: ch=TILE_ARM_STORM_DRAGON_HIDE; break;
    case ARM_STORM_DRAGON_ARMOUR: ch=TILE_ARM_STORM_DRAGON_ARMOUR; break;
    case ARM_GOLD_DRAGON_HIDE: ch=TILE_ARM_GOLD_DRAGON_HIDE; break;
    case ARM_GOLD_DRAGON_ARMOUR: ch=TILE_ARM_GOLD_DRAGON_ARMOUR; break;
    case ARM_SWAMP_DRAGON_HIDE: ch=TILE_ARM_SWAMP_DRAGON_HIDE; break;
    case ARM_SWAMP_DRAGON_ARMOUR: ch=TILE_ARM_SWAMP_DRAGON_ARMOUR; break;
  }
  return ch;
}
int tileidx_food(const item_def &item)
{
    int ch = TILE_ERROR;
    int type=item.sub_type;
    switch(type)
    {
    case FOOD_MEAT_RATION: ch=TILE_FOOD_MEAT_RATION; break;
    case FOOD_BREAD_RATION: ch=TILE_FOOD_BREAD_RATION; break;
    case FOOD_PEAR: ch=TILE_FOOD_PEAR; break;
    case FOOD_APPLE: ch=TILE_FOOD_APPLE; break;
    case FOOD_CHOKO: ch=TILE_FOOD_CHOKO; break;
    case FOOD_HONEYCOMB: ch=TILE_FOOD_HONEYCOMB; break;
    case FOOD_ROYAL_JELLY: ch=TILE_FOOD_ROYAL_JELLY; break;
    case FOOD_SNOZZCUMBER: ch=TILE_FOOD_SNOZZCUMBER; break;
    case FOOD_PIZZA: ch=TILE_FOOD_PIZZA; break;
    case FOOD_APRICOT: ch=TILE_FOOD_APRICOT; break;
    case FOOD_ORANGE: ch=TILE_FOOD_ORANGE; break;
    case FOOD_BANANA: ch=TILE_FOOD_BANANA; break;
    case FOOD_STRAWBERRY: ch=TILE_FOOD_STRAWBERRY; break;
    case FOOD_RAMBUTAN: ch=TILE_FOOD_RAMBUTAN; break;
    case FOOD_LEMON: ch=TILE_FOOD_LEMON; break;
    case FOOD_GRAPE: ch=TILE_FOOD_GRAPE; break;
    case FOOD_SULTANA: ch=TILE_FOOD_SULTANA; break;
    case FOOD_LYCHEE: ch=TILE_FOOD_LYCHEE; break;
    case FOOD_BEEF_JERKY: ch=TILE_FOOD_BEEF_JERKY; break;
    case FOOD_CHEESE: ch=TILE_FOOD_CHEESE; break;
    case FOOD_SAUSAGE: ch=TILE_FOOD_SAUSAGE; break;
    case FOOD_CHUNK: 
        ch=TILE_FOOD_CHUNK; 
        if (item.special < 100) ch = TILE_FOOD_CHUNK_ROTTEN;
        break;
    }
    return ch;
}
int tileidx_corpse(int mon)
{
  int ch = TILE_ERROR;
  switch(mon)
  {
  case MONS_GIANT_ANT: ch=TILE_CORPSE_GIANT_ANT; break;
  case MONS_GIANT_BAT: ch=TILE_CORPSE_GIANT_BAT; break;
  case MONS_CENTAUR: ch=TILE_CORPSE_CENTAUR; break;
  case MONS_GOBLIN: ch=TILE_CORPSE_GOBLIN; break;
  case MONS_HOUND: ch=TILE_CORPSE_HOUND; break;
  case MONS_JACKAL: ch=TILE_CORPSE_JACKAL; break;
  case MONS_KILLER_BEE: ch=TILE_CORPSE_KILLER_BEE; break;
  case MONS_KILLER_BEE_LARVA: ch=TILE_CORPSE_KILLER_BEE_LARVA; break;
  case MONS_MANTICORE: ch=TILE_CORPSE_MANTICORE; break;
  case MONS_NECROPHAGE: ch=TILE_CORPSE_NECROPHAGE; break;
  case MONS_ORC: ch=TILE_CORPSE_ORC; break;
  case MONS_RAT: ch=TILE_CORPSE_RAT; break;
  case MONS_SCORPION: ch=TILE_CORPSE_SCORPION; break;
  case MONS_UGLY_THING: ch=TILE_CORPSE_UGLY_THING; break;
  case MONS_WORM: ch=TILE_CORPSE_WORM; break;
  case MONS_YELLOW_WASP: ch=TILE_CORPSE_YELLOW_WASP; break;
  case MONS_GIANT_BEETLE: ch=TILE_CORPSE_GIANT_BEETLE; break;
  case MONS_CYCLOPS: ch=TILE_CORPSE_CYCLOPS; break;
  case MONS_DRAGON: ch=TILE_CORPSE_DRAGON; break;
  case MONS_TWO_HEADED_OGRE: ch=TILE_CORPSE_TWO_HEADED_OGRE; break;
  case MONS_HOBGOBLIN: ch=TILE_CORPSE_HOBGOBLIN; break;
  case MONS_KOBOLD: ch=TILE_CORPSE_KOBOLD; break;
  case MONS_GUARDIAN_NAGA: ch=TILE_CORPSE_GUARDIAN_NAGA; break;
  case MONS_OGRE: ch=TILE_CORPSE_OGRE; break;
  case MONS_QUEEN_BEE: ch=TILE_CORPSE_QUEEN_BEE; break;
  case MONS_SNAKE: ch=TILE_CORPSE_SNAKE; break;
  case MONS_TROLL: ch=TILE_CORPSE_TROLL; break;
  case MONS_YAK: ch=TILE_CORPSE_YAK; break;
  case MONS_WYVERN: ch=TILE_CORPSE_WYVERN; break;
  case MONS_GIANT_EYEBALL: ch=TILE_CORPSE_GIANT_EYEBALL; break;
  case MONS_WOLF_SPIDER: ch=TILE_CORPSE_WOLF_SPIDER; break;
  case MONS_EYE_OF_DRAINING: ch=TILE_CORPSE_EYE_OF_DRAINING; break;
  case MONS_BUTTERFLY: ch=TILE_CORPSE_BUTTERFLY; break;
  case MONS_BRAIN_WORM: ch=TILE_CORPSE_BRAIN_WORM; break;
  case MONS_GIANT_ORANGE_BRAIN: ch=TILE_CORPSE_GIANT_ORANGE_BRAIN; break;
  case MONS_BOULDER_BEETLE: ch=TILE_CORPSE_BOULDER_BEETLE; break;
  case MONS_MINOTAUR: ch=TILE_CORPSE_MINOTAUR; break;
  case MONS_ICE_DRAGON: ch=TILE_CORPSE_ICE_DRAGON; break;
  case MONS_GREAT_ORB_OF_EYES: ch=TILE_CORPSE_GREAT_ORB_OF_EYES; break;
  case MONS_GLOWING_SHAPESHIFTER: ch=TILE_CORPSE_GLOWING_SHAPESHIFTER; break;
  case MONS_SHAPESHIFTER: ch=TILE_CORPSE_SHAPESHIFTER; break;
  case MONS_GIANT_MITE: ch=TILE_CORPSE_GIANT_MITE; break;
  case MONS_STEAM_DRAGON: ch=TILE_CORPSE_STEAM_DRAGON; break;
  case MONS_VERY_UGLY_THING: ch=TILE_CORPSE_VERY_UGLY_THING; break;
//  case MONS_ORC_SORCERER: ch=TILE_CORPSE_ORC_SORCERER; break;
  case MONS_HIPPOGRIFF: ch=TILE_CORPSE_HIPPOGRIFF; break;
  case MONS_GRIFFON: ch=TILE_CORPSE_GRIFFON; break;
  case MONS_HYDRA: ch=TILE_CORPSE_HYDRA; break;
  case MONS_HELL_KNIGHT: ch=TILE_CORPSE_HELL_KNIGHT; break;
  case MONS_NECROMANCER: ch=TILE_CORPSE_NECROMANCER; break;
  case MONS_WIZARD: ch=TILE_CORPSE_WIZARD; break;
//  case MONS_ORC_PRIEST: ch=TILE_CORPSE_ORC_PRIEST; break;
//  case MONS_ORC_HIGH_PRIEST: ch=TILE_CORPSE_ORC_HIGH_PRIEST; break;
  case MONS_HUMAN: ch=TILE_CORPSE_HUMAN; break;
  case MONS_GNOLL: ch=TILE_CORPSE_GNOLL; break;
  case MONS_MOTTLED_DRAGON: ch=TILE_CORPSE_MOTTLED_DRAGON; break;
  case MONS_BROWN_SNAKE: ch=TILE_CORPSE_BROWN_SNAKE; break;
  case MONS_GIANT_LIZARD: ch=TILE_CORPSE_GIANT_LIZARD; break;
  case MONS_STORM_DRAGON: ch=TILE_CORPSE_STORM_DRAGON; break;
  case MONS_YAKTAUR: ch=TILE_CORPSE_YAKTAUR; break;
  case MONS_DEATH_YAK: ch=TILE_CORPSE_DEATH_YAK; break;
  case MONS_ROCK_TROLL: ch=TILE_CORPSE_ROCK_TROLL; break;
  case MONS_STONE_GIANT: ch=TILE_CORPSE_STONE_GIANT; break;
  case MONS_BUMBLEBEE: ch=TILE_CORPSE_BUMBLEBEE; break;
  case MONS_REDBACK: ch=TILE_CORPSE_REDBACK; break;
  case MONS_SPINY_WORM: ch=TILE_CORPSE_SPINY_WORM; break;
  case MONS_TITAN: ch=TILE_CORPSE_TITAN; break;
  case MONS_GOLDEN_DRAGON: ch=TILE_CORPSE_GOLDEN_DRAGON; break;
  case MONS_ELF: ch=TILE_CORPSE_ELF; break;
  case MONS_LINDWURM: ch=TILE_CORPSE_LINDWURM; break;
  case MONS_ELEPHANT_SLUG: ch=TILE_CORPSE_ELEPHANT_SLUG; break;
  case MONS_WAR_DOG: ch=TILE_CORPSE_WAR_DOG; break;
  case MONS_GREY_RAT: ch=TILE_CORPSE_GREY_RAT; break;
  case MONS_GREEN_RAT: ch=TILE_CORPSE_GREEN_RAT; break;
  case MONS_ORANGE_RAT: ch=TILE_CORPSE_ORANGE_RAT; break;
  case MONS_BLACK_SNAKE: ch=TILE_CORPSE_BLACK_SNAKE; break;
  case MONS_SHEEP: ch=TILE_CORPSE_SHEEP; break;
  case MONS_GHOUL: ch=TILE_CORPSE_GHOUL; break;
  case MONS_HOG: ch=TILE_CORPSE_HOG; break;
  case MONS_GIANT_MOSQUITO: ch=TILE_CORPSE_GIANT_MOSQUITO; break;
  case MONS_GIANT_CENTIPEDE: ch=TILE_CORPSE_GIANT_CENTIPEDE; break;
  case MONS_IRON_TROLL: ch=TILE_CORPSE_IRON_TROLL; break;
  case MONS_NAGA: ch=TILE_CORPSE_NAGA; break;
  case MONS_FIRE_GIANT: ch=TILE_CORPSE_FIRE_GIANT; break;
  case MONS_FROST_GIANT: ch=TILE_CORPSE_FROST_GIANT; break;
  case MONS_FIREDRAKE: ch=TILE_CORPSE_FIREDRAKE; break;
  case MONS_SHADOW_DRAGON: ch=TILE_CORPSE_SHADOW_DRAGON; break;
  case MONS_YELLOW_SNAKE: ch=TILE_CORPSE_YELLOW_SNAKE; break;
  case MONS_GREY_SNAKE: ch=TILE_CORPSE_GREY_SNAKE; break;
  case MONS_DEEP_TROLL: ch=TILE_CORPSE_DEEP_TROLL; break;
  case MONS_GIANT_BLOWFLY: ch=TILE_CORPSE_GIANT_BLOWFLY; break;
  case MONS_RED_WASP: ch=TILE_CORPSE_RED_WASP; break;
  case MONS_SWAMP_DRAGON: ch=TILE_CORPSE_SWAMP_DRAGON; break;
  case MONS_SWAMP_DRAKE: ch=TILE_CORPSE_SWAMP_DRAKE; break;
  case MONS_SOLDIER_ANT: ch=TILE_CORPSE_SOLDIER_ANT; break;
  case MONS_HILL_GIANT: ch=TILE_CORPSE_HILL_GIANT; break;
  case MONS_QUEEN_ANT: ch=TILE_CORPSE_QUEEN_ANT; break;
  case MONS_ANT_LARVA: ch=TILE_CORPSE_ANT_LARVA; break;
  case MONS_GIANT_FROG: ch=TILE_CORPSE_GIANT_FROG; break;
  case MONS_GIANT_BROWN_FROG: ch=TILE_CORPSE_GIANT_BROWN_FROG; break;
  case MONS_SPINY_FROG: ch=TILE_CORPSE_SPINY_FROG; break;
  case MONS_BLINK_FROG: ch=TILE_CORPSE_BLINK_FROG; break;
  case MONS_GIANT_COCKROACH: ch=TILE_CORPSE_GIANT_COCKROACH; break;
  case MONS_SMALL_SNAKE: ch=TILE_CORPSE_SMALL_SNAKE; break;
  case MONS_GIANT_AMOEBA: ch=TILE_CORPSE_GIANT_AMOEBA; break;
  case MONS_GIANT_SLUG: ch=TILE_CORPSE_GIANT_SLUG; break;
  case MONS_GIANT_SNAIL: ch=TILE_CORPSE_GIANT_SNAIL; break;
  case MONS_BORING_BEETLE: ch=TILE_CORPSE_BORING_BEETLE; break;
//  case MONS_NAGA_MAGE: ch=TILE_CORPSE_NAGA_MAGE; break;
//  case MONS_NAGA_WARRIOR: ch=TILE_CORPSE_NAGA_WARRIOR; break;
//  case MONS_ORC_WARLORD: ch=TILE_CORPSE_ORC_WARLORD; break;
//  case MONS_DEEP_ELF_SOLDIER: ch=TILE_CORPSE_DEEP_ELF_SOLDIER; break;
//  case MONS_DEEP_ELF_FIGHTER: ch=TILE_CORPSE_DEEP_ELF_FIGHTER; break;
//  case MONS_DEEP_ELF_KNIGHT: ch=TILE_CORPSE_DEEP_ELF_KNIGHT; break;
//  case MONS_DEEP_ELF_MAGE: ch=TILE_CORPSE_DEEP_ELF_MAGE; break;
//  case MONS_DEEP_ELF_SUMMONER: ch=TILE_CORPSE_DEEP_ELF_SUMMONER; break;
//  case MONS_DEEP_ELF_CONJURER: ch=TILE_CORPSE_DEEP_ELF_CONJURER; break;
//  case MONS_DEEP_ELF_PRIEST: ch=TILE_CORPSE_DEEP_ELF_PRIEST; break;
//  case MONS_DEEP_ELF_HIGH_PRIEST: ch=TILE_CORPSE_DEEP_ELF_HIGH_PRIEST; break;
//  case MONS_DEEP_ELF_DEMONOLOGIST: ch=TILE_CORPSE_DEEP_ELF_DEMONOLOGIST; break;
//  case MONS_DEEP_ELF_ANNIHILATOR: ch=TILE_CORPSE_DEEP_ELF_ANNIHILATOR; break;
//  case MONS_DEEP_ELF_SORCERER: ch=TILE_CORPSE_DEEP_ELF_SORCERER; break;
//  case MONS_DEEP_ELF_DEATH_MAGE: ch=TILE_CORPSE_DEEP_ELF_DEATH_MAGE; break;
  case MONS_GREATER_NAGA: ch=TILE_CORPSE_GREATER_NAGA; break;
//  case MONS_CENTAUR_WARRIOR: ch=TILE_CORPSE_CENTAUR_WARRIOR; break;
//  case MONS_YAKTAUR_CAPTAIN: ch=TILE_CORPSE_YAKTAUR_CAPTAIN; break;
  case MONS_QUOKKA: ch=TILE_CORPSE_QUOKKA; break;
//  case MONS_SHUGGOTH: ch=TILE_CORPSE_SHUGGOTH; break;
  case MONS_WOLF: ch=TILE_CORPSE_WOLF; break;
  case MONS_WARG: ch=TILE_CORPSE_WARG; break;
  case MONS_BEAR: ch=TILE_CORPSE_BEAR; break;
  case MONS_GRIZZLY_BEAR: ch=TILE_CORPSE_GRIZZLY_BEAR; break;
  case MONS_POLAR_BEAR: ch=TILE_CORPSE_POLAR_BEAR; break;
  case MONS_BLACK_BEAR: ch=TILE_CORPSE_BLACK_BEAR; break;
  case MONS_GIANT_NEWT: ch=TILE_CORPSE_GIANT_NEWT; break;
  case MONS_GIANT_GECKO: ch=TILE_CORPSE_GIANT_GECKO; break;
  case MONS_GIANT_IGUANA: ch=TILE_CORPSE_GIANT_IGUANA; break;
  case MONS_GILA_MONSTER: ch=TILE_CORPSE_GILA_MONSTER; break;
  case MONS_KOMODO_DRAGON: ch=TILE_CORPSE_KOMODO_DRAGON; break;
  case MONS_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_BROWN; break;
  case MONS_BLACK_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_BLACK; break;
  case MONS_YELLOW_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_YELLOW; break;
  case MONS_GREEN_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_GREEN; break;
  case MONS_MOTTLED_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_MOTTLED; break;
  case MONS_PALE_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_PALE; break;
  case MONS_PURPLE_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_PURPLE; break;
  case MONS_RED_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_RED; break;
  case MONS_WHITE_DRACONIAN: ch=TILE_CORPSE_DRACONIAN_WHITE; break;
  case MONS_DEATH_DRAKE: ch=TILE_CORPSE_DEATH_DRAKE; break;
  }
  return ch;
}
int tileidx_misc(int type)
{
  int ch = TILE_ERROR;
  switch(type)
  {
    case MISC_BOTTLED_EFREET: ch = TILE_MISC_BOTTLED_EFREET; break;
    case MISC_CRYSTAL_BALL_OF_SEEING: ch = TILE_MISC_CRYSTAL_BALL_OF_SEEING; break;
    case MISC_AIR_ELEMENTAL_FAN: ch = TILE_MISC_AIR_ELEMENTAL_FAN; break;
    case MISC_LAMP_OF_FIRE: ch = TILE_MISC_LAMP_OF_FIRE; break;
    case MISC_STONE_OF_EARTH_ELEMENTALS: ch = TILE_MISC_STONE_OF_EARTH_ELEMENTALS; break;
    case MISC_LANTERN_OF_SHADOWS: ch = TILE_MISC_LANTERN_OF_SHADOWS; break;
    case MISC_HORN_OF_GERYON: ch = TILE_MISC_HORN_OF_GERYON; break;
    case MISC_BOX_OF_BEASTS: ch = TILE_MISC_BOX_OF_BEASTS; break;
    case MISC_CRYSTAL_BALL_OF_ENERGY: ch = TILE_MISC_CRYSTAL_BALL_OF_ENERGY; break;
    case MISC_EMPTY_EBONY_CASKET: ch = TILE_MISC_EMPTY_EBONY_CASKET; break;
    case MISC_CRYSTAL_BALL_OF_FIXATION: ch = TILE_MISC_CRYSTAL_BALL_OF_FIXATION; break;
    case MISC_DISC_OF_STORMS: ch = TILE_MISC_DISC_OF_STORMS; break;
    case MISC_DECK_OF_ESCAPE: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_DESTRUCTION: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_DUNGEONS: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_SUMMONING: ch = TILE_MISC_DECK_OF_SUMMONINGS; break;
    case MISC_DECK_OF_WONDERS: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_PUNISHMENT: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_WAR: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_CHANGES: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_DECK_OF_DEFENSE: ch = TILE_MISC_DECK_OF_WONDERS; break;
    case MISC_RUNE_OF_ZOT: ch = TILE_MISC_RUNE_OF_ZOT; break;
  }
  return ch;
}
/*****************************************************/
int tileidx_item(const item_def &item)
{
    int clas=item.base_type;
    int type=item.sub_type;
    int special=item.special;
    int color=item.colour;
    id_arr& id = get_typeid_array();
    switch (clas)
    {
	case OBJ_WEAPONS:
        if(is_fixed_artefact(item))
            return tileidx_fixed_artifact(special); 
        else
        if (is_unrandom_artefact( item ))
            return tileidx_unrand_artifact(find_unrandart_index(item));
        else
            return tileidx_weapon(item);
	break;
	case OBJ_MISSILES:
	return tileidx_missile(item);
	break;
        case OBJ_ARMOUR:
        if (is_unrandom_artefact( item ))
            return tileidx_unrand_artifact(find_unrandart_index(item));
        else
            return tileidx_armour(item);
	break;
        case OBJ_WANDS:
#if 1 //ID Item
        if (id[ IDTYPE_WANDS ][type] == ID_KNOWN_TYPE
            ||  (item.flags &ISFLAG_KNOW_TYPE ))
             return TILE_WAND_FLAME + type;
        else
#endif
             return TILE_WAND_OFFSET + special % 12;
	break;
	case OBJ_FOOD:
	return tileidx_food(item);
	break;
        case OBJ_SCROLLS:
#if 1 //ID Item
        if (id[ IDTYPE_SCROLLS ][type] == ID_KNOWN_TYPE
            ||  (item.flags &ISFLAG_KNOW_TYPE ))
             return TILE_SCR_IDENTIFY + type;
#endif
        return TILE_SCROLL;
	break;
        case OBJ_GOLD:
	return TILE_GOLD;
	break;
        case OBJ_JEWELLERY:
        if (type < AMU_RAGE)
        { // rings
           if(is_random_artefact( item ))
	       return TILE_RING_RANDOM_OFFSET + color - 1;
           else 
	       return TILE_RING_NORMAL_OFFSET + special % 13;
        } else { // amu
        if (is_unrandom_artefact( item ))
            return tileidx_unrand_artifact(find_unrandart_index(item));
        else
           if(is_random_artefact( item ))
               return TILE_AMU_RANDOM_OFFSET + color - 1;
           else
               return TILE_AMU_NORMAL_OFFSET + special % 13;
        } 
	break;
        case OBJ_POTIONS:
        if (id[ IDTYPE_POTIONS ][type] == ID_KNOWN_TYPE
            ||  (item.flags &ISFLAG_KNOW_TYPE ))
         return TILE_POT_HEALING + type;
         else
         return TILE_POTION_OFFSET + special % 14;
	 break;
        case OBJ_BOOKS:
        type= special % 10;
        if(type<2) return TILE_BOOK_PAPER_OFFSET + color;
        if(type==2) return TILE_BOOK_LEATHER_OFFSET + special/10;
        if(type==3) return TILE_BOOK_METAL_OFFSET + special/10;
        if(type==4) return TILE_BOOK_PAPYRUS;
	break;
        case OBJ_STAVES:
	return TILE_STAFF_OFFSET + special % 10;
	break;
        case OBJ_CORPSES:
        if (item.sub_type == CORPSE_SKELETON)
            return TILE_FOOD_BONE;
        else
            return tileidx_corpse(item.plus);
	break;
        case OBJ_ORBS:
	return TILE_ORB;
	break;
        case OBJ_MISCELLANY:
	return tileidx_misc(type);
	break;
        default:
	break;
    }
    return TILE_ERROR;
}
/*
  Determine Octant of missile direction
  ---> X+
 |
 |  701
 Y  6O2
 +  543
  the octant boundary slope tan(pi/8)=sqrt(2)-1 = 0.414 is approximated by 2/5
*/
static int tile_bolt_dir(int dx, int dy)
{
    int ax = abs(dx);
    int ay = abs(dy);
    if ( 5*ay < 2*ax )
    {
	return (dx > 0)? 2:6;
    }
    else if ( 5*ax < 2*ay)
    {
        return ( dy > 0 )? 4:0;
    }
    else 
    {
        if (dx>0)
	    return (dy>0)? 3:1;
	else
	    return (dy>0)? 5:7;
    }
}
int tileidx_item_throw(const item_def &item, int dx, int dy)
{
    if (item.base_type == OBJ_MISSILES)
    {
        int ch = -1;
        int dir = tile_bolt_dir(dx, dy);
        // Thrown items with multiple directions
        switch(item.sub_type)
        {
            case MI_ARROW:
                ch = TILE_MI_ARROW0;
                break;
            case MI_BOLT:
                ch = TILE_MI_BOLT0;
                break;
            case MI_DART:
                ch = TILE_MI_DART0;
                break;
            case MI_NEEDLE:
                ch = TILE_MI_NEEDLE0;
                break;
            case MI_JAVELIN:
                ch = TILE_MI_JAVELIN0;
                break;
            case MI_THROWING_NET:
                ch = TILE_MI_THROWING_NET0;
            default:
                break;
        }
        if (ch != -1)
            return ch + dir;
        // Thrown items with a single direction
        switch(item.sub_type)
        {
            case MI_STONE:
                ch = TILE_MI_STONE0;
                break;
            case MI_SLING_BULLET:
                ch = TILE_MI_SLING_BULLET0;
                break;
            case MI_LARGE_ROCK:
                ch = TILE_MI_LARGE_ROCK0;
                break;
            case MI_THROWING_NET:
                ch = TILE_MI_THROWING_NET0;
                break;
            default:
                break;
        }
        if (ch != -1)
            return ch;
    }
    // If not a special case, just return the default tile.
    return tileidx_item(item);
}
int tileidx_feature(int object){
    int ch = TILE_ERROR;
    switch (object)
    {
    case DNGN_UNSEEN: ch=TILE_DNGN_UNSEEN; break;
    case DNGN_ROCK_WALL:
    case DNGN_PERMAROCK_WALL:
    case DNGN_SECRET_DOOR:
        ch=TILE_DNGN_ROCK_WALL_OFS; break;
    case DNGN_STONE_WALL: ch=TILE_DNGN_STONE_WALL; break;
    case DNGN_CLOSED_DOOR: ch=TILE_DNGN_CLOSED_DOOR; break;
    case DNGN_METAL_WALL: ch=TILE_DNGN_METAL_WALL; break;
    case DNGN_GREEN_CRYSTAL_WALL: ch=TILE_DNGN_GREEN_CRYSTAL_WALL; break;
    case DNGN_ORCISH_IDOL: ch=TILE_DNGN_ORCISH_IDOL; break;
    case DNGN_WAX_WALL: ch=TILE_DNGN_WAX_WALL; break;
    //case DNGN_LAST_SOLID_CH: ch=TILE_DNGN_LAST_SOLID_CH; break;
    case DNGN_GRANITE_STATUE: ch=TILE_DNGN_GRANITE_STATUE; break;
    //  case DNGN_STATUE_39: ch=TILE_DNGN_STATUE_39; break;
    case DNGN_LAVA: ch=TILE_DNGN_LAVA; break;
    case DNGN_DEEP_WATER: ch=TILE_DNGN_DEEP_WATER; break;
    case DNGN_SHALLOW_WATER: ch=TILE_DNGN_SHALLOW_WATER; break;
    //  case DNGN_WATER_STUCK: ch=TILE_DNGN_WATER_STUCK; break;
    case DNGN_FLOOR: 
    case DNGN_UNDISCOVERED_TRAP:
        ch=TILE_DNGN_FLOOR; break;
    case DNGN_FLOOR_SPECIAL:
        ch=TILE_DNGN_FLOOR_SPECIAL; break;
    case DNGN_ENTER_HELL: ch=TILE_DNGN_ENTER_HELL; break;
    case DNGN_OPEN_DOOR: ch=TILE_DNGN_OPEN_DOOR; break;
    //  case DNGN_BRANCH_STAIRS: ch=TILE_DNGN_BRANCH_STAIRS; break;
    case DNGN_TRAP_MECHANICAL: ch=TILE_DNGN_TRAP_MECHANICAL; break;
    case DNGN_TRAP_MAGICAL: ch=TILE_DNGN_TRAP_MAGICAL; break;
//    case DNGN_TRAP_III: ch=TILE_DNGN_TRAP_III; break;
    case DNGN_ENTER_SHOP: ch=TILE_DNGN_ENTER_SHOP; break;
    case DNGN_ENTER_LABYRINTH: ch=TILE_DNGN_ENTER_LABYRINTH; break;
    case DNGN_STONE_STAIRS_DOWN_I: 
    case DNGN_STONE_STAIRS_DOWN_II: 
    case DNGN_STONE_STAIRS_DOWN_III: ch=TILE_DNGN_STONE_STAIRS_DOWN; break;
    case DNGN_ROCK_STAIRS_DOWN: ch=TILE_DNGN_ROCK_STAIRS_DOWN; break;
    case DNGN_STONE_STAIRS_UP_I:
    case DNGN_STONE_STAIRS_UP_II:
    case DNGN_STONE_STAIRS_UP_III: ch=TILE_DNGN_STONE_STAIRS_UP; break;
    case DNGN_ROCK_STAIRS_UP: ch=TILE_DNGN_ROCK_STAIRS_UP; break;
    case DNGN_ENTER_DIS: ch=TILE_DNGN_ENTER_DIS; break;
    case DNGN_ENTER_GEHENNA: ch=TILE_DNGN_ENTER_GEHENNA; break;
    case DNGN_ENTER_COCYTUS: ch=TILE_DNGN_ENTER_COCYTUS; break;
    case DNGN_ENTER_TARTARUS: ch=TILE_DNGN_ENTER_TARTARUS; break;
    case DNGN_ENTER_ABYSS: ch=TILE_DNGN_ENTER_ABYSS; break;
    case DNGN_EXIT_ABYSS:
    case DNGN_EXIT_HELL:
        ch=TILE_DNGN_EXIT_ABYSS; break;
    case DNGN_STONE_ARCH: ch=TILE_DNGN_STONE_ARCH; break;
    case DNGN_ENTER_PANDEMONIUM: ch=TILE_DNGN_ENTER_PANDEMONIUM; break;
    case DNGN_EXIT_PANDEMONIUM: ch=TILE_DNGN_EXIT_PANDEMONIUM; break;
    case DNGN_TRANSIT_PANDEMONIUM: ch=TILE_DNGN_TRANSIT_PANDEMONIUM; break;
    // case DNGN_BUILDER_SPECIAL_WALL: ch=TILE_DNGN_BUILDER_SPECIAL_WALL; break;
    // case DNGN_BUILDER_SPECIAL_FLOOR: ch=TILE_DNGN_BUILDER_SPECIAL_FLOOR; break;
    case DNGN_ENTER_ORCISH_MINES:
    case DNGN_ENTER_HIVE:
    case DNGN_ENTER_LAIR:
    case DNGN_ENTER_SLIME_PITS:
    case DNGN_ENTER_VAULTS:
    case DNGN_ENTER_CRYPT:
    case DNGN_ENTER_HALL_OF_BLADES:
    case DNGN_ENTER_ZOT:
    case DNGN_ENTER_TEMPLE:
    case DNGN_ENTER_SNAKE_PIT:
    case DNGN_ENTER_ELVEN_HALLS:
    case DNGN_ENTER_TOMB:
    case DNGN_ENTER_SWAMP:
    case DNGN_ENTER_SHOALS:
    case DNGN_ENTER_RESERVED_2:
    case DNGN_ENTER_RESERVED_3:
    case DNGN_ENTER_RESERVED_4:
        ch=TILE_DNGN_ENTER; break;
    case DNGN_RETURN_FROM_ORCISH_MINES:
    case DNGN_RETURN_FROM_HIVE:
    case DNGN_RETURN_FROM_LAIR:
    case DNGN_RETURN_FROM_SLIME_PITS:
    case DNGN_RETURN_FROM_VAULTS:
    case DNGN_RETURN_FROM_CRYPT:
    case DNGN_RETURN_FROM_HALL_OF_BLADES:
    case DNGN_RETURN_FROM_ZOT:
    case DNGN_RETURN_FROM_TEMPLE:
    case DNGN_RETURN_FROM_SNAKE_PIT:
    case DNGN_RETURN_FROM_ELVEN_HALLS:
    case DNGN_RETURN_FROM_TOMB:
    case DNGN_RETURN_FROM_SWAMP:
    case DNGN_RETURN_FROM_SHOALS:
    case DNGN_RETURN_RESERVED_2:
    case DNGN_RETURN_RESERVED_3:
    case DNGN_RETURN_RESERVED_4:
        ch=TILE_DNGN_RETURN; break;
    case DNGN_ENTER_PORTAL_VAULT:
    case DNGN_EXIT_PORTAL_VAULT:
        ch=TILE_DNGN_TRANSIT_PANDEMONIUM; break;
    case DNGN_ALTAR_ZIN: ch=TILE_DNGN_ALTAR_ZIN; break;
    case DNGN_ALTAR_SHINING_ONE: ch=TILE_DNGN_ALTAR_SHINING_ONE; break;
    case DNGN_ALTAR_KIKUBAAQUDGHA: ch=TILE_DNGN_ALTAR_KIKUBAAQUDGHA; break;
    case DNGN_ALTAR_YREDELEMNUL: ch=TILE_DNGN_ALTAR_YREDELEMNUL; break;
    case DNGN_ALTAR_XOM: ch=TILE_DNGN_ALTAR_XOM; break;
    case DNGN_ALTAR_VEHUMET: ch=TILE_DNGN_ALTAR_VEHUMET; break;
    case DNGN_ALTAR_OKAWARU: ch=TILE_DNGN_ALTAR_OKAWARU; break;
    case DNGN_ALTAR_MAKHLEB: ch=TILE_DNGN_ALTAR_MAKHLEB; break;
    case DNGN_ALTAR_SIF_MUNA: ch=TILE_DNGN_ALTAR_SIF_MUNA; break;
    case DNGN_ALTAR_TROG: ch=TILE_DNGN_ALTAR_TROG; break;
    case DNGN_ALTAR_NEMELEX_XOBEH: ch=TILE_DNGN_ALTAR_NEMELEX_XOBEH; break;
    case DNGN_ALTAR_ELYVILON: ch=TILE_DNGN_ALTAR_ELYVILON; break;
    case DNGN_ALTAR_LUGONU: ch=TILE_DNGN_ALTAR_LUGONU; break;
    case DNGN_ALTAR_BEOGH: ch=TILE_DNGN_ALTAR_BEOGH; break;
    case DNGN_BLUE_FOUNTAIN: ch=TILE_DNGN_BLUE_FOUNTAIN; break;
    case DNGN_DRY_FOUNTAIN_I: 
    case DNGN_DRY_FOUNTAIN_II:
    case DNGN_DRY_FOUNTAIN_III:
    case DNGN_DRY_FOUNTAIN_IV:
    case DNGN_DRY_FOUNTAIN_V:
    case DNGN_DRY_FOUNTAIN_VI:
    case DNGN_DRY_FOUNTAIN_VII:
    case DNGN_DRY_FOUNTAIN_VIII:
    case DNGN_PERMADRY_FOUNTAIN :
        ch=TILE_DNGN_DRY_FOUNTAIN; break;
    case DNGN_SPARKLING_FOUNTAIN: ch=TILE_DNGN_SPARKLING_FOUNTAIN; break;
    }
    
    return ch;
}
int tileidx_cloud(int type, int decay){
    int ch = TILE_ERROR;
    int dur = decay/20;
    if (dur>2) dur = 2;
    switch (type)
    {
        case CLOUD_FIRE:
            ch = TILE_CLOUD_FIRE_0 + dur;
            break;
        case CLOUD_COLD:
            ch = TILE_CLOUD_COLD_0 + dur;
            break;
        case CLOUD_STINK:
        case CLOUD_POISON:
            ch = TILE_CLOUD_POISON_0 + dur;
            break;
        case CLOUD_BLUE_SMOKE:
            ch = TILE_CLOUD_BLUE_SMOKE;
            break;
        case CLOUD_PURP_SMOKE:
            ch = TILE_CLOUD_PURP_SMOKE;
            break;
        case CLOUD_MIASMA:
            ch = TILE_CLOUD_MIASMA;
            break;
        case CLOUD_BLACK_SMOKE:
            ch = TILE_CLOUD_BLACK_SMOKE;
            break;
        default:
            ch = TILE_CLOUD_GREY_SMOKE;
            break;
    }
    return (ch | TILE_FLAG_FLYING);
}
/**********************************************************/
int tileidx_player(int job){
    int ch = TILE_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;
    }
    if (player_is_airborne())
	ch |= TILE_FLAG_FLYING;
    if (you.attribute[ATTR_HELD])
        ch |= TILE_FLAG_NET;
    return ch;
}
int tileidx_unseen(int ch, const coord_def& gc)
{
    int res = TILE_ERROR;
    ch &= 0xff;
    if (ch<32) ch=32;
    if ( (ch>='@' && ch<='Z') || (ch>='a' && ch<='z') || ch=='&'
        || (ch>='1' && ch<='5') || ch == ';')
        return TILE_UNSEEN_MONSTER | tile_unseen_flag(gc);
    switch (ch)
    {
        //blank, walls, and floors first, since they are frequent
        case ' ': res = TILE_DNGN_UNSEEN; break;
        case 127: //old
        case 176:
        case 177: res = TILE_DNGN_ROCK_WALL_OFS; break;
	case 130:
        case ',':
        case '.':
        case 249:
        case 250: res = TILE_DNGN_FLOOR; break;
	// old;
        case 137: res = TILE_DNGN_WAX_WALL; break;
        case 138: res = TILE_DNGN_STONE_WALL; break;
        case 139: res = TILE_DNGN_METAL_WALL; break;
        case 140: res = TILE_DNGN_GREEN_CRYSTAL_WALL; break;
        // others
        case '!': res = TILE_POTION_OFFSET + 13; break;
        case '"': res = TILE_AMU_NORMAL_OFFSET + 2; break;
        case '#': res = TILE_CLOUD_GREY_SMOKE; break;
        case '$': res = TILE_GOLD; break;
        case '%': res = TILE_FOOD_MEAT_RATION; break;
        case 142: res = TILE_UNSEEN_CORPSE; break;
        case '\'':
        case 134: res = TILE_DNGN_OPEN_DOOR; break;
        case '(':
        case ')': res = TILE_UNSEEN_WEAPON; break;
        case '*': res = TILE_DNGN_ROCK_WALL_OFS ; break;
        case '+': res =  TILE_BOOK_PAPER_OFFSET + 15; break;
        case '/': res = TILE_WAND_OFFSET; break;
        case '8': res = TILE_DNGN_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;
        case '?': res = TILE_SCROLL; break;
        case '[':
        case ']': res = TILE_UNSEEN_ARMOUR; break;
        case '\\': res = TILE_STAFF_OFFSET; break;
        case '^': res = TILE_DNGN_TRAP_MAGICAL; break;
        case '_':
        case 131: res = TILE_UNSEEN_ALTAR; break;
        case '~': res = TILE_UNSEEN_ITEM; break;
        case '{':
        case 135: res = TILE_DNGN_DEEP_WATER; break;
        case 133: res = TILE_DNGN_BLUE_FOUNTAIN; break;
        case '}': res = TILE_MISC_CRYSTAL_BALL_OF_SEEING; break;
        case 128: //old 
        case 254: res = TILE_DNGN_CLOSED_DOOR; break;
        case 129: res = TILE_DNGN_RETURN; break;
        case 132: res = TILE_UNSEEN_ENTRANCE; break;
        case 136: res = TILE_DNGN_ENTER; break;
        case 141: res = TILE_DNGN_LAVA; break;
    }
    //if(res == TILE_ERROR)printf("undefined mapchar %d [%c]\n",ch,ch);
    return res | tile_unseen_flag(gc);
}
int tileidx_bolt(const bolt &bolt)
{
    int col = bolt.colour;
    return tileidx_zap(col);
}
int tileidx_zap(int color)
{
    int col = color;
    if (col > 8) col -= 8;
    if (col < 1) col = 7;
    return TILE_SYM_BOLT_OFS -1 + col;
}
// Convert normal tile to 3D tile if it exists
// Plus modify wall tile index depending on
//  1: floor/wall flavor in 2D mode
//  2: connectivity in 3D mode
void finalize_tile(short unsigned int *tile, unsigned char wflag,
    char wall_flv, char floor_flv, char special_flv)
{
    int orig = (*tile) & TILE_FLAG_MASK;
    int flag = (*tile) & (~TILE_FLAG_MASK);
    // Hack: Swap rock/stone in crypt and tomb, because there are
    //       only stone walls.
    if ((you.where_are_you == BRANCH_CRYPT || you.where_are_you == BRANCH_TOMB)
            && orig == TILE_DNGN_STONE_WALL)
            orig = TILE_DNGN_ROCK_WALL_OFS;
    // If there are special tiles for this level, then use them.
    // Otherwise, we'll fall through to the next case and replace
    // special tiles with normal floor.
    if (orig == TILE_DNGN_FLOOR_SPECIAL && 
        get_num_floor_special_flavors() > 0)
    {
        (*tile) = get_floor_special_tile_idx() + special_flv;
        ASSERT(special_flv >= 0 && 
            special_flv < get_num_floor_special_flavors());
    }
    else if (orig == TILE_DNGN_FLOOR || orig == TILE_DNGN_FLOOR_SPECIAL)
    {
        (*tile) = get_floor_tile_idx() + floor_flv;
    }
    else if (orig == TILE_DNGN_ROCK_WALL_OFS)
    {
        (*tile) = get_wall_tile_idx() + wall_flv;
    }
    (*tile) |= flag;
}
void tilep_calc_flags(int parts[], int flag[])
{
    int i;
    for(i=0;i<TILEP_PARTS_TOTAL;i++) flag[i]=TILEP_FLAG_NORMAL;
    if (parts[TILEP_PART_HELM]-1 >= TILEP_HELM_HELM_OFS)
        flag[TILEP_PART_HAIR]=TILEP_FLAG_HIDE;
    if (parts[TILEP_PART_HELM]-1 >= TILEP_HELM_FHELM_OFS)
        flag[TILEP_PART_BEARD]=TILEP_FLAG_HIDE;
    if(parts[TILEP_PART_BASE]== TILEP_BASE_NAGA ||
       parts[TILEP_PART_BASE]== TILEP_BASE_NAGA+1)
    {
        flag[TILEP_PART_BOOTS]=flag[TILEP_PART_LEG]=TILEP_FLAG_HIDE;
        flag[TILEP_PART_BODY] = TILEP_FLAG_CUT_NAGA;
    }
    if(parts[TILEP_PART_BASE]== TILEP_BASE_CENTAUR ||
       parts[TILEP_PART_BASE]== TILEP_BASE_CENTAUR+1)
    {
        flag[TILEP_PART_BOOTS]=flag[TILEP_PART_LEG]=TILEP_FLAG_HIDE;
        flag[TILEP_PART_BODY] = TILEP_FLAG_CUT_CENTAUR;
    }
    if (parts[TILEP_PART_BASE] == TILEP_BASE_MERFOLK_WATER ||
        parts[TILEP_PART_BASE] == TILEP_BASE_MERFOLK_WATER +1)
    {
        flag[TILEP_PART_BOOTS] = TILEP_FLAG_HIDE;
        flag[TILEP_PART_LEG] = TILEP_FLAG_HIDE;
        flag[TILEP_PART_SHADOW] = TILEP_FLAG_HIDE;
    }
}
/*
 * Set default parts of each race 
 * body + optional beard, hair, etc 
 */
int draconian_color(int race, int level)
{
    if (level < 0) // hack:monster
    {
        switch(race)
        {
        case MONS_DRACONIAN:        return 0;
        case MONS_BLACK_DRACONIAN:  return 1;
        case MONS_YELLOW_DRACONIAN: return 2;
        case MONS_GREEN_DRACONIAN:  return 4;
        case MONS_MOTTLED_DRACONIAN:return 5;
        case MONS_PALE_DRACONIAN:   return 6;
        case MONS_PURPLE_DRACONIAN: return 7;
        case MONS_RED_DRACONIAN:    return 8;
        case MONS_WHITE_DRACONIAN:  return 9;
        }
    }
    if (level < 7)
        return 0;
    switch(race)
    {
    case SP_BLACK_DRACONIAN:   return 1;
    case SP_GOLDEN_DRACONIAN:  return 2;
    case SP_GREY_DRACONIAN:    return 3;
    case SP_GREEN_DRACONIAN:   return 4;
    case SP_MOTTLED_DRACONIAN: return 5;
    case SP_PALE_DRACONIAN:    return 6;
    case SP_PURPLE_DRACONIAN:  return 7;
    case SP_RED_DRACONIAN:     return 8;
    case SP_WHITE_DRACONIAN:   return 9;
    }
    return 0;
}
void tilep_race_default(int race, int gender, int level, int *parts)
{
    int result;
    int hair;
    int beard=0;
    if(gender==TILEP_GENDER_MALE)
        hair = TILEP_HAIR_SHORT_BLACK;
    else
        hair = TILEP_HAIR_LONG_BLACK;
    switch(race)
    {
        case SP_HUMAN:
            result = TILEP_BASE_HUMAN; 
            break;
        case SP_ELF:
        case SP_HIGH_ELF:
        case SP_GREY_ELF:
        case SP_SLUDGE_ELF:
            result = TILEP_BASE_ELF;
            hair = TILEP_HAIR_ELF_YELLOW;
            break;
        case SP_DEEP_ELF:
            result = TILEP_BASE_DEEP_ELF;
            hair = TILEP_HAIR_ELF_WHITE;
            break;
        case SP_HILL_DWARF:
        case SP_MOUNTAIN_DWARF:
            result = TILEP_BASE_DWARF;
            if(gender==TILEP_GENDER_MALE)
            {
                hair = TILEP_HAIR_SHORT_RED;
                beard = TILEP_BEARD_LONG_RED;
            }
            else
            {
                hair = TILEP_HAIR_LONG_RED;
                beard = TILEP_BEARD_SHORT_RED;
            }
            break;
        case SP_HALFLING:
            result = TILEP_BASE_HALFLING;
            break;
        case SP_HILL_ORC:
            result = TILEP_BASE_ORC;
            hair = 0;
            break;
        case SP_KOBOLD:
            result = TILEP_BASE_KOBOLD;
            hair = 0;
            break;
        case SP_MUMMY:
            result = TILEP_BASE_MUMMY;
            hair = 0;
            break;
        case SP_NAGA:
            result = TILEP_BASE_NAGA;
            break;
        case SP_GNOME:
            result = TILEP_BASE_GNOME;
            break;
        case SP_OGRE:
            result = TILEP_BASE_OGRE;
            break;
        case SP_TROLL:
            result = TILEP_BASE_TROLL;
            hair = 0;
            break;
        case SP_OGRE_MAGE:
            result = TILEP_BASE_OGRE_MAGE;
            break;
        case SP_BASE_DRACONIAN:
        case SP_RED_DRACONIAN:
        case SP_WHITE_DRACONIAN:
        case SP_GREEN_DRACONIAN:
        case SP_GOLDEN_DRACONIAN:
        case SP_GREY_DRACONIAN:
        case SP_BLACK_DRACONIAN:
        case SP_PURPLE_DRACONIAN:
        case SP_MOTTLED_DRACONIAN:
        case SP_PALE_DRACONIAN:
            hair = 0;
            if (you.mutation[MUT_BIG_WINGS])
            {
                parts[TILEP_PART_DRCWING] = 1 + draconian_color(race, level);
            }
            result = TILEP_BASE_DRACONIAN + draconian_color(race, level)*2;
            break;
        case SP_CENTAUR:
            result = TILEP_BASE_CENTAUR;
            break;
        case SP_DEMIGOD:
            result = TILEP_BASE_DEMIGOD;
            break;
        case SP_SPRIGGAN:
            result = TILEP_BASE_SPRIGGAN;
            break;
        case SP_MINOTAUR:
            result = TILEP_BASE_MINOTAUR;
            hair = 0;
            break;
        case SP_DEMONSPAWN:
            result = TILEP_BASE_DEMONSPAWN;
            hair = 0;
            break;
        case SP_GHOUL:
            result = TILEP_BASE_GHOUL;
            hair = 0;
            break;
        case SP_KENKU:
            result = TILEP_BASE_KENKU;
            break;
        case SP_MERFOLK:
            result = player_in_water() ? 
                TILEP_BASE_MERFOLK_WATER :
                TILEP_BASE_MERFOLK;
            break;
        case SP_VAMPIRE:
            result = TILEP_BASE_VAMPIRE;
            break;
        default:
            result = TILEP_BASE_HUMAN;
            break;
    }
    if(gender==TILEP_GENDER_MALE) result++;
    parts[TILEP_PART_BASE]=result;
    parts[TILEP_PART_HAIR]=hair;
    parts[TILEP_PART_BEARD]=beard;
    parts[TILEP_PART_SHADOW]= 1;
}
void tilep_job_default(int job, int gender, int *parts)
{
    parts[TILEP_PART_CLOAK]= 0;
    parts[TILEP_PART_BOOTS]= 0;
    parts[TILEP_PART_LEG]= 0;
    parts[TILEP_PART_BODY]= 0;
    parts[TILEP_PART_ARM]= 0;
    parts[TILEP_PART_HAND1]=0;
    parts[TILEP_PART_HAND2]= 0;
    parts[TILEP_PART_HELM]= 0;
    
    switch(job)
    {
        case JOB_FIGHTER:
            parts[TILEP_PART_BODY]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_LEG]=TILEP_LEG_METAL_SILVER;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            break;
        case JOB_CRUSADER:
            parts[TILEP_PART_BODY]=TILEP_BODY_SHIRT_WHITE3;
            parts[TILEP_PART_LEG]=TILEP_LEG_SKIRT_OFS;
            parts[TILEP_PART_HELM]=TILEP_HELM_HELM_OFS;
            parts[TILEP_PART_ARM]=TILEP_ARM_GLOVE_GRAY;
            parts[TILEP_PART_BOOTS]=TILEP_BOOTS_MIDDLE_GRAY;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_BLUE;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            break;
        case JOB_PALADIN:
            parts[TILEP_PART_BODY]=TILEP_BODY_ROBE_WHITE;
            parts[TILEP_PART_LEG]=TILEP_LEG_PANTS_BROWN;
            parts[TILEP_PART_HELM]=TILEP_HELM_HELM_OFS;
            parts[TILEP_PART_ARM]=TILEP_ARM_GLOVE_GRAY;
            parts[TILEP_PART_BOOTS]=TILEP_BOOTS_MIDDLE_GRAY;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_BLUE;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            break;
        case JOB_DEATH_KNIGHT:
            parts[TILEP_PART_BODY]=TILEP_BODY_SHIRT_BLACK3;
            parts[TILEP_PART_LEG]=TILEP_LEG_METAL_GRAY;
            parts[TILEP_PART_HELM]=TILEP_HELM_FHELM_OFS;
            parts[TILEP_PART_ARM]=TILEP_ARM_GLOVE_BLACK;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_YELLOW;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]=TILEP_HAND2_BOOK_BLACK;
            break;
        case JOB_CHAOS_KNIGHT:
            parts[TILEP_PART_BODY]=TILEP_BODY_BELT1;
            parts[TILEP_PART_LEG]=TILEP_LEG_METAL_GRAY;
            parts[TILEP_PART_HELM]=TILEP_HELM_FHELM_PLUME;
            parts[TILEP_PART_BOOTS]=TILEP_BOOTS_SHORT_BROWN;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            break;
        case JOB_BERSERKER:
            parts[TILEP_PART_BODY]=TILEP_BODY_ANIMAL_SKIN;
            parts[TILEP_PART_LEG]=TILEP_LEG_BELT_REDBROWN;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            break;
        case JOB_REAVER:
            parts[TILEP_PART_BODY]=TILEP_BODY_ROBE_BLACK_GOLD;
            parts[TILEP_PART_LEG]=TILEP_LEG_PANTS_BROWN;
            parts[TILEP_PART_HAND2]=TILEP_HAND2_BOOK_RED_DIM;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_THIEF:
            parts[TILEP_PART_HELM] = TILEP_HELM_HOOD_YBROWN;
            parts[TILEP_PART_BODY]=TILEP_BODY_LEATHER_JACKET;
            parts[TILEP_PART_LEG]=TILEP_LEG_PANTS_SHORT_GRAY;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_SWORD_THIEF;
            parts[TILEP_PART_ARM]=TILEP_ARM_GLOVE_WRIST_PURPLE;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_LBROWN;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_MIDDLE_BROWN2;
            break;
        case JOB_STALKER:
            parts[TILEP_PART_HELM] = TILEP_HELM_HOOD_GREEN;
            parts[TILEP_PART_BODY]=TILEP_BODY_LEATHER_JACKET;
            parts[TILEP_PART_LEG]=TILEP_LEG_PANTS_SHORT_GRAY;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_SWORD_THIEF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_GREEN_DIM;
            parts[TILEP_PART_ARM]=TILEP_ARM_GLOVE_WRIST_PURPLE;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_GREEN;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_MIDDLE_BROWN2;
            break;
        case JOB_ASSASSIN:
            parts[TILEP_PART_HELM] = TILEP_HELM_MASK_NINJA_BLACK;
            parts[TILEP_PART_BODY]=TILEP_BODY_SHIRT_BLACK3;
            parts[TILEP_PART_LEG]=TILEP_LEG_PANTS_BLACK;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_SWORD_THIEF;
            parts[TILEP_PART_ARM]=TILEP_ARM_GLOVE_BLACK;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_BLACK;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN2;
            break;
        case JOB_WIZARD:
            parts[TILEP_PART_BODY]= TILEP_BODY_GANDALF_G;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_CYAN_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            parts[TILEP_PART_HELM] = TILEP_HELM_GANDALF;
            break;
        case JOB_PRIEST:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_WHITE;
            parts[TILEP_PART_ARM] = TILEP_ARM_GLOVE_WHITE;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_HEALER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_WHITE;
            parts[TILEP_PART_ARM] = TILEP_ARM_GLOVE_WHITE;
            parts[TILEP_PART_HAND1]= 38;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            parts[TILEP_PART_HELM] = TILEP_HELM_FHELM_HEALER;
            break;
        case JOB_NECROMANCER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_BLACK;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_STAFF_SKULL;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_BLACK;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_FIRE_ELEMENTALIST:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_RED;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_RED_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_ICE_ELEMENTALIST:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_BLUE;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_BLUE_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_AIR_ELEMENTALIST:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_CYAN;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_CYAN_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_EARTH_ELEMENTALIST:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_YELLOW;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_YELLOW_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_VENOM_MAGE:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_GREEN;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_GREEN_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_TRANSMUTER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_RAINBOW;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_STAFF_MAGE;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_MAGENTA_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_CONJURER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_MAGENTA;
            parts[TILEP_PART_HELM] = TILEP_HELM_GANDALF;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_STAFF_MAGE;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_RED_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_ENCHANTER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_YELLOW;
            parts[TILEP_PART_HELM] = TILEP_HELM_GANDALF;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_STAFF_MAGE;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_BLUE_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_SUMMONER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_BROWN;
            parts[TILEP_PART_HELM] = TILEP_HELM_GANDALF;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_STAFF_MAGE;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_YELLOW_DIM;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            break;
        case JOB_WARPER:
            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_BROWN;
            parts[TILEP_PART_HELM] = TILEP_HELM_GANDALF;
            parts[TILEP_PART_HAND1]= 42;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_WHITE;
            parts[TILEP_PART_BOOTS] = TILEP_BOOTS_SHORT_BROWN;
            parts[TILEP_PART_CLOAK]=TILEP_CLOAK_RED;
            break;
        case JOB_HUNTER:
            parts[TILEP_PART_BODY]=TILEP_BODY_LEATHER_ARMOUR2;
            parts[TILEP_PART_LEG]=TILEP_LEG_PANTS_BROWN;
            parts[TILEP_PART_HAND1]=TILEP_HAND1_BOW;
            parts[TILEP_PART_ARM] = 7;
            parts[TILEP_PART_BOOTS]= TILEP_BOOTS_MIDDLE_BROWN;
            break;
        case JOB_GLADIATOR:
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]= 10;
            if(gender==TILEP_GENDER_MALE)
            {
                parts[TILEP_PART_BODY]= TILEP_BODY_BELT1;
                parts[TILEP_PART_LEG]= TILEP_LEG_BELT_GRAY;
                parts[TILEP_PART_BOOTS] = TILEP_BOOTS_MIDDLE_GRAY;
            }
            else
            {
                parts[TILEP_PART_BODY]= TILEP_BODY_BIKINI_RED;
                parts[TILEP_PART_LEG]= TILEP_LEG_BIKINI_RED;
                parts[TILEP_PART_BOOTS] = TILEP_BOOTS_LONG_RED;
            }
            break;
        case JOB_MONK:
            parts[TILEP_PART_BODY]= TILEP_BODY_MONK_BLACK;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            break;
        case JOB_WANDERER:
            parts[TILEP_PART_BODY]= TILEP_BODY_SHIRT_HAWAII;
            parts[TILEP_PART_LEG]= TILEP_LEG_PANTS_SHORT_BROWN;
            parts[TILEP_PART_HAND1]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_HAND2]=TILEP_SHOW_EQUIP;
            parts[TILEP_PART_BOOTS] = 11;
            break;
    }
}
/*
 * Patrs index to string
 */
void tilep_part_to_str(int number, char *buf)
{
    //special
    if (number == TILEP_SHOW_EQUIP)
    {
        buf[0] = buf[1] = buf[2] ='*';
    }
    else
    {
        //normal 2 digits
        buf[0] = '0' + (number/100) % 10;
        buf[1] = '0' + (number/ 10) % 10;
        buf[2] = '0' +  number % 10;
    }
    buf[3] ='\0';
}
/*
 * Parts string to index
 */
int tilep_str_to_part(char *str)
{
    //special
    if (str[0]=='*') return TILEP_SHOW_EQUIP;
    //normal 2 digits
    return atoi(str);
}
const int parts_saved[] ={
    TILEP_PART_SHADOW,
    TILEP_PART_BASE,
    TILEP_PART_CLOAK,
    TILEP_PART_BOOTS,
    TILEP_PART_LEG,
    TILEP_PART_BODY,
    TILEP_PART_ARM,
    TILEP_PART_HAND1,
    TILEP_PART_HAND2,
    TILEP_PART_HAIR,
    TILEP_PART_BEARD,
    TILEP_PART_HELM,
    -1
};
/*
 * scan input line from dolls.txt
 */
void tilep_scan_parts(char *fbuf, int *parts)
{
    char  ibuf[8];
    int gcount = 0;
    int ccount = 0;
    for(int i = 0; parts_saved[i] != -1; i++)
    {
        int idx;
        ccount = 0;
	int p = parts_saved[i];
        while ( (fbuf[gcount] != ':') && (fbuf[gcount] != '\n')
		&& (ccount<4) && (gcount<48) )
        {
            ibuf[ccount] = fbuf[gcount];
            ccount ++;
            gcount ++;
        }
        ibuf[ccount] = '\0';
        gcount ++;
        idx = tilep_str_to_part(ibuf);
        if (p == TILEP_PART_BASE)
        {
            int p0 = (parts[p]-1) & (0xfe);
            if (((1-idx) & 1) == 1) p0++;
            parts[p] = p0 + 1;
        }
        else if (idx == TILEP_SHOW_EQUIP)
            parts[p] = TILEP_SHOW_EQUIP;
        else if (idx < 0) // no negative value
            parts[p] = 0;
        else if (idx > tilep_parts_total[p]) // bound it
            parts[p] = tilep_parts_total[p];
        else
            parts[p] = idx;
    }
}
/*
 * format-print parts
 */
void tilep_print_parts(char *fbuf, int *parts)
{
    int i;
    char *ptr = fbuf;
    for(i = 0; parts_saved[i] != -1; i++)
    {
	int p = parts_saved[i];
        if (p == TILEP_PART_BASE) // 0:female  1:male
        {
            sprintf(ptr, "%03d", parts[p]%2);
            ptr += 3;
        }
        else
        {
            tilep_part_to_str(parts[p], ptr);
            ptr += 3;
        }
        *ptr = ':';
        ptr++;
    }
    ptr--; // erase the last ':'
    *ptr = 0;
}
/*
 * return equip-dependent parts index
 */
int tilep_equ_weapon(const item_def &item)
{
    if (item.base_type == OBJ_STAVES) return TILEP_HAND1_STAFF_MAGE;
    if (item.base_type ==OBJ_MISCELLANY)
    {
        switch(item.sub_type)
        {
        case MISC_BOTTLED_EFREET: return TILEP_HAND1_BOTTLE;
        case MISC_AIR_ELEMENTAL_FAN: return TILEP_HAND1_FAN;
        case MISC_STONE_OF_EARTH_ELEMENTALS: return TILEP_HAND1_STONE;
        case MISC_DISC_OF_STORMS: return TILEP_HAND1_DISC;
        case MISC_CRYSTAL_BALL_OF_SEEING: 
        case MISC_CRYSTAL_BALL_OF_ENERGY: 
        case MISC_CRYSTAL_BALL_OF_FIXATION: return TILEP_HAND1_CRYSTAL;
        case MISC_LAMP_OF_FIRE: return TILEP_HAND1_LANTERN;
        case MISC_LANTERN_OF_SHADOWS: return TILEP_HAND1_BONE_LANTERN;
        case MISC_HORN_OF_GERYON: return TILEP_HAND1_HORN;
        case MISC_BOX_OF_BEASTS: 
        case MISC_EMPTY_EBONY_CASKET: return TILEP_HAND1_BOX;
        case MISC_DECK_OF_ESCAPE:
        case MISC_DECK_OF_DESTRUCTION:
        case MISC_DECK_OF_DUNGEONS:
        case MISC_DECK_OF_SUMMONING:
        case MISC_DECK_OF_WONDERS:
        case MISC_DECK_OF_PUNISHMENT:
        case MISC_DECK_OF_WAR:
        case MISC_DECK_OF_CHANGES:
        case MISC_DECK_OF_DEFENSE: return TILEP_HAND1_DECK;
        }
    }
    if (item.base_type != OBJ_WEAPONS) return 0;
    if (is_fixed_artefact( item ))
    {
        switch(item.special)
        {
            case SPWPN_SINGING_SWORD: return TILEP_HAND1_SINGING_SWORD;
            case SPWPN_WRATH_OF_TROG: return TILEP_HAND1_AXE_TROG;
            case SPWPN_SCYTHE_OF_CURSES: return TILEP_HAND1_FINISHER;
            case SPWPN_MACE_OF_VARIABILITY: return TILEP_HAND1_MACE_OF_VARIABILITY;
            case SPWPN_GLAIVE_OF_PRUNE: return TILEP_HAND1_GLAIVE_OF_PRUNE;
            case SPWPN_SCEPTRE_OF_TORMENT: return TILEP_HAND1_MACE_RUBY;
            case SPWPN_SWORD_OF_ZONGULDROK: return TILEP_HAND1_ZONGULDROK;
            case SPWPN_SWORD_OF_CEREBOV: return TILEP_HAND1_SWORD_TWIST;
            case SPWPN_STAFF_OF_DISPATER: return TILEP_HAND1_DISPATER;
            case SPWPN_SCEPTRE_OF_ASMODEUS: return TILEP_HAND1_ASMODEUS;
            case SPWPN_SWORD_OF_POWER: break;
            case SPWPN_KNIFE_OF_ACCURACY: break;
            case SPWPN_STAFF_OF_OLGREB: return TILEP_HAND1_OLGREB;
            case SPWPN_VAMPIRES_TOOTH: break;
            case SPWPN_STAFF_OF_WUCAD_MU: break;
        }
    }
    if (is_unrandom_artefact( item ))
    {
        int x = find_unrandart_index(item);
        switch(x+1)
        {
            // Bloodbane
            case 2: return TILEP_HAND1_BLOODBANE;
            // Flaming Death
            case 4: return TILEP_HAND1_FLAMING_DEATH;
            //mace of Brilliance
            case 8: return TILEP_HAND1_MACE_OF_VARIABILITY;
            //demon blade Leech
            case 12: return TILEP_HAND1_LEECH;
            //dagger of Chilly Death
            case 15: return TILEP_HAND1_CHILLY_DEATH;
            //dagger \"Morg\"
            case 17: return TILEP_HAND1_MORG;
            //scythe \"Finisher
            case 18: return TILEP_HAND1_FINISHER;
            //sling \"Punk
            case 19: return TILEP_HAND1_PUNK;
            //bow of Krishna
            case 20: return TILEP_HAND1_KRISHNA;
            //giant club \"Skullcrusher
            case 22: break;
            //glaive of the Guard
            case 24: break;
            //sword of Jihad
            case 25: return TILEP_HAND1_JIHAD;
            //crossbow \"Fiery Devil
            case 28: return TILEP_HAND1_FIERY_DEVIL;
            //sword of Doom Knight
            case 31: return TILEP_HAND1_DOOM_KNIGHT;
            //Eos
            case 35: break;
            //spear of Voo-Doo
            case 39: return TILEP_HAND1_VOODOO;
            //trident of the Octopus king
            case 40: break;
            //mithril axe \"Arga
            case 42: return TILEP_HAND1_ARGA;
            //Elemental Staff
            case 43: return TILEP_HAND1_ELEMENTAL_STAFF;
            //hand crossbow \"Sniper
            case 44: return TILEP_HAND1_SNIPER;
            //bow \"Erchidel
            case 45: return TILEP_HAND1_GREAT_BOW;
            //plutonium sword
            case 47: return TILEP_HAND1_PLUTONIUM_SWORD;
            //mace \"Undeadhunter
            case 48: return TILEP_HAND1_LARGE_MACE;
        }
    }
    switch (item.sub_type)
    {
  // Blunt
  case WPN_CLUB: return TILEP_HAND1_CLUB_SLANT;
  case WPN_MACE: return TILEP_HAND1_MACE;
  case WPN_GREAT_MACE: return TILEP_HAND1_GREAT_MACE;
  case WPN_FLAIL: return TILEP_HAND1_FRAIL;
  case WPN_SPIKED_FLAIL: return TILEP_HAND1_SPIKED_FRAIL;
  case WPN_DIRE_FLAIL: return TILEP_HAND1_GREAT_FRAIL;
  case WPN_MORNINGSTAR: return TILEP_HAND1_MORNINGSTAR;
  case WPN_EVENINGSTAR: return TILEP_HAND1_EVENINGSTAR;
  case WPN_GIANT_CLUB: return TILEP_HAND1_GIANT_CLUB_SLANT;
  case WPN_GIANT_SPIKED_CLUB: return TILEP_HAND1_GIANT_CLUB_SPIKE_SLANT;
  case WPN_ANCUS: return TILEP_HAND1_MACE;
  case WPN_WHIP: return TILEP_HAND1_WHIP;
  case WPN_DEMON_WHIP: return TILEP_HAND1_BLACK_WHIP;
  // Edge
  case WPN_KNIFE: return TILEP_HAND1_DAGGER_SLANT;
  case WPN_DAGGER: return TILEP_HAND1_DAGGER_SLANT;
  case WPN_SHORT_SWORD: return TILEP_HAND1_SHORT_SWORD_SLANT;
  case WPN_LONG_SWORD: return TILEP_HAND1_LONG_SWORD_SLANT;
  case WPN_GREAT_SWORD: return TILEP_HAND1_GREAT_SWORD_SLANT;
  case WPN_SCIMITAR: return TILEP_HAND1_SCIMITAR;
  case WPN_FALCHION: return TILEP_HAND1_FALCHION;
  case WPN_SABRE: return TILEP_HAND1_SABRE;
  case WPN_DEMON_BLADE: return TILEP_HAND1_SWORD_BLACK;
  case WPN_QUICK_BLADE: return TILEP_HAND1_DAGGER;
  case WPN_KATANA: return TILEP_HAND1_KATANA_SLANT;
  case WPN_DOUBLE_SWORD: return TILEP_HAND1_DOUBLE_SWORD;
  case WPN_TRIPLE_SWORD: return TILEP_HAND1_TRIPLE_SWORD;
  case WPN_BLESSED_BLADE: return TILEP_HAND1_BLESSED_BLADE;
  // Axe
  case WPN_HAND_AXE: return TILEP_HAND1_HAND_AXE;
  case WPN_BATTLEAXE: return TILEP_HAND1_BATTLEAXE;
  case WPN_BROAD_AXE: return TILEP_HAND1_BROAD_AXE;
  case WPN_WAR_AXE: return TILEP_HAND1_WAR_AXE;
  case WPN_EXECUTIONERS_AXE: return TILEP_HAND1_EXECUTIONERS_AXE;
  case WPN_BARDICHE: return TILEP_HAND1_GLAIVE3;
  //Pole
  case WPN_SPEAR: return TILEP_HAND1_SPEAR;
  case WPN_HALBERD: return TILEP_HAND1_HALBERD;
  case WPN_GLAIVE: return TILEP_HAND1_GLAIVE;
  case WPN_QUARTERSTAFF: return TILEP_HAND1_QUARTERSTAFF1;
  case WPN_SCYTHE: return TILEP_HAND1_SCYTHE;
  case WPN_HAMMER: return TILEP_HAND1_HAMMER;
  case WPN_DEMON_TRIDENT: return TILEP_HAND1_DEMON_TRIDENT;
  case WPN_TRIDENT: return TILEP_HAND1_TRIDENT2;
  case WPN_LAJATANG: return TILEP_HAND1_D_GLAIVE;
  //Ranged
  case WPN_SLING: return TILEP_HAND1_SLING;
  case WPN_BOW: return TILEP_HAND1_BOW2;
  case WPN_CROSSBOW: return TILEP_HAND1_CROSSBOW;
  case WPN_HAND_CROSSBOW: return TILEP_HAND1_CROSSBOW;
  case WPN_BLOWGUN: return TILEP_HAND1_BLOWGUN;
  case WPN_LONGBOW: return TILEP_HAND1_BOW3;
        default: return 0;
    }
}
int tilep_equ_armour(const item_def &item)
{
    if (item.base_type !=OBJ_ARMOUR) return 0;
    if (is_unrandom_artefact( item ))
    {
        int x = find_unrandart_index(item);
        switch(x+1)
        {
            // Holy Armour of Zin
            case 6: return TILEP_BODY_ARMOR_MUMMY;
            // robe of Augmentation
            case 7: return TILEP_BODY_ROBE_RED2;
            // robe of Misfortune
            case 14: return TILEP_BODY_ARWEN;
            // Lear's chain mail
            case 26: return TILEP_BODY_LEARS_CHAIN_MAIL;
            // skin of Zhor
            case 27: return TILEP_BODY_ZHOR; break;
            // salamander hide armour
            case 29: return TILEP_BODY_LEATHER_RED;
            // robe of Folly
            case 33: return TILEP_BODY_ROBE_BLACK;
            // Edison's patent armour
            case 38: return TILEP_BODY_EDISON;
            // robe of Night
            case 46: return TILEP_BODY_ROBE_OF_NIGHT;
            // armour of the Dragon King
            case 49: break;
        }
    }
    switch (item.sub_type)
    {
    case ARM_ROBE: 
        switch(item.colour)
        {
            // We've got a zillion robes; let's use 'em!
            case BLACK:       return TILEP_BODY_ROBE_BLACK_RED;
            case BLUE:        return TILEP_BODY_ROBE_BLUE;
            case LIGHTBLUE:   return TILEP_BODY_ROBE_BLUE_WHITE;
            case GREEN:       return TILEP_BODY_ROBE_GREEN;
            case LIGHTGREEN:  return TILEP_BODY_ROBE_BLUE_GREEN;
            case CYAN:        return TILEP_BODY_ROBE_WHITE_GREEN;
            case LIGHTCYAN:   return TILEP_BODY_ROBE_CYAN;
            case RED:         return TILEP_BODY_ROBE_RED;
            case LIGHTRED:    return TILEP_BODY_ROBE_RED_GOLD;
            case MAGENTA:     return TILEP_BODY_ROBE_MAGENTA;
            case LIGHTMAGENTA:return TILEP_BODY_ROBE_RED3;
            case BROWN:       return TILEP_BODY_ROBE_BROWN;
            case YELLOW:      return TILEP_BODY_ROBE_YELLOW;
            case LIGHTGREY:   return TILEP_BODY_ROBE_GRAY2;
            case DARKGREY:    return TILEP_BODY_GANDALF_G;
            case WHITE:       return TILEP_BODY_ROBE_WHITE;
            default:          return 0;
        }
 
    case ARM_LEATHER_ARMOUR: return TILEP_BODY_LEATHER_ARMOUR3;
    case ARM_RING_MAIL: return TILEP_BODY_RINGMAIL;
    case ARM_CHAIN_MAIL: return TILEP_BODY_CHAINMAIL;
    case ARM_SCALE_MAIL: return TILEP_BODY_SCALEMAIL;
    case ARM_SPLINT_MAIL: return TILEP_BODY_BANDED;
    case ARM_BANDED_MAIL: return TILEP_BODY_BANDED;
    case ARM_PLATE_MAIL: return TILEP_BODY_PLATE_BLACK;
    case ARM_CRYSTAL_PLATE_MAIL: return TILEP_BODY_CRYSTAL_PLATE;
    case ARM_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_GREEN;
    case ARM_ICE_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_CYAN;
    case ARM_STEAM_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_WHITE;
    case ARM_MOTTLED_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_MAGENTA;
    case ARM_STORM_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_BLUE;
    case ARM_GOLD_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_GOLD;
    case ARM_SWAMP_DRAGON_HIDE: return TILEP_BODY_DRAGONSC_BROWN;
    case ARM_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_GREEN;
    case ARM_ICE_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_CYAN;
    case ARM_STEAM_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_WHITE;
    case ARM_MOTTLED_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_MAGENTA;
    case ARM_STORM_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_BLUE;
    case ARM_GOLD_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_GOLD;
    case ARM_SWAMP_DRAGON_ARMOUR: return TILEP_BODY_DRAGONARM_BROWN;
    case ARM_ANIMAL_SKIN: return TILEP_BODY_ANIMAL_SKIN;
    case ARM_TROLL_HIDE: 
    case ARM_TROLL_LEATHER_ARMOUR: return TILEP_BODY_TROLL_HIDE;
    default: return 0;
    }
}
int tilep_equ_shield(const item_def &item)
{
    if (you.equip[EQ_SHIELD] == -1) return 0;
    if (item.base_type !=OBJ_ARMOUR) return 0;
    if (is_unrandom_artefact( item ))
    {
        int x = find_unrandart_index(item);
        switch(x+1)
        {
            // shield of Ignorance
            case 5: return TILEP_HAND2_SHIELD_SHAMAN;
            // Bullseye
            case 10: return TILEP_HAND2_BULLSEYE;
            // shield of Resistance
            case 32: return TILEP_HAND2_SHIELD_OF_RESISTANCE;
        }
    }
    switch (item.sub_type)
    {
        case ARM_SHIELD: return TILEP_HAND2_SHIELD_KNIGHT_BLUE;
        case ARM_BUCKLER: return TILEP_HAND2_SHIELD_ROUND_SMALL;
        case ARM_LARGE_SHIELD: return TILEP_HAND2_SHIELD_LONG_RED;
        default: return 0;
    }
}
int tilep_equ_cloak(const item_def &item)
{
    if (you.equip[EQ_CLOAK] == -1) return 0;
    if (item.base_type !=OBJ_ARMOUR) return 0;
    if (item.sub_type != ARM_CLOAK) return 0;
    switch (item.colour)
    {
         case BLACK:
         case BLUE:
         case LIGHTBLUE:   return TILEP_CLOAK_BLUE;
         case GREEN:
         case LIGHTGREEN:  return TILEP_CLOAK_GREEN;
         case CYAN:
         case LIGHTCYAN:   return TILEP_CLOAK_CYAN;
         case RED:
         case LIGHTRED:    return TILEP_CLOAK_RED;
         case MAGENTA:
         case LIGHTMAGENTA:return TILEP_CLOAK_MAGENTA;
         case BROWN:       return TILEP_CLOAK_LBROWN;
         case YELLOW:      return TILEP_CLOAK_YELLOW;
         case LIGHTGREY:   return TILEP_CLOAK_GRAY;
         case DARKGREY:    return TILEP_CLOAK_BLACK;
         case WHITE:       return TILEP_CLOAK_WHITE;
         default:          return 0;
    }
}
int tilep_equ_helm(const item_def &item)
{
    if (you.equip[EQ_HELMET] == -1)
        return 0;
    if (item.base_type != OBJ_ARMOUR)
        return 0;
    if (is_unrandom_artefact(item))
    {
        int idx = find_unrandart_index(item);
        switch (idx + 1)
        {
            case 11:
                // crown of Dyrovepreva
                return TILEP_HELM_DYROVEPREVA;
            case 41:
                // mask of the Dragon
                return TILEP_HELM_ART_DRAGONHELM;
            case 50:
                // hat of the Alchemist
                return TILEP_HELM_TURBAN_PURPLE;
        }
        // Although there shouldn't be any, just in case
        // unhandled artefacts fall through to defaults...
    }
    int etype = get_etype(item);
    int helmet_desc = get_helmet_desc(item);
    switch (item.sub_type)
    {
        case ARM_CAP:
            switch (item.colour)
            {
                case BLACK:
                case BLUE:
                case LIGHTBLUE:
                    return TILEP_HELM_FEATHER_BLUE;
                case GREEN:
                case LIGHTGREEN:
                case CYAN:
                case LIGHTCYAN:
                    return TILEP_HELM_FEATHER_GREEN;
                case RED:
                case LIGHTRED:
                case MAGENTA:
                case LIGHTMAGENTA:
                    return TILEP_HELM_FEATHER_RED;
                case BROWN:
                case YELLOW:
                    return TILEP_HELM_FEATHER_YELLOW;
                case LIGHTGREY:
                case DARKGREY:
                case WHITE:
                    return TILEP_HELM_FEATHER_WHITE;
            }
            return 0;
        case ARM_WIZARD_HAT:
            switch (item.colour)
            {
                case MAGENTA:
                case LIGHTMAGENTA:
                case BLACK:
                    return TILEP_HELM_WIZARD_BLACKRED;
                case BLUE:
                case LIGHTBLUE:
                    return TILEP_HELM_WIZARD_BLUE;
                case GREEN:
                case LIGHTGREEN:
                    return TILEP_HELM_WIZARD_DARKGREEN;
                case CYAN:
                    return TILEP_HELM_WIZARD_PURPLE;
                case LIGHTCYAN:
                    return TILEP_HELM_WIZARD_BLUEGREEN;
                case RED:
                case LIGHTRED:
                    return TILEP_HELM_WIZARD_RED;
                case BROWN:
                    return TILEP_HELM_WIZARD_BROWN;
                case YELLOW:
                    return TILEP_HELM_WIZARD_BLACKGOLD;
                case LIGHTGREY:
                case DARKGREY:
                case WHITE:
                    return TILEP_HELM_WIZARD_WHITE;
            }
            return 0;
        // Why are there both helms and helmets? -Enne
        // It'd be like having catsup and ketchup in the same game.
        case ARM_HELM:
        case ARM_HELMET:
            switch (helmet_desc)
            {
                case THELM_DESC_PLAIN:
                    switch (etype)
                    {
                        default:
                            return TILEP_HELM_CHAIN;
                        case 1:
                            return TILEP_HELM_HELM_GIMLI;
                        case 2:
                            return TILEP_HELM_HELM_OFS; // urgh
                        case 3:
                            return TILEP_HELM_FHELM_GRAY2;
                        case 4:
                            return TILEP_HELM_FHELM_BLACK;
                    }
                case THELM_DESC_WINGED:
                    return TILEP_HELM_YELLOW_WING;
                case THELM_DESC_HORNED:
                    switch (etype)
                    {
                        default:
                            return TILEP_HELM_FHELM_HORN2;
                        case 1:
                            return TILEP_HELM_BLUE_HORN_GOLD;
                        case 2:
                            return TILEP_HELM_FHELM_HORN_GRAY;
                        case 3:
                            return TILEP_HELM_FHELM_HORN_YELLOW;
                        case 4:
                            return TILEP_HELM_FHELM_OFS; // urgh
                    }
                case THELM_DESC_CRESTED:
                    return TILEP_HELM_FHELM_ISILDUR;
                case THELM_DESC_PLUMED:
                    return TILEP_HELM_FHELM_PLUME;
                case THELM_DESC_SPIKED:
                    return TILEP_HELM_FHELM_EVIL;
                case THELM_DESC_VISORED:
                    return TILEP_HELM_FHELM_GRAY3;
                case THELM_DESC_JEWELLED:
                    return TILEP_HELM_FULL_GOLD;
            }
    }
    return 0;
}
int tilep_equ_gloves(const item_def &item)
{
    if (you.equip[EQ_GLOVES] == -1)
        return 0;
    if (item.base_type != OBJ_ARMOUR)
        return 0;
    if (item.sub_type != ARM_GLOVES)
        return 0;
    if (is_unrandom_artefact(item))
    {
        int idx = find_unrandart_index(item);
        switch (idx + 1)
        {
            case 30: // gauntlets of War (thick brown)
                return TILEP_ARM_GLOVE_BLACK;
            case 51: // fencer's gloves (white)
                return TILEP_ARM_GLOVE_WHITE;
        }
    }
    int etype = get_etype(item);
    switch (etype)
    {
        default:
        case 0:
            switch (item.colour)
            {
                case LIGHTBLUE:
                    return TILEP_ARM_GLOVE_BLUE;
                default:
                case BROWN:
                    return TILEP_ARM_GLOVE_BROWN;
            }
        case 1:
        case 2:
        case 3:
        case 4:
            switch (item.colour)
            {
                case LIGHTBLUE:
                default:
                    return TILEP_ARM_GLOVE_CHUNLI;
                case BROWN:
                    return TILEP_ARM_GLOVE_GRAYFIST;
            }
    }
    return 0;
}
int tilep_equ_boots(const item_def &item)
{
    if (you.equip[EQ_BOOTS] == -1)
        return 0;
    if (item.base_type != OBJ_ARMOUR)
        return 0;
    if (item.sub_type == ARM_NAGA_BARDING)
        return TILEP_BOOTS_NAGA_BARDING;
    if (item.sub_type == ARM_CENTAUR_BARDING)
        return TILEP_BOOTS_CENTAUR_BARDING;
    if (item.sub_type != ARM_BOOTS)
        return 0;
    if (is_unrandom_artefact(item))
    {
        int idx = find_unrandart_index(item);
        switch (idx + 1)
        {
            case 23: // boots of the assassin
                return TILEP_BOOTS_MIDDLE_GRAY;
        }
    }
    int etype = get_etype(item);
    switch (etype)
    {
        default:
        case 0:
            return TILEP_BOOTS_MIDDLE_BROWN3;
        case 1:
        case 2:
            switch (item.colour)
            {
                case BROWN:
                default:
                    return TILEP_BOOTS_MESH_RED;
                case BLUE:
                    return TILEP_BOOTS_MESH_BLUE;
            }
        case 3:
        case 4:
            switch (item.colour)
            {
                case BROWN:
                    return TILEP_BOOTS_LONG_RED;
                default:
                case BLUE:
                    return TILEP_BOOTS_BLUE_GOLD;
            }
    }
    return 0;
}
#ifdef TILEP_DEBUG
/*
 *   Debugging routines
 */
const char *get_ctg_name(int part)
{
    return tilep_parts_name[part];
}
int get_ctg_idx(char *name)
{
    int i;
    for(i=0;i<TILEP_PARTS_TOTAL;i++)
        if(strcmp(name, tilep_parts_name[i])==0) return i;
    return 0;
}
const char *get_parts_name(int part, int idx)
{
    static char tmp[10];
    const char *ptr = tilep_comment[ tilep_comment_ofs[part] -1 + idx ];
    if(idx==0) return "";
    if(ptr[0]==0)
    {
        sprintf(tmp,"%02d",idx);
        return tmp;
    }
    return ptr;
}
// �p�[�c�̖��O�𐔎��ɕϊ�
int get_parts_idx(int part, char *name)
{
    int res = atoi(name);
    int i;
    for(i=0;i<tilep_parts_total[part];i++)
        if(strcmp(name, tilep_comment[ tilep_comment_ofs[part]+i])==0)
            return i+1;
    return res;
}
#endif /* TILEP_DEBUG */
/*
 * Tile data preparation
 */
// for clarity
enum SpecialIdx
{
    SPECIAL_N = 0,
    SPECIAL_NE = 1,
    SPECIAL_E = 2,
    SPECIAL_SE = 3,
    SPECIAL_S = 4,
    SPECIAL_SW = 5,
    SPECIAL_W = 6,
    SPECIAL_NW = 7,
    SPECIAL_FULL = 8
};
int jitter(SpecialIdx i)
{
    return (i + random_range(-1, 1) + 8) % 8;
}
void tile_init_flavor()
{
    for (int x = 0; x < GXM; x++)
    {
        for (int y = 0; y < GYM; y++)
        {
            int max_wall_flavor = get_num_wall_flavors() - 1;
            int max_floor_flavor = get_num_floor_flavors() - 1;
            int wall_flavor = random_range(0, max_wall_flavor);
            int floor_flavor = random_range(0, max_floor_flavor);
            env.tile_flavor[x][y].floor = floor_flavor;
            env.tile_flavor[x][y].wall = wall_flavor;
            if (grd[x][y] == DNGN_FLOOR_SPECIAL)
            {
                int left_grd = (x > 0) ? grd[x-1][y] : DNGN_ROCK_WALL;
                int right_grd = (x < GXM - 1) ? grd[x+1][y] : DNGN_ROCK_WALL;
                int up_grd = (y > 0) ? grd[x][y-1] : DNGN_ROCK_WALL;
                int down_grd = (y < GYM - 1) ? grd[x][y+1] : DNGN_ROCK_WALL;
                // The special tiles contains part floor and part special, so
                // if there are adjacent floor or special tiles, we should
                // do our best to "connect" them appropriately.  If there are
                // are other tiles there (walls, doors, whatever...) then it
                // doesn't matter.
                bool l_nrm = left_grd == DNGN_FLOOR;
                bool r_nrm = right_grd == DNGN_FLOOR;
                bool u_nrm = up_grd == DNGN_FLOOR;
                bool d_nrm = down_grd == DNGN_FLOOR;
                bool l_spc = left_grd == DNGN_FLOOR_SPECIAL;
                bool r_spc = right_grd == DNGN_FLOOR_SPECIAL;
                bool u_spc = up_grd == DNGN_FLOOR_SPECIAL;
                bool d_spc = down_grd == DNGN_FLOOR_SPECIAL;
                if (l_nrm && r_nrm || u_nrm && d_nrm)
                {
                    // Not much to do here...
                    env.tile_flavor[x][y].special = SPECIAL_FULL;
                }
                else if (l_nrm)
                {
                    if (u_nrm)
                        env.tile_flavor[x][y].special = SPECIAL_NW;
                    else if (d_nrm)
                        env.tile_flavor[x][y].special = SPECIAL_SW;
                    else if (u_spc && d_spc)
                        env.tile_flavor[x][y].special = SPECIAL_W;
                    else if (u_spc && r_spc)
                        env.tile_flavor[x][y].special = SPECIAL_SW;
                    else if (d_spc && r_spc)
                        env.tile_flavor[x][y].special = SPECIAL_NW;
                    else if (u_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_W : SPECIAL_SW;
                    else if (d_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_W : SPECIAL_NW;
                    else
                        env.tile_flavor[x][y].special = jitter(SPECIAL_W);
                }
                else if (r_nrm)
                {
                    if (u_nrm)
                        env.tile_flavor[x][y].special = SPECIAL_NE;
                    else if (d_nrm)
                        env.tile_flavor[x][y].special = SPECIAL_SE;
                    else if (u_spc && d_spc)
                        env.tile_flavor[x][y].special = SPECIAL_E;
                    else if (u_spc && l_spc)
                        env.tile_flavor[x][y].special = SPECIAL_SE;
                    else if (d_spc && l_spc)
                        env.tile_flavor[x][y].special = SPECIAL_NE;
                    else if (u_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_E : SPECIAL_SE;
                    else if (d_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_E : SPECIAL_NE;
                    else
                        env.tile_flavor[x][y].special = jitter(SPECIAL_E);
                }
                else if (u_nrm)
                {
                    if (r_spc && l_spc)
                        env.tile_flavor[x][y].special = SPECIAL_N;
                    else if (r_spc && d_spc)
                        env.tile_flavor[x][y].special = SPECIAL_NW;
                    else if (l_spc && d_spc)
                        env.tile_flavor[x][y].special = SPECIAL_NE;
                    else if (r_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_N : SPECIAL_NW;
                    else if (l_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_N : SPECIAL_NE;
                    else
                        env.tile_flavor[x][y].special = jitter(SPECIAL_N);
                }
                else if (d_nrm)
                {
                    if (r_spc && l_spc)
                        env.tile_flavor[x][y].special = SPECIAL_S;
                    else if (r_spc && u_spc)
                        env.tile_flavor[x][y].special = SPECIAL_SW;
                    else if (l_spc && u_spc)
                        env.tile_flavor[x][y].special = SPECIAL_SE;
                    else if (r_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_S : SPECIAL_SW;
                    else if (l_spc)
                        env.tile_flavor[x][y].special = coinflip() ?
                            SPECIAL_S : SPECIAL_SE;
                    else
                        env.tile_flavor[x][y].special = jitter(SPECIAL_S);
                }
                else if (u_spc && d_spc)
                {
                    // We know this value is already initialized and
                    // is necessarily in bounds.
                    char t = env.tile_flavor[x][y-1].special;
                    if (t == SPECIAL_NE || t == SPECIAL_E)
                        env.tile_flavor[x][y].special = SPECIAL_E;
                    else if (t == SPECIAL_NW || t == SPECIAL_W)
                        env.tile_flavor[x][y].special = SPECIAL_W;
                    else
                        env.tile_flavor[x][y].special = SPECIAL_FULL;
                }
                else if (r_spc && l_spc)
                {
                    // We know this value is already initialized and
                    // is necessarily in bounds.
                    char t = env.tile_flavor[x-1][y].special;
                    if (t == SPECIAL_NW || t == SPECIAL_N)
                        env.tile_flavor[x][y].special = SPECIAL_N;
                    else if (t == SPECIAL_SW || t == SPECIAL_S)
                        env.tile_flavor[x][y].special = SPECIAL_S;
                    else
                        env.tile_flavor[x][y].special = SPECIAL_FULL;
                }
                else if (u_spc && l_spc)
                {
                    env.tile_flavor[x][y].special = SPECIAL_SE;
                }
                else if (u_spc && r_spc)
                {
                    env.tile_flavor[x][y].special = SPECIAL_SW;
                }
                else if (d_spc && l_spc)
                {
                    env.tile_flavor[x][y].special = SPECIAL_NE;
                }
                else if (d_spc && r_spc)
                {
                    env.tile_flavor[x][y].special = SPECIAL_NW;
                }
                else
                {
                    env.tile_flavor[x][y].special = SPECIAL_FULL;
                }
            }
            else
            {
                env.tile_flavor[x][y].special = 0;
            }
        }
    }
    // Second pass for clean up.  The only bad part about the above
    // algorithm is that it could turn a block of floor like this:
    //
    // N4NN
    // 3125
    // NN6N
    //
    // (KEY: N = normal floor, # = special floor)
    //
    // Into these flavors:
    // 1 - SPECIAL_S
    // 2 - SPECIAL_N
    // 3-6, not important
    //
    // Generally the tiles don't fit with a north to the right or left
    // of a south tile.  What we really want to do is to separate the
    // two regions, by making 1 a SPECIAL_SE and 2 a SPECIAL_NW tile.
    for (int x = 0; x < GXM - 1; x++)
    {
        for (int y = 0; y < GYM - 1; y++)
        {
            if (grd[x][y] != DNGN_FLOOR_SPECIAL)
                continue;
            if (env.tile_flavor[x][y].special != SPECIAL_N &&
                env.tile_flavor[x][y].special != SPECIAL_S &&
                env.tile_flavor[x][y].special != SPECIAL_E &&
                env.tile_flavor[x][y].special != SPECIAL_W)
            {
                continue;
            }
            int right_flavor = x < GXM - 1 ? env.tile_flavor[x+1][y].special :
                SPECIAL_FULL;
            int down_flavor = y < GYM - 1 ? env.tile_flavor[x][y+1].special :
                SPECIAL_FULL;
            int this_flavor = env.tile_flavor[x][y].special;
            if (this_flavor == SPECIAL_N && right_flavor == SPECIAL_S)
            {
                env.tile_flavor[x][y].special = SPECIAL_NE;
                env.tile_flavor[x+1][y].special = SPECIAL_SW;
            }
            else if (this_flavor == SPECIAL_S && right_flavor == SPECIAL_N)
            {
                env.tile_flavor[x][y].special = SPECIAL_SE;
                env.tile_flavor[x+1][y].special = SPECIAL_NW;
            }
            else if (this_flavor == SPECIAL_E && down_flavor == SPECIAL_W)
            {
                env.tile_flavor[x][y].special = SPECIAL_SE;
                env.tile_flavor[x][y+1].special = SPECIAL_NW;
            }
            else if (this_flavor == SPECIAL_W && down_flavor == SPECIAL_E)
            {
                env.tile_flavor[x][y].special = SPECIAL_NE;
                env.tile_flavor[x][y+1].special = SPECIAL_SW;
            }
        }
    }
}
void tile_clear_buf()
{
    for (int y = 0; y < GYM; y++)
    {
        for (int x = 0; x < GXM; x++)
        {
            unsigned char this_is_wall = 128;
            gv_now[x][y]=0;
            tile_dngn[x][y]=TILE_DNGN_UNSEEN;
            if (env.map[x][y].glyph() != 0)
            {
                int g = grd[x][y];
                if (g >= DNGN_ORCISH_IDOL && g != DNGN_OPEN_DOOR)
                    this_is_wall = 0;
            }
            wall_flag[x][y] = this_is_wall;
        }
    }
    for (int y = 0; y < GYM; y++)
    {
        for (int x = 0; x < GXM; x++)
        {
            unsigned char w = wall_flag[x][y]&0x80;
            if (w)
            {
                if (x != 0)     wall_flag[x-1][y] |= WFLAG_R;
                if (x != GXM-1) wall_flag[x+1][y] |= WFLAG_L;
                if (y != 0)     wall_flag[x][y-1] |= WFLAG_D;
                if (y != GYM-1) wall_flag[x][y+1] |= WFLAG_U;
            }
            wall_flag[x][y] &= 0xf;
        }
    }
}
/* called from view.cc */
void tile_draw_floor()
{
    int cx, cy;
    for (cy = 0; cy < env.tile_fg.height(); cy++)
    {
        for (cx = 0; cx < env.tile_fg.width(); cx++)
        {
            const coord_def ep(cx+1, cy+1);
            const coord_def gc = view2grid(show2view(ep));
            int bg = TILE_DNGN_UNSEEN | tile_unseen_flag(gc);
            int object = env.show(ep);
            if (in_bounds(gc) && object != 0)
            {
                if (object != gv_now[gc.x][gc.y])
                {
                    if (object == DNGN_SECRET_DOOR)
                        object = (int)grid_secret_door_appearance(gc.x, gc.y);
                    tile_dngn[gc.x][gc.y] = tileidx_feature(object);
                    gv_now[gc.x][gc.y] = object;
                    unsigned char wall = 0xff;
                    if (object >= DNGN_ORCISH_IDOL && object != DNGN_OPEN_DOOR)
                        wall = 0;
                    if (gc.x != 0)
                    {
                        wall_flag[gc.x-1][gc.y] = (wall_flag[gc.x-1][gc.y] & 
                            (~WFLAG_R)) | (wall & WFLAG_R);
                    }
                    if (gc.x != GXM-1)
                    {
                        wall_flag[gc.x+1][gc.y] = (wall_flag[gc.x+1][gc.y] & 
                            (~WFLAG_L)) | (wall & WFLAG_L);
                    }
                    if (gc.y != 0)
                    {
                        wall_flag[gc.x][gc.y-1] = (wall_flag[gc.x][gc.y-1] & 
                            (~WFLAG_D)) | (wall & WFLAG_D);
                    }
                    if (gc.y != GYM-1)
                    {
                        wall_flag[gc.x][gc.y+1] = (wall_flag[gc.x][gc.y+1] & 
                            (~WFLAG_U)) | (wall & WFLAG_U);
                    }
                }
                bg = tile_dngn[gc.x][gc.y];
            }
            // init tiles
            env.tile_bg[ep.x-1][ep.y-1] = bg;
            env.tile_fg[ep.x-1][ep.y-1] = 0;
        }
    }
}
// Called from item() in view.cc
void tile_place_item(int x, int y, int idx)
{
    int t = tileidx_item(mitm[idx]);
    if (mitm[idx].link != NON_ITEM)
        t |= TILE_FLAG_S_UNDER;
    env.tile_fg[x-1][y-1]=t;
    if (item_needs_autopickup(mitm[idx]))
        env.tile_bg[x-1][y-1] |= TILE_FLAG_CURSOR3;
}
void tile_place_item_bk(int gx, int gy, int idx)
{
    int t = tileidx_item(mitm[idx]);
    env.tile_bk_fg[gx][gy] = t;
    if (item_needs_autopickup(mitm[idx]))
        env.tile_bk_bg[gx][gy] |= TILE_FLAG_CURSOR3;
}
void tile_place_tile_bk(int gx, int gy, int tileidx)
{
    env.tile_bk_fg[gx][gy] = tileidx;
}
// Called from item() in view.cc
void tile_place_item_marker(int x, int y, int idx)
{
    env.tile_fg[x-1][y-1] |= TILE_FLAG_S_UNDER;
    if (item_needs_autopickup(mitm[idx]))
        env.tile_bg[x-1][y-1] |= TILE_FLAG_CURSOR3;
}
// Called from monster_grid() in view.cc
void tile_place_monster(int gx, int gy, int idx, bool foreground)
{
    if (idx == NON_MONSTER)
    {
        return;
    }
    const coord_def gc(gx, gy);
    const coord_def ep = view2show(grid2view(gc));
    int t = tileidx_monster(idx);
    int t0 = t & TILE_FLAG_MASK;
    int flag = t & (~TILE_FLAG_MASK);
    int mon_wep = menv[idx].inv[MSLOT_WEAPON];
    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 | TileMcacheFind(cls, eq, race);
    }
    else if (mon_wep != NON_ITEM)
    {
        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:
            if (eq != 0 )
                t = flag | TileMcacheFind(t0, eq);
            break;
        }
    }
    if (foreground)
    {
        env.tile_fg[ep.x-1][ep.y-1] = t;
    }
    else
    {
        env.tile_bk_fg[gc.x][gc.y] = t0;
    }
}
void tile_place_cloud(int x, int y, int type, int decay)
{
    env.tile_fg[x-1][y-1]= tileidx_cloud(type, decay);
}
unsigned int tileRayCount = 0;
FixedVector<coord_def, 30> tileRays;
void tile_place_ray(const coord_def& gc)
{
    // Record rays for later.  The curses version just applies
    // rays directly to the screen.  The tiles version doesn't have
    // (nor want) such direct access.  So, it batches up all of the
    // rays and applies them in viewwindow(...).
    if (tileRayCount < tileRays.size() - 1)
    {
        tileRays[tileRayCount++] = view2show(grid2view(gc));
    }
}
void tile_draw_rays(bool resetCount)
{
    for (unsigned int i = 0; i < tileRayCount; i++)
    {
        env.tile_bg[tileRays[i].x-1][tileRays[i].y-1] |= TILE_FLAG_RAY;
    }
    if (resetCount)
        tileRayCount = 0;
}
void tile_finish_dngn(short unsigned int *tileb, int cx, int cy)
{
    int x, y;
    int count = 0;
    for (y=0; y < crawl_view.viewsz.y; y++)
    {
        for (x=0; x < crawl_view.viewsz.x; x++)
        {
            const int gx = view2gridX(x);
            const int gy = view2gridY(y);
            int wall = 0;
            char wall_flv = 0;
            char floor_flv = 0;
            char special_flv = 0;
            if (map_bounds( gx, gy ))
            {
                wall = wall_flag[gx][gy];
                wall_flv = env.tile_flavor[gx][gy].wall;
                floor_flv = env.tile_flavor[gx][gy].floor;
                special_flv = env.tile_flavor[gx][gy].special;
            }
            finalize_tile(&tileb[count], wall, 
                wall_flv, floor_flv, special_flv);
            finalize_tile(&tileb[count+1], wall,
                wall_flv, floor_flv, special_flv);
            count += 2;
        }
    }
}
void tile_draw_dungeon(short unsigned int *tileb)
{
    tile_finish_dngn(tileb, you.x_pos, you.y_pos);
    TileDrawDungeon(tileb);    
}
#define swapint(a, b) {int tmp = a; a = b; b = tmp;}
// Item is unided(1) or tried(2) or id'ed (0)
//  Note that Jewellries are never "tried"
static int item_unid_type(const item_def &item)
{
    int t = item.base_type;
    int s = item.sub_type;
    int id0 = 0;
    id_arr& id = get_typeid_array();
    if ((item.flags &ISFLAG_KNOW_TYPE) != 0)
        return 0;
    switch (t)
    {
        case OBJ_SCROLLS:
          id0 = id[ IDTYPE_SCROLLS ][s];
          if (id0 == ID_TRIED_TYPE)
             return 2;
          else
          if (id0 != ID_KNOWN_TYPE)
             return 1;
          else
             return 0;
        case OBJ_WANDS:
          id0 = id[ IDTYPE_WANDS ][s];
          if (id0 == ID_TRIED_TYPE)
             return 2;
          else
          if (id0 != ID_KNOWN_TYPE)
             return 1;
          else
             return 0;
        case OBJ_POTIONS:
          id0 = id[ IDTYPE_POTIONS ][s];
          if (id0 == ID_TRIED_TYPE)
             return 2;
          else
          if (id0 != ID_KNOWN_TYPE)
             return 1;
          else
             return 0;
        case OBJ_JEWELLERY:
          id0 = id[ IDTYPE_JEWELLERY ][s];
          if (id0 != ID_KNOWN_TYPE)
             return 1;
          else
             return 0;
    }
    return 0;
}
// Helper routine: sort floor item index and pack into idx
int pack_floor_item(int *idx, int *flag, int *isort, int max)
{
    int n = 0;
    static int isort_weapon2[NUM_WEAPONS];
    static int isort_armour2[NUM_ARMOURS];
    static const int isort_weapon[NUM_WEAPONS] = 
    {
        WPN_WHIP, WPN_CLUB, WPN_HAMMER, WPN_MACE,
        WPN_FLAIL, WPN_DEMON_WHIP,
        WPN_ANCUS, WPN_MORNINGSTAR, WPN_EVENINGSTAR,
        WPN_SPIKED_FLAIL, WPN_GREAT_MACE, WPN_DIRE_FLAIL,
        WPN_GIANT_CLUB,  WPN_GIANT_SPIKED_CLUB,
        WPN_KNIFE, WPN_DAGGER, WPN_SHORT_SWORD, WPN_SABRE, WPN_QUICK_BLADE,
        WPN_FALCHION, WPN_LONG_SWORD, WPN_SCIMITAR, WPN_KATANA,
        WPN_DEMON_BLADE, WPN_DOUBLE_SWORD, WPN_GREAT_SWORD, WPN_TRIPLE_SWORD,
        WPN_HAND_AXE, WPN_WAR_AXE, WPN_BROAD_AXE,
        WPN_BATTLEAXE, WPN_EXECUTIONERS_AXE,
        WPN_SPEAR, WPN_TRIDENT, WPN_HALBERD, WPN_SCYTHE,
        WPN_GLAIVE, WPN_DEMON_TRIDENT,
        WPN_QUARTERSTAFF,
        WPN_SLING, WPN_BOW, WPN_CROSSBOW, WPN_HAND_CROSSBOW
    };
    static const int isort_armour[NUM_ARMOURS] = 
    {
        ARM_ROBE, 
        ARM_ANIMAL_SKIN,
        ARM_LEATHER_ARMOUR,
        ARM_TROLL_LEATHER_ARMOUR,
        ARM_RING_MAIL, ARM_SCALE_MAIL, ARM_CHAIN_MAIL, 
        ARM_SPLINT_MAIL, ARM_BANDED_MAIL, ARM_PLATE_MAIL,
        ARM_CRYSTAL_PLATE_MAIL,
        ARM_SWAMP_DRAGON_ARMOUR,
        ARM_MOTTLED_DRAGON_ARMOUR,
        ARM_STEAM_DRAGON_ARMOUR,
        ARM_DRAGON_ARMOUR,
        ARM_ICE_DRAGON_ARMOUR,
        ARM_STORM_DRAGON_ARMOUR,
        ARM_GOLD_DRAGON_ARMOUR,
        ARM_TROLL_HIDE,
        ARM_SWAMP_DRAGON_HIDE,
        ARM_MOTTLED_DRAGON_HIDE,
        ARM_STEAM_DRAGON_HIDE,
        ARM_DRAGON_HIDE,
        ARM_ICE_DRAGON_HIDE,
        ARM_STORM_DRAGON_HIDE,
        ARM_GOLD_DRAGON_HIDE,
        ARM_CLOAK,
        ARM_BUCKLER, ARM_SHIELD, ARM_LARGE_SHIELD,
        ARM_HELMET, ARM_GLOVES, ARM_BOOTS
    };
    int i;
    for (i=0;i<NUM_WEAPONS;i++)
        isort_weapon2[isort_weapon[i]] = i;
    for (i=0;i<NUM_ARMOURS;i++)
        isort_armour2[isort_armour[i]] = i;
    int o = igrd[you.x_pos][you.y_pos];
    if (o == NON_ITEM) return 0;
    while (o != NON_ITEM)
    {
        int id0 = item_unid_type(mitm[o]);
        int next = mitm[o].link;
        int typ = mitm[o].base_type;
        if (n >= max) break;
        idx[n] = o;
        isort[n] = typ * 256 * 3;
        if (typ == OBJ_WEAPONS)
        {
            isort[n] += 3 * isort_weapon2[ mitm[o].sub_type];
        }
        if (typ == OBJ_ARMOUR)
        {
            isort[n] += 3 * isort_armour2[ mitm[o].sub_type ];
        }
        flag[n] = 0;
        if (item_ident( mitm[o], ISFLAG_KNOW_CURSE ) &&
            item_cursed(mitm[o]))
        {
            flag[n] |= TILEI_FLAG_CURSE;
        }
        if (id0 != 0)
        {
            isort[n] += id0;
            if (id0 == 2)
                flag[n] = TILEI_FLAG_TRIED;
        }
        flag[n] |= TILEI_FLAG_FLOOR;
        // Simple Bubble sort
        int k = n;
        while( (k > 0) && (isort[k-1] > isort[k]))
        {
            swapint(idx[k-1], idx[k]);
            swapint(isort[k-1], isort[k]);
            swapint(flag[k-1], flag[k]);
            k--;
        }
        n++;
        o = next;
    }
    return n;
}
// Helper routine: Calculate tile index and quantity data to be displayed
void finish_inven_data(int n, int *tiles, int *num, int *idx, int *iflag)
{
    int i;
    for(i = 0; i < n; i++)
    {
        int q = -1;
        int j = idx[i];
        item_def *itm;
        if (j==-1)
        {
            num[i]=-1;
            tiles[i]= 0;
            continue;
        }
        if (iflag[i] & TILEI_FLAG_FLOOR)
            itm = &mitm[j];
        else
            itm = &you.inv[j];
        int type = itm->base_type;
        if (type == OBJ_FOOD || type == OBJ_SCROLLS
             || type == OBJ_POTIONS || type == OBJ_MISSILES)
            q = itm->quantity;
        if (q==1) q = -1;
        if (type == OBJ_WANDS && 
              (itm->flags & ISFLAG_KNOW_PLUSES )!= 0)
            q = itm->plus;
        tiles[i] = tileidx_item(*itm);
        num[i] = q;
    }
}
// Display Inventory/floor items
#include "guic.h"
extern TileRegionClass *region_item;
extern TileRegionClass *region_item2;
extern WinClass *win_main;
void tile_draw_inv(int item_type, int flag)
{
    #define MAXINV 200
    int tiles[MAXINV];
    int num[MAXINV];
    int idx[MAXINV];
    int iflag[MAXINV];
    int isort[MAXINV];
    int n = 0;
    int i, j;
    if (flag == -1)
    {
        flag = (win_main->active_layer == 0) ? REGION_INV1 : REGION_INV2;
    }
    TileRegionClass *r = (flag == REGION_INV1) ? region_item:region_item2;
    int numInvTiles = r->mx * r->my;
    if (numInvTiles > MAXINV)
        numInvTiles = MAXINV;
    // item.base_type <-> char conversion table
    const static char *obj_syms = ")([/%#?=!#+\\0}x";
    const static char *syms_table[] =
    {
        ")\\", // weapons and staves
        "(",   // missile
        "[",   // armour
        "/",   // wands
        "%",   // foods
        "#",   //  none
        "?+",  // scrolls and books
        "=",   // rings/amulets
        "!",   // potions
        "#",   //  none
        "?+",  // books/scrolls
        ")\\", // weapons and staves
        "0",
        "}",
        "x"
    };
    const char *item_chars = Options.show_items;
    int eq_flag[ENDOFPACK];
    int empty = 0;
    for (j = 0; j < ENDOFPACK; j++)
    {
        eq_flag[j] =
            (you.inv[j].quantity != 0 && is_valid_item( you.inv[j])) ? 1:0;
        empty += 1-eq_flag[j];
    }
    for (j=0; j<NUM_EQUIP; j++)
    {
        int eq = you.equip[j];
        if (eq >= 0 && eq < ENDOFPACK)
            eq_flag[eq] = 2;
    }
    if (item_type >= 0)
        item_chars = syms_table[item_type];
    else
    if (item_type == -2)
        item_chars = obj_syms;
    else
    if (item_type == -3)
        item_chars = ".";
    if (item_chars[0] == 0) return;
    for (i=0; i < (int)strlen(item_chars); i++)
    {
        int top = n;
        char ic = item_chars[i];
        if (n >= numInvTiles) break;
        // Items on the floor
        if (ic == '.')
        {
            n += pack_floor_item(&idx[n], &iflag[n], &isort[n], numInvTiles - n);
            continue;
        }
        // empty slots
        if (ic == '_')
        {
            for (j = 0; j < empty && n < numInvTiles; j++)
            {
                idx[n] = -1;
                iflag[n] = 0;
                n++;
            }
            continue;
        }
        // convert item char to item type
        int type = -1;
        for (j=0; j < (int)strlen(obj_syms); j++)
        {
            if (obj_syms[j] == ic)
            {
                type = j;
                break;
            }
        }
        if (type == -1) continue;
        for (j = 0; j < ENDOFPACK && n < numInvTiles; j++)
        {
            if (you.inv[j].base_type==type && eq_flag[j] != 0)
            {
                int sval = NUM_EQUIP + you.inv[j].sub_type;
                int base = 0;
                int id0 = item_unid_type(you.inv[j]);
                idx[n] = j;
                iflag[n] = 0;
                if (type == OBJ_JEWELLERY && sval >= AMU_RAGE)
                {
                    base = 1000;
                    sval = base + sval;
                }
                if (id0 == 2)
                {
                     iflag[n] |= TILEI_FLAG_TRIED;
                     // To the tail
                     sval = base + 980;
                }
                else if (id0 == 1)
                {
                     // To the tail
                     sval = base + 990;
                }
                // Equipment first
                if (eq_flag[j]==2)
                {
                     //sval = base;
                     iflag[n] |= TILEI_FLAG_EQUIP;
                }
                if (item_cursed(you.inv[j]) &&
                    item_ident( you.inv[j], ISFLAG_KNOW_CURSE ))
                {
                    iflag[n] |= TILEI_FLAG_CURSE;
                }
                if (flag == REGION_INV2)
                    sval = j;
                isort[n] = sval;
                int k = n;
                while( (k > top) && (isort[k-1] > isort[k]))
                {
                    swapint(idx[k-1], idx[k]);
                    swapint(isort[k-1], isort[k]);
                    swapint(iflag[k-1], iflag[k]);
                    k--;
                }
                n++;
            } // type == base
        } // j
    }  // i
    finish_inven_data(n, tiles, num, idx, iflag);
    for(i = n; i < numInvTiles; i++)
    {
        tiles[i] = 0;
        num[i] = 0;
        idx[i] = -1;
        iflag[i] = 0;
    }
    TileDrawInvData(n, flag, tiles, num, idx, iflag);
}
#endif