void ImgCopyFromTileImg(int idx, img_type dest, int dx, int dy, int copy,
                        char *mask = NULL, bool hilite = false)

void _ImgCopyFromTileImg(int idx, img_type dest, int dx, int dy, int copy,
                         char *mask = NULL, bool hilite = false)

void ImgCopyToTileImg(int idx, img_type src, int sx, int sy, int copy,
                        char *mask = NULL, bool hilite = false)

static void _ImgCopyToTileImg(int idx, img_type src, int sx, int sy, int copy,
                              char *mask = NULL, bool hilite = false)

void lift_tcache(int ix, int kind, int hash)

static void _lift_tcache(int ix, int kind, int hash)

    lift_tcache(tc0->idx, kind, hash);

    _lift_tcache(tc0->idx, kind, hash);

void tcache_overlay(img_type img, int idx,
    int tile, int region, int *copy, char *mask, unsigned int shift_left = 0)

static void _tcache_overlay(img_type img, int idx, int tile, int region,
                            int *copy, char *mask, unsigned int shift_left = 0)

void tcache_overlay_player(img_type img, int dx, int dy,
                        int part, int idx, int ymax, int *copy)

void _tcache_overlay_player(img_type img, int dx, int dy, int part, int idx,
                            int ymax, int *copy)

void update_single_grid(int x, int y)

static void _update_single_grid(int x, int y)

void redraw_spx_tcache(int tile)

static void _redraw_spx_tcache(int tile)

void get_bbg(int bg, int *new_bg, int *bbg)

static void _get_bbg(int bg, int *new_bg, int *bbg)

int sink_mask_tile(int bg, int fg)

static int _sink_mask_tile(int bg, int fg)

    get_bbg(bg0, &new_bg, &bbg);

    _get_bbg(bg0, &new_bg, &bbg);

        tcache_overlay(tc_img, ix, bbg, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, bbg, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_BLOOD0, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_BLOOD0, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, new_bg, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, new_bg, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_SANCTUARY, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_SANCTUARY, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_TRAVEL_EXCLUSION, TREGION_0_NORMAL, &c, 
                       NULL);

        _tcache_overlay(tc_img, ix, TILE_TRAVEL_EXCLUSION, TREGION_0_NORMAL, &c,
                        NULL);

        tcache_overlay(tc_img, ix, TILE_RAY_MESH, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_RAY_MESH, TREGION_0_NORMAL, &c, NULL);

        sink = sink_mask_tile(bg0, fg0);

        sink = _sink_mask_tile(bg0, fg0);

            tcache_overlay(tc_img, ix, fg0, TREGION_0_NORMAL, &c, sink_mask);

            _tcache_overlay(tc_img, ix, fg0, TREGION_0_NORMAL, &c, sink_mask);

            tcache_overlay(tc_img, ix, fg0, TREGION_0_NORMAL, &c, NULL);

            _tcache_overlay(tc_img, ix, fg0, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_TRAP_NET, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_TRAP_NET, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_SOMETHING_UNDER,
                       TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_SOMETHING_UNDER,
                        TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_HEART, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_HEART, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_NEUTRAL, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_NEUTRAL, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_STAB_BRAND, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_STAB_BRAND, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_MAY_STAB_BRAND, TREGION_0_NORMAL, &c,
                       NULL);

        _tcache_overlay(tc_img, ix, TILE_MAY_STAB_BRAND, TREGION_0_NORMAL, &c,
                        NULL);

        tcache_overlay(tc_img, ix, TILE_POISON, TREGION_0_NORMAL, &c, NULL,
                       status_shift);

        _tcache_overlay(tc_img, ix, TILE_POISON, TREGION_0_NORMAL, &c, NULL,
                        status_shift);

        tcache_overlay(tc_img, ix, TILE_MESH, TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_MESH, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_MAGIC_MAP_MESH, TREGION_0_NORMAL, &c, 
                       NULL);

        _tcache_overlay(tc_img, ix, TILE_MAGIC_MAP_MESH, TREGION_0_NORMAL, &c,
                        NULL);

        tcache_overlay(tc_img, ix, TILE_NEW_STAIR,
                       TREGION_0_NORMAL, &c, NULL);

        _tcache_overlay(tc_img, ix, TILE_NEW_STAIR, TREGION_0_NORMAL, &c, NULL);

        tcache_overlay(tc_img, ix, TILE_TRAVEL_EXCLUSION, TREGION_0_NORMAL, &c, 
                       NULL);

        _tcache_overlay(tc_img, ix, TILE_TRAVEL_EXCLUSION, TREGION_0_NORMAL, &c,
                        NULL);

       tcache_overlay(tc_img, ix, type, TREGION_0_NORMAL, &c, NULL);

       _tcache_overlay(tc_img, ix, type, TREGION_0_NORMAL, &c, NULL);

    update_single_grid(x, y);

    _update_single_grid(x, y);

    update_single_grid(x, y);

    _update_single_grid(x, y);

static void TileLoadWallAux(int idx_src, int idx_dst, img_type wall)

static void _TileLoadWallAux(int idx_src, int idx_dst, img_type wall)

    ImgCopyToTileImg(idx_dst, wall, sx, sy, 1);

    _ImgCopyToTileImg(idx_dst, wall, sx, sy, 1);

        int idx_src = tile_W2D_start[floor_idx] + i;
        int idx_dst = offset++;
        TileLoadWallAux(idx_src, idx_dst, WallImg);

         int idx_src = tile_W2D_start[floor_idx] + i;
         int idx_dst = offset++;
         _TileLoadWallAux(idx_src, idx_dst, WallImg);

        int idx_src = tile_W2D_start[wall_idx] + i;
        int idx_dst = offset++;
        TileLoadWallAux(idx_src, idx_dst, WallImg);

         int idx_src = tile_W2D_start[wall_idx] + i;
         int idx_dst = offset++;
         _TileLoadWallAux(idx_src, idx_dst, WallImg);

            int idx_src = tile_W2D_start[special_idx] + i;
            int idx_dst = offset++;
            TileLoadWallAux(idx_src, idx_dst, WallImg);

             int idx_src = tile_W2D_start[special_idx] + i;
             int idx_dst = offset++;
             _TileLoadWallAux(idx_src, idx_dst, WallImg);

            tcache_overlay_player(img, 0, 0, TILEP_PART_SHADOW,
                                  tile, TILE_Y, &c);

            _tcache_overlay_player(img, 0, 0, TILEP_PART_SHADOW,
                                   tile, TILE_Y, &c);

            tcache_overlay_player(img, 0, 0, p, parts2[p], ymax, &c);

            _tcache_overlay_player(img, 0, 0, p, parts2[p], ymax, &c);

static void load_doll_data(const char *fn, dolls_data *dolls, int max,
                           int *mode, int *cur)

static void _load_doll_data(const char *fn, dolls_data *dolls, int max,
                            int *mode, int *cur)

    load_doll_data("dolls.txt", dolls, DOLLS_MAX, &mode, &cur_doll);

    _load_doll_data("dolls.txt", dolls, DOLLS_MAX, &mode, &cur_doll);

                tcache_overlay_player(PartsImg, i * TILE_X, 0, 

                _tcache_overlay_player(PartsImg, i * TILE_X, 0,

            ImgCopyFromTileImg( TILE_CURSOR, ScrBufImg,
                              (3 + PARTS_DISP_MAX / 2) * TILE_X, 4 * TILE_Y, 0);

            _ImgCopyFromTileImg( TILE_CURSOR, ScrBufImg,
                                (3 + PARTS_DISP_MAX / 2) * TILE_X,
                                4 * TILE_Y, 0);

        ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(TILE_PLAYER, ScrBufImg, 8*TILE_X, 8*TILE_Y, 0);

        _ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);
        _ImgCopyFromTileImg(TILE_PLAYER, ScrBufImg, 8*TILE_X, 8*TILE_Y, 0);

        ImgCopyFromTileImg( TILE_CURSOR, ScrBufImg,
                            (3 + cur_doll) * TILE_X, PARTS_Y, 0);

        _ImgCopyFromTileImg( TILE_CURSOR, ScrBufImg,
                             (3 + cur_doll) * TILE_X, PARTS_Y, 0);

    ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);

    _ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);

    redraw_spx_tcache(TILE_PLAYER);

    _redraw_spx_tcache(TILE_PLAYER);

    ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);

    _ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);

    redraw_spx_tcache(TILE_PLAYER);

    _redraw_spx_tcache(TILE_PLAYER);

    update_single_grid(ep.x-1, ep.y-1);

    _update_single_grid(ep.x-1, ep.y-1);

    load_doll_data("dolls.txt", &doll, 1, &mode, &cur_doll); 

    _load_doll_data("dolls.txt", &doll, 1, &mode, &cur_doll);

    ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);

    _ImgCopyToTileImg(TILE_PLAYER, DollCacheImg, 0, 0, 1);

    ImgCopyToTileImg(TILE_MONS_PLAYER_GHOST, DollCacheImg, 0, 0, 1);

    _ImgCopyToTileImg(TILE_MONS_PLAYER_GHOST, DollCacheImg, 0, 0, 1);

    ImgCopyToTileImg(TILE_MONS_PLAYER_GHOST, DollCacheImg, 0, 0, 1, mask, false);
    redraw_spx_tcache(TILE_MONS_PLAYER_GHOST);

    _ImgCopyToTileImg(TILE_MONS_PLAYER_GHOST, DollCacheImg, 0, 0, 1, mask, false);
    _redraw_spx_tcache(TILE_MONS_PLAYER_GHOST);

        ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        _ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        _ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        _ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        _ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        _ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        _ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        _ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        _ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        _ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

        _ImgCopyFromTileImg(tile0, DollCacheImg, 0, 0, 1);
        _ImgCopyFromTileImg(tile1, DollCacheImg, 0, 0, 0);
        _ImgCopyToTileImg(tile1, DollCacheImg, 0, 0, 1);

static void ImgCopyDoll(int equ_tile, int hand, int ofs_x, int ofs_y)

static void _ImgCopyDoll(int equ_tile, int hand, int ofs_x, int ofs_y)

static void mcache_compose(int tile_idx, int mon_tile, int equ_tile)

static void _mcache_compose(int tile_idx, int mon_tile, int equ_tile)

    ImgCopyFromTileImg(mon_tile, DollCacheImg, 0, 0, 1);

    _ImgCopyFromTileImg(mon_tile, DollCacheImg, 0, 0, 1);

    ImgCopyDoll(equ_tile, 1, ofs_x, ofs_y);

    _ImgCopyDoll(equ_tile, 1, ofs_x, ofs_y);

        ImgCopyDoll(eq2, 2, -ofs_x, ofs_y);

        _ImgCopyDoll(eq2, 2, -ofs_x, ofs_y);

    ImgCopyToTileImg(tile_idx, DollCacheImg, 0, 0, 1);

    _ImgCopyToTileImg(tile_idx, DollCacheImg, 0, 0, 1);

    redraw_spx_tcache(tile_idx);

    _redraw_spx_tcache(tile_idx);

static void mcache_compose_draco(int tile_idx, int race, int cls, int w)

static void _mcache_compose_draco(int tile_idx, int race, int cls, int w)

    ImgCopyToTileImg(tile_idx, DollCacheImg, 0, 0, 1);
    redraw_spx_tcache(tile_idx);

    _ImgCopyToTileImg(tile_idx, DollCacheImg, 0, 0, 1);
    _redraw_spx_tcache(tile_idx);

        mcache_compose_draco(mc->idx, draco, mon_tile, equ_tile);

        _mcache_compose_draco(mc->idx, draco, mon_tile, equ_tile);

        mcache_compose(mc->idx, mon_tile, equ_tile);

        _mcache_compose(mc->idx, mon_tile, equ_tile);

static void TilePutch(int c, img_type Dest, int dx, int dy)

static void _TilePutch(int c, img_type Dest, int dx, int dy)

        ImgCopyFromTileImg(TILE_DNGN_UNSEEN, r->backbuf, dx, dy, 1);

        _ImgCopyFromTileImg(TILE_DNGN_UNSEEN, r->backbuf, dx, dy, 1);

        ImgCopyFromTileImg(TILE_DNGN_FLOOR, r->backbuf, dx, dy, 1);

        _ImgCopyFromTileImg(TILE_DNGN_FLOOR, r->backbuf, dx, dy, 1);

        ImgCopyFromTileImg(TILE_ITEM_SLOT, r->backbuf, dx, dy, 1);

        _ImgCopyFromTileImg(TILE_ITEM_SLOT, r->backbuf, dx, dy, 1);

            ImgCopyFromTileImg(TILE_ITEM_SLOT_EQUIP_CURSED, r->backbuf, 
                               dx, dy, 0);

            _ImgCopyFromTileImg(TILE_ITEM_SLOT_EQUIP_CURSED, r->backbuf,
                                dx, dy, 0);

            ImgCopyFromTileImg(TILE_ITEM_SLOT_EQUIP, r->backbuf, dx, dy, 0);

            _ImgCopyFromTileImg(TILE_ITEM_SLOT_EQUIP, r->backbuf, dx, dy, 0);

        ImgCopyFromTileImg(TILE_ITEM_SLOT_CURSED, r->backbuf, dx, dy, 0);

        _ImgCopyFromTileImg(TILE_ITEM_SLOT_CURSED, r->backbuf, dx, dy, 0);

        ImgCopyFromTileImg(TILE_RAY_MESH, r->backbuf, dx, dy, 0);

        _ImgCopyFromTileImg(TILE_RAY_MESH, r->backbuf, dx, dy, 0);

        ImgCopyFromTileImg(TILE_CURSOR, r->backbuf, dx, dy, 0);

        _ImgCopyFromTileImg(TILE_CURSOR, r->backbuf, dx, dy, 0);

    ImgCopyFromTileImg(tile, r->backbuf, dx, dy, 0);

    _ImgCopyFromTileImg(tile, r->backbuf, dx, dy, 0);

            TilePutch('0' + c100, r->backbuf, dx+offset, dy);

            _TilePutch('0' + c100, r->backbuf, dx+offset, dy);

            TilePutch('0' + c10, r->backbuf, dx+offset, dy);

            _TilePutch('0' + c10, r->backbuf, dx+offset, dy);

        TilePutch('0' + c1, r->backbuf, dx+offset, dy);

        _TilePutch('0' + c1, r->backbuf, dx+offset, dy);

        TilePutch('?', r->backbuf, dx, dy + TILE_Y/2);

        _TilePutch('?', r->backbuf, dx, dy + TILE_Y/2);

int tileidx_monster_base(int mon_idx, bool detected)

static int _tileidx_monster_base(int mon_idx, bool detected)

int tileidx_monster(int mon_idx, bool detected)

static int _tileidx_monster(int mon_idx, bool detected)

    int ch = tileidx_monster_base(mon_idx, detected);

    int ch = _tileidx_monster_base(mon_idx, detected);

int tileidx_fixed_artifact(int special)

static int _tileidx_fixed_artefact(int special)

  int ch = TILE_ERROR;

  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;

  case SPWPN_SINGING_SWORD:       return TILE_SPWPN_SINGING_SWORD;
  case SPWPN_WRATH_OF_TROG:       return TILE_SPWPN_WRATH_OF_TROG;
  case SPWPN_SCYTHE_OF_CURSES:    return TILE_SPWPN_SCYTHE_OF_CURSES;
  case SPWPN_MACE_OF_VARIABILITY: return TILE_SPWPN_MACE_OF_VARIABILITY;
  case SPWPN_GLAIVE_OF_PRUNE:     return TILE_SPWPN_GLAIVE_OF_PRUNE;
  case SPWPN_SCEPTRE_OF_TORMENT:  return TILE_SPWPN_SCEPTRE_OF_TORMENT;
  case SPWPN_SWORD_OF_ZONGULDROK: return TILE_SPWPN_SWORD_OF_ZONGULDROK;
  case SPWPN_SWORD_OF_CEREBOV:    return TILE_SPWPN_SWORD_OF_CEREBOV;
  case SPWPN_STAFF_OF_DISPATER:   return TILE_SPWPN_STAFF_OF_DISPATER;
  case SPWPN_SCEPTRE_OF_ASMODEUS: return TILE_SPWPN_SCEPTRE_OF_ASMODEUS;
  case SPWPN_SWORD_OF_POWER:      return TILE_SPWPN_SWORD_OF_POWER;
  case SPWPN_KNIFE_OF_ACCURACY:   return TILE_SPWPN_KNIFE_OF_ACCURACY;
  case SPWPN_STAFF_OF_OLGREB:     return TILE_SPWPN_STAFF_OF_OLGREB;
  case SPWPN_VAMPIRES_TOOTH:      return TILE_SPWPN_VAMPIRES_TOOTH;
  case SPWPN_STAFF_OF_WUCAD_MU:   return TILE_SPWPN_STAFF_OF_WUCAD_MU;

  return ch;

  
  return TILE_ERROR;

int tileidx_unrand_artifact(int idx)

static int _tileidx_unrand_artefact(int idx)

int get_etype(const item_def &item)

static int _get_etype(const item_def &item)

    int etype;

            etype = 1;
            break;

            return 1;

            etype = 2;
            break;

            return 2;

            etype = 3;
            break;

            return 3;

            etype = is_random_artefact(item) ? 4 : 0;
            break;

            return (is_random_artefact(item) ? 4 : 0);

    return etype;

int tileidx_weapon(const item_def &item)

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

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

    int race  = item.flags & ISFLAG_RACIAL_MASK;
    int etype = _get_etype(item);

    switch (item.sub_type)
    {
    case WPN_KNIFE:
        return TILE_WPN_KNIFE;
    case WPN_DAGGER:
        if (race == ISFLAG_ORCISH)
            return TILE_WPN_DAGGER_ORC;
        if (race == ISFLAG_ELVEN)
            return TILE_WPN_DAGGER_ELF;
        return TILE_WPN_DAGGER;

  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_SHORT_SWORD:
        if (race == ISFLAG_ORCISH)
            return TILE_WPN_SHORT_SWORD_ORC;
        if (race == ISFLAG_ELVEN)
            return TILE_WPN_SHORT_SWORD_ELF;
        return TILE_WPN_SHORT_SWORD + etable[1][etype];
    case WPN_QUICK_BLADE:
        return TILE_WPN_QUICK_BLADE;
    case WPN_SABRE:
        return TILE_WPN_SABRE + etable[1][etype];
    case WPN_FALCHION:
        return TILE_WPN_FALCHION;
    case WPN_KATANA:
        return TILE_WPN_KATANA + etable[1][etype];

    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;

      ch=TILE_WPN_LONG_SWORD + etable[1][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_LONG_SWORD_ORC;
      break;

        if (race == ISFLAG_ORCISH)
            return TILE_WPN_LONG_SWORD_ORC;
        return TILE_WPN_LONG_SWORD + etable[1][etype];

      ch=TILE_WPN_GREAT_SWORD + etable[1][etype];
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_GREAT_SWORD_ORC;
      break;

        if (race == ISFLAG_ORCISH)
            return TILE_WPN_GREAT_SWORD_ORC;
        return TILE_WPN_GREAT_SWORD + etable[1][etype];

      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;

        return TILE_WPN_SCIMITAR + etable[1][etype];

    case WPN_HAND_AXE: ch=TILE_WPN_HAND_AXE; break;
    case WPN_WAR_AXE: ch=TILE_WPN_WAR_AXE; break;

    case WPN_DOUBLE_SWORD:
        return TILE_WPN_DOUBLE_SWORD;
    case WPN_TRIPLE_SWORD:
        return TILE_WPN_TRIPLE_SWORD;
    case WPN_HAND_AXE:
        return TILE_WPN_HAND_AXE;
    case WPN_WAR_AXE:
        return TILE_WPN_WAR_AXE;

      ch=TILE_WPN_BROAD_AXE + etable[1][etype];
      break;

        return TILE_WPN_BROAD_AXE + etable[1][etype];

      ch=TILE_WPN_BATTLEAXE + etable[1][etype];
      break;

        return TILE_WPN_BATTLEAXE + etable[1][etype];

      ch=TILE_WPN_EXECUTIONERS_AXE + etable[1][etype];
      break;

        return TILE_WPN_EXECUTIONERS_AXE + etable[1][etype];

      ch=TILE_WPN_BLOWGUN + etable[1][etype];
      break;
    case WPN_SLING: ch=TILE_WPN_SLING; break;

        return TILE_WPN_BLOWGUN + etable[1][etype];
    case WPN_SLING:
        return TILE_WPN_SLING;

      ch=TILE_WPN_BOW + etable[1][etype];
      break;

        return TILE_WPN_BOW + etable[1][etype];

      ch=TILE_WPN_CROSSBOW + etable[1][etype];
      break;

        return TILE_WPN_CROSSBOW + etable[1][etype];

      ch=TILE_WPN_HAND_CROSSBOW + etable[1][etype];
      break;

        return TILE_WPN_HAND_CROSSBOW + etable[1][etype];

    case WPN_SPEAR: 
      ch=TILE_WPN_SPEAR + etable[1][etype]; 
      break;

    case WPN_SPEAR:
        return TILE_WPN_SPEAR + etable[1][etype];

      ch=TILE_WPN_TRIDENT + etable[1][etype]; 
      break;

        return TILE_WPN_TRIDENT + etable[1][etype];

      ch=TILE_WPN_HALBERD + etable[1][etype]; 
      break;

        return TILE_WPN_HALBERD + etable[1][etype];

      ch=TILE_WPN_SCYTHE + etable[1][etype]; 
      break;

        return TILE_WPN_SCYTHE + etable[1][etype];

      ch=TILE_WPN_GLAIVE + etable[1][etype]; 
      if (race == ISFLAG_ORCISH) ch = TILE_WPN_GLAIVE_ORC;
      break;

        if (race == ISFLAG_ORCISH)
            return TILE_WPN_GLAIVE_ORC;
        return TILE_WPN_GLAIVE + etable[1][etype];
    case WPN_QUARTERSTAFF:
        return TILE_WPN_QUARTERSTAFF;
    case WPN_CLUB:
        return TILE_WPN_CLUB;

    case WPN_QUARTERSTAFF: ch=TILE_WPN_QUARTERSTAFF; break;

    case WPN_HAMMER:
        return TILE_WPN_HAMMER + etable[1][etype];

    case WPN_CLUB: ch=TILE_WPN_CLUB; break;
    case WPN_HAMMER: 
      ch=TILE_WPN_HAMMER + etable[1][etype];
      break;

      ch=TILE_WPN_MACE + etable[1][etype];
      break;
    case WPN_FLAIL: 
      ch=TILE_WPN_FLAIL + etable[1][etype];
      break;

        return TILE_WPN_MACE + etable[1][etype];
    case WPN_FLAIL:
        return TILE_WPN_FLAIL + etable[1][etype];

      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;

        return TILE_WPN_SPIKED_FLAIL + etable[1][etype];
    case WPN_GREAT_MACE:
        return TILE_WPN_GREAT_MACE + etable[1][etype];
    case WPN_DIRE_FLAIL:
        return TILE_WPN_GREAT_FLAIL + etable[1][etype];
    case WPN_MORNINGSTAR:
        return TILE_WPN_MORNINGSTAR + etable[1][etype];

      ch=TILE_WPN_EVENINGSTAR + etable[1][etype];
      break;

        return TILE_WPN_EVENINGSTAR + etable[1][etype];
    case WPN_GIANT_CLUB:
        return TILE_WPN_GIANT_CLUB;
    case WPN_GIANT_SPIKED_CLUB:
        return TILE_WPN_GIANT_SPIKED_CLUB;
    case WPN_ANCUS:
        return TILE_WPN_ANCUS;
    case WPN_WHIP:
        return TILE_WPN_WHIP;
    case WPN_DEMON_BLADE:
        return TILE_WPN_DEMON_BLADE;
    case WPN_DEMON_WHIP:
        return TILE_WPN_DEMON_WHIP;
    case WPN_DEMON_TRIDENT:
        return TILE_WPN_DEMON_TRIDENT;
    case WPN_BLESSED_BLADE:
        return TILE_WPN_BLESSED_BLADE;

    case WPN_GIANT_CLUB: ch=TILE_WPN_GIANT_CLUB; break;
    case WPN_GIANT_SPIKED_CLUB: ch=TILE_WPN_GIANT_SPIKED_CLUB; break;

    case WPN_LONGBOW:
        return TILE_WPN_LONGBOW;

    case WPN_ANCUS: ch=TILE_WPN_ANCUS; break;
    case WPN_WHIP: ch=TILE_WPN_WHIP; break;

    case WPN_LAJATANG:
        return TILE_WPN_LAJATANG;

    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;

    case WPN_BARDICHE:
        return TILE_WPN_LOCHABER_AXE;
    }
  
    return TILE_ERROR;

int tileidx_missile(const item_def &item)

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

    int brand = item.special;
    switch(item.sub_type)
    {
    case MI_STONE:        return TILE_MI_STONE;
    case MI_ARROW:        return TILE_MI_ARROW;
    case MI_BOLT:         return TILE_MI_BOLT;
    case MI_LARGE_ROCK:   return TILE_MI_LARGE_ROCK;
    case MI_SLING_BULLET: return TILE_MI_SLING_BULLET;
    case MI_JAVELIN:      return TILE_MI_JAVELIN;
    case MI_THROWING_NET: return TILE_MI_THROWING_NET;
    case MI_DART:
        if (brand == SPMSL_POISONED || brand == SPMSL_POISONED_II)
            return TILE_MI_DART_P;
        return TILE_MI_DART;

      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;

        if (brand == SPMSL_POISONED || brand == SPMSL_POISONED_II)
            return TILE_MI_NEEDLE_P;
        return TILE_MI_NEEDLE;

  return ch;

  
  return TILE_ERROR;

int tileidx_armour(const item_def &item)

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

    int race  = item.flags & ISFLAG_RACIAL_MASK;
    int type  = item.sub_type;
    int etype = _get_etype(item);

        ch = TILE_ARM_ROBE + etable[2][etype];
        break;

        return TILE_ARM_ROBE + etable[2][etype];
        

        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;

        if (race == ISFLAG_ORCISH)
            return TILE_ARM_LEATHER_ARMOUR_ORC;
        if (race == ISFLAG_ELVEN)
            return TILE_ARM_LEATHER_ARMOUR_ELF;
        return TILE_ARM_LEATHER_ARMOUR  + etable[2][etype];
        

        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;

        if (race == ISFLAG_ORCISH)
            return TILE_ARM_RING_MAIL_ORC;
        if (race == ISFLAG_ELVEN)
            return TILE_ARM_RING_MAIL_ELF;
        if (race == ISFLAG_DWARVEN)
            return TILE_ARM_RING_MAIL_DWA;
        return TILE_ARM_RING_MAIL + etable[1][etype];
        

        ch = TILE_ARM_SCALE_MAIL + etable[1][etype];
        if (race == ISFLAG_ELVEN ) ch = TILE_ARM_SCALE_MAIL_ELF;
        break;

        if (race == ISFLAG_ELVEN)
            return TILE_ARM_SCALE_MAIL_ELF;
        return TILE_ARM_SCALE_MAIL + etable[1][etype];

        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;

        if (race == ISFLAG_ELVEN)
            return TILE_ARM_CHAIN_MAIL_ELF;
        if (race == ISFLAG_ORCISH)
            return TILE_ARM_CHAIN_MAIL_ORC;
        return TILE_ARM_CHAIN_MAIL + etable[1][etype];

        ch = TILE_ARM_SPLINT_MAIL;
        break;

        return TILE_ARM_SPLINT_MAIL;

        ch = TILE_ARM_BANDED_MAIL;
        break;

        return TILE_ARM_BANDED_MAIL;

        ch = TILE_ARM_PLATE_MAIL;
        if (race == ISFLAG_ORCISH) ch = TILE_ARM_PLATE_MAIL_ORC;
        break;

        if (race == ISFLAG_ORCISH)
            return TILE_ARM_PLATE_MAIL_ORC;
        return TILE_ARM_PLATE_MAIL;

        ch = TILE_ARM_CRYSTAL_PLATE_MAIL;
        break;

        return TILE_ARM_CRYSTAL_PLATE_MAIL;

        ch = TILE_ARM_SHIELD  + etable[2][etype];
        break;

        return TILE_ARM_SHIELD  + etable[2][etype];

        ch = TILE_ARM_CLOAK + etable[3][etype];
        break;

        return TILE_ARM_CLOAK + etable[3][etype];

        ch = TILE_THELM_WIZARD_HAT + etable[1][etype];
        break;

        return TILE_THELM_WIZARD_HAT + etable[1][etype];

        ch = TILE_THELM_CAP;
        break;

        return TILE_THELM_CAP;

        ch = TILE_THELM_HELM  + etable[3][etype];
        break;

        return TILE_THELM_HELM  + etable[3][etype];

        ch = TILE_ARM_GLOVES  + etable[3][etype];
        break;

        return TILE_ARM_GLOVES  + etable[3][etype];

        ch = TILE_ARM_BOOTS + etable[3][etype];
        break;

        return TILE_ARM_BOOTS + etable[3][etype];

        ch = TILE_ARM_BUCKLER + etable[1][etype]; 
        break;

        return TILE_ARM_BUCKLER + etable[1][etype];

        ch = TILE_ARM_LARGE_SHIELD + etable[2][etype];
        break;

        return TILE_ARM_LARGE_SHIELD + etable[2][etype];

        ch = TILE_ARM_CENTAUR_BARDING + etable[3][etype];
        break;

        return TILE_ARM_CENTAUR_BARDING + etable[3][etype];

        ch = TILE_ARM_NAGA_BARDING + etable[3][etype];
        break;

        return TILE_ARM_NAGA_BARDING + etable[3][etype];

        ch = TILE_ARM_ANIMAL_SKIN + etable[1][etype];
        break;

        return TILE_ARM_ANIMAL_SKIN + etable[1][etype];

        ch = TILE_ARM_TROLL_HIDE;
        break;

        return TILE_ARM_TROLL_HIDE;

        ch = TILE_ARM_TROLL_LEATHER_ARMOUR;
        break;

        return TILE_ARM_TROLL_LEATHER_ARMOUR;

        ch = TILE_ARM_DRAGON_HIDE;
        break;

        return TILE_ARM_DRAGON_HIDE;

        ch = TILE_ARM_DRAGON_ARMOUR;
        break;

        return TILE_ARM_DRAGON_ARMOUR;

        ch = TILE_ARM_ICE_DRAGON_HIDE;
        break;

        return TILE_ARM_ICE_DRAGON_HIDE;

        ch = TILE_ARM_ICE_DRAGON_ARMOUR;
        break;

        return TILE_ARM_ICE_DRAGON_ARMOUR;

        ch = TILE_ARM_STEAM_DRAGON_HIDE;
        break;

        return TILE_ARM_STEAM_DRAGON_HIDE;

        ch = TILE_ARM_STEAM_DRAGON_ARMOUR;
        break;

        return TILE_ARM_STEAM_DRAGON_ARMOUR;

        ch = TILE_ARM_MOTTLED_DRAGON_HIDE;
        break;

        return TILE_ARM_MOTTLED_DRAGON_HIDE;

        ch = TILE_ARM_MOTTLED_DRAGON_ARMOUR;
        break;

        return TILE_ARM_MOTTLED_DRAGON_ARMOUR;

        ch = TILE_ARM_STORM_DRAGON_HIDE;
        break;

        return TILE_ARM_STORM_DRAGON_HIDE;

        ch = TILE_ARM_STORM_DRAGON_ARMOUR;
        break;

        return TILE_ARM_STORM_DRAGON_ARMOUR;

        ch = TILE_ARM_GOLD_DRAGON_HIDE;
        break;

        return TILE_ARM_GOLD_DRAGON_HIDE;

        ch = TILE_ARM_GOLD_DRAGON_ARMOUR;
        break;

        return TILE_ARM_GOLD_DRAGON_ARMOUR;

        ch = TILE_ARM_SWAMP_DRAGON_HIDE;
        break;

        return TILE_ARM_SWAMP_DRAGON_HIDE;

        ch = TILE_ARM_SWAMP_DRAGON_ARMOUR;
        break;

        return TILE_ARM_SWAMP_DRAGON_ARMOUR;

    return ch;

    return TILE_ERROR;

int tileidx_food(const item_def &item)

static int _tileidx_food(const item_def &item)

    int ch = TILE_ERROR;
    int type=item.sub_type;
    switch(type)

    switch (item.sub_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_MEAT_RATION:  return TILE_FOOD_MEAT_RATION;
    case FOOD_BREAD_RATION: return TILE_FOOD_BREAD_RATION;
    case FOOD_PEAR:         return TILE_FOOD_PEAR;
    case FOOD_APPLE:        return TILE_FOOD_APPLE;
    case FOOD_CHOKO:        return TILE_FOOD_CHOKO;
    case FOOD_HONEYCOMB:    return TILE_FOOD_HONEYCOMB;
    case FOOD_ROYAL_JELLY:  return TILE_FOOD_ROYAL_JELLY;
    case FOOD_SNOZZCUMBER:  return TILE_FOOD_SNOZZCUMBER;
    case FOOD_PIZZA:        return TILE_FOOD_PIZZA;
    case FOOD_APRICOT:      return TILE_FOOD_APRICOT;
    case FOOD_ORANGE:       return TILE_FOOD_ORANGE;
    case FOOD_BANANA:       return TILE_FOOD_BANANA;
    case FOOD_STRAWBERRY:   return TILE_FOOD_STRAWBERRY;
    case FOOD_RAMBUTAN:     return TILE_FOOD_RAMBUTAN;
    case FOOD_LEMON:        return TILE_FOOD_LEMON;
    case FOOD_GRAPE:        return TILE_FOOD_GRAPE;
    case FOOD_SULTANA:      return TILE_FOOD_SULTANA;
    case FOOD_LYCHEE:       return TILE_FOOD_LYCHEE;
    case FOOD_BEEF_JERKY:   return TILE_FOOD_BEEF_JERKY;
    case FOOD_CHEESE:       return TILE_FOOD_CHEESE;
    case FOOD_SAUSAGE:      return TILE_FOOD_SAUSAGE;

        ch=TILE_FOOD_CHUNK; 
        if (food_is_rotten(item)) ch = TILE_FOOD_CHUNK_ROTTEN;
        break;

        if (food_is_rotten(item))
            return TILE_FOOD_CHUNK_ROTTEN;
        return TILE_FOOD_CHUNK;

    return ch;

    return TILE_ERROR;

int tileidx_corpse(int mon)

// returns index of corpse tiles
// parameter mon already holds the corpse type (monster species)
static int _tileidx_corpse(int mon)

  int ch = TILE_ERROR;
  switch(mon)

  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_GIANT_COCKROACH:      return TILE_CORPSE_GIANT_COCKROACH;
  case MONS_GIANT_ANT:            return TILE_CORPSE_GIANT_ANT;
  case MONS_SOLDIER_ANT:          return TILE_CORPSE_SOLDIER_ANT;
  case MONS_GIANT_BAT:            return TILE_CORPSE_GIANT_BAT;
  case MONS_BUTTERFLY:            return TILE_CORPSE_BUTTERFLY;
  // including centaur warrior
  case MONS_CENTAUR:              return TILE_CORPSE_CENTAUR;
  // including yaktaur captain
  case MONS_YAKTAUR:              return TILE_CORPSE_YAKTAUR;
  // draconians
  case MONS_DRACONIAN:            return TILE_CORPSE_DRACONIAN_BROWN;
  case MONS_BLACK_DRACONIAN:      return TILE_CORPSE_DRACONIAN_BLACK;
  case MONS_YELLOW_DRACONIAN:     return TILE_CORPSE_DRACONIAN_YELLOW;
  case MONS_GREEN_DRACONIAN:      return TILE_CORPSE_DRACONIAN_GREEN;
  case MONS_MOTTLED_DRACONIAN:    return TILE_CORPSE_DRACONIAN_MOTTLED;
  case MONS_PALE_DRACONIAN:       return TILE_CORPSE_DRACONIAN_PALE;
  case MONS_PURPLE_DRACONIAN:     return TILE_CORPSE_DRACONIAN_PURPLE;
  case MONS_RED_DRACONIAN:        return TILE_CORPSE_DRACONIAN_RED;
  case MONS_WHITE_DRACONIAN:      return TILE_CORPSE_DRACONIAN_WHITE;
  // all elves
  case MONS_ELF:                  return TILE_CORPSE_ELF;
  
  case MONS_JACKAL:               return TILE_CORPSE_JACKAL;
  case MONS_HOUND:                return TILE_CORPSE_HOUND;
  case MONS_WAR_DOG:              return TILE_CORPSE_WAR_DOG;
  case MONS_HOG:                  return TILE_CORPSE_HOG;
  case MONS_WOLF:                 return TILE_CORPSE_WOLF;
  case MONS_WARG:                 return TILE_CORPSE_WARG;
  case MONS_GOBLIN:               return TILE_CORPSE_GOBLIN;
  case MONS_HOBGOBLIN:            return TILE_CORPSE_HOBGOBLIN;
  case MONS_GNOLL:                return TILE_CORPSE_GNOLL;
  case MONS_KILLER_BEE:           return TILE_CORPSE_KILLER_BEE;
  case MONS_KILLER_BEE_LARVA:     return TILE_CORPSE_KILLER_BEE_LARVA;
  case MONS_BUMBLEBEE:            return TILE_CORPSE_BUMBLEBEE;
  case MONS_ELEPHANT_SLUG:        return TILE_CORPSE_ELEPHANT_SLUG;
  case MONS_GIANT_SLUG:           return TILE_CORPSE_GIANT_SLUG;
  case MONS_GIANT_SNAIL:          return TILE_CORPSE_GIANT_SNAIL;
  case MONS_GIANT_NEWT:           return TILE_CORPSE_GIANT_NEWT;
  case MONS_GIANT_GECKO:          return TILE_CORPSE_GIANT_GECKO;
  case MONS_GIANT_IGUANA:         return TILE_CORPSE_GIANT_IGUANA;
  case MONS_GIANT_LIZARD:         return TILE_CORPSE_GIANT_LIZARD;
  case MONS_GILA_MONSTER:         return TILE_CORPSE_GILA_MONSTER;
  case MONS_LINDWURM:             return TILE_CORPSE_LINDWURM;
  case MONS_KOMODO_DRAGON:        return TILE_CORPSE_KOMODO_DRAGON;
  case MONS_SWAMP_DRAKE:          return TILE_CORPSE_SWAMP_DRAKE;
  case MONS_FIREDRAKE:            return TILE_CORPSE_FIREDRAKE;
  case MONS_DEATH_DRAKE:          return TILE_CORPSE_DEATH_DRAKE;
  case MONS_MERMAID:              return TILE_CORPSE_MERMAID;
  case MONS_MERFOLK:              return TILE_CORPSE_MERFOLK_FIGHTER;
  
  case MONS_NECROPHAGE:           return TILE_CORPSE_NECROPHAGE;
  case MONS_GHOUL:                return TILE_CORPSE_GHOUL;
  // all orcs
  case MONS_ORC:                  return TILE_CORPSE_ORC;
  
  case MONS_RAT:                  return TILE_CORPSE_RAT;
  case MONS_QUOKKA:               return TILE_CORPSE_QUOKKA;
  case MONS_GREY_RAT:             return TILE_CORPSE_GREY_RAT;
  case MONS_GREEN_RAT:            return TILE_CORPSE_GREEN_RAT;
  case MONS_ORANGE_RAT:           return TILE_CORPSE_ORANGE_RAT;
  case MONS_GIANT_CENTIPEDE:      return TILE_CORPSE_GIANT_CENTIPEDE;
  case MONS_GIANT_MITE:           return TILE_CORPSE_GIANT_MITE;
  case MONS_SCORPION:             return TILE_CORPSE_SCORPION;
  case MONS_WOLF_SPIDER:          return TILE_CORPSE_WOLF_SPIDER;
  case MONS_REDBACK:              return TILE_CORPSE_REDBACK;
  case MONS_MINOTAUR:             return TILE_CORPSE_MINOTAUR;
  
  case MONS_UGLY_THING:           return TILE_CORPSE_UGLY_THING;
  case MONS_VERY_UGLY_THING:      return TILE_CORPSE_VERY_UGLY_THING;
  case MONS_WORM:                 return TILE_CORPSE_WORM;
  case MONS_BRAIN_WORM:           return TILE_CORPSE_BRAIN_WORM;
  case MONS_ANT_LARVA:            return TILE_CORPSE_ANT_LARVA;
  case MONS_SPINY_WORM:           return TILE_CORPSE_SPINY_WORM;
  case MONS_YELLOW_WASP:          return TILE_CORPSE_YELLOW_WASP;
  case MONS_GIANT_MOSQUITO:       return TILE_CORPSE_GIANT_MOSQUITO;
  case MONS_RED_WASP:             return TILE_CORPSE_RED_WASP;
  case MONS_GIANT_BLOWFLY:        return TILE_CORPSE_GIANT_BLOWFLY;
  case MONS_GIANT_BEETLE:         return TILE_CORPSE_GIANT_BEETLE;
  case MONS_BOULDER_BEETLE:       return TILE_CORPSE_BOULDER_BEETLE;
  case MONS_BORING_BEETLE:        return TILE_CORPSE_BORING_BEETLE;
  case MONS_CYCLOPS:              return TILE_CORPSE_CYCLOPS;
  case MONS_STONE_GIANT:          return TILE_CORPSE_STONE_GIANT;
  case MONS_TITAN:                return TILE_CORPSE_TITAN;
  case MONS_HILL_GIANT:           return TILE_CORPSE_HILL_GIANT;
  case MONS_FIRE_GIANT:           return TILE_CORPSE_FIRE_GIANT;
  case MONS_FROST_GIANT:          return TILE_CORPSE_FROST_GIANT;
  case MONS_WYVERN:               return TILE_CORPSE_WYVERN;
  case MONS_DRAGON:               return TILE_CORPSE_DRAGON;
  case MONS_HYDRA:                return TILE_CORPSE_HYDRA;
  case MONS_STEAM_DRAGON:         return TILE_CORPSE_STEAM_DRAGON;
  case MONS_ICE_DRAGON:           return TILE_CORPSE_ICE_DRAGON;
  case MONS_MOTTLED_DRAGON:       return TILE_CORPSE_MOTTLED_DRAGON;
  case MONS_STORM_DRAGON:         return TILE_CORPSE_STORM_DRAGON;
  case MONS_GOLDEN_DRAGON:        return TILE_CORPSE_GOLDEN_DRAGON;
  case MONS_SWAMP_DRAGON:         return TILE_CORPSE_SWAMP_DRAGON;
  case MONS_SHADOW_DRAGON:        return TILE_CORPSE_SHADOW_DRAGON;
  case MONS_GIANT_FROG:           return TILE_CORPSE_GIANT_FROG;
  case MONS_GIANT_BROWN_FROG:     return TILE_CORPSE_GIANT_BROWN_FROG;
  case MONS_SPINY_FROG:           return TILE_CORPSE_SPINY_FROG;
  case MONS_BLINK_FROG:           return TILE_CORPSE_BLINK_FROG;
  case MONS_GIANT_EYEBALL:        return TILE_CORPSE_GIANT_EYEBALL;
  case MONS_EYE_OF_DRAINING:      return TILE_CORPSE_EYE_OF_DRAINING;
  case MONS_GIANT_ORANGE_BRAIN:   return TILE_CORPSE_GIANT_ORANGE_BRAIN;
  case MONS_GREAT_ORB_OF_EYES:    return TILE_CORPSE_GREAT_ORB_OF_EYES;
  case MONS_MANTICORE:            return TILE_CORPSE_MANTICORE;
  case MONS_HIPPOGRIFF:           return TILE_CORPSE_HIPPOGRIFF;
  case MONS_GRIFFON:              return TILE_CORPSE_GRIFFON;
  // all kobolds
  case MONS_KOBOLD:               return TILE_CORPSE_KOBOLD;
  case MONS_GIANT_AMOEBA:         return TILE_CORPSE_GIANT_AMOEBA;
  // all nagas
  case MONS_NAGA:                 return TILE_CORPSE_NAGA;
  
  // including ogre-mage
  case MONS_OGRE:                 return TILE_CORPSE_OGRE;
  case MONS_TWO_HEADED_OGRE:      return TILE_CORPSE_TWO_HEADED_OGRE;
  
  case MONS_QUEEN_BEE:            return TILE_CORPSE_QUEEN_BEE;
  case MONS_QUEEN_ANT:            return TILE_CORPSE_QUEEN_ANT;
  case MONS_SMALL_SNAKE:          return TILE_CORPSE_SMALL_SNAKE;
  case MONS_SNAKE:                return TILE_CORPSE_SNAKE;
  case MONS_BLACK_SNAKE:          return TILE_CORPSE_BLACK_SNAKE;
  case MONS_BROWN_SNAKE:          return TILE_CORPSE_BROWN_SNAKE;
  case MONS_YELLOW_SNAKE:         return TILE_CORPSE_YELLOW_SNAKE;
  case MONS_GREY_SNAKE:           return TILE_CORPSE_GREY_SNAKE;
  case MONS_TROLL:                return TILE_CORPSE_TROLL;
  case MONS_ROCK_TROLL:           return TILE_CORPSE_ROCK_TROLL;
  case MONS_IRON_TROLL:           return TILE_CORPSE_IRON_TROLL;
  case MONS_DEEP_TROLL:           return TILE_CORPSE_DEEP_TROLL;
  case MONS_BEAR:                 return TILE_CORPSE_BEAR;
  case MONS_GRIZZLY_BEAR:         return TILE_CORPSE_GRIZZLY_BEAR;
  case MONS_POLAR_BEAR:           return TILE_CORPSE_POLAR_BEAR;
  case MONS_BLACK_BEAR:           return TILE_CORPSE_BLACK_BEAR;
  case MONS_SHEEP:                return TILE_CORPSE_SHEEP;
  case MONS_YAK:                  return TILE_CORPSE_YAK;
  case MONS_DEATH_YAK:            return TILE_CORPSE_DEATH_YAK;

  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_GLOWING_SHAPESHIFTER: return TILE_CORPSE_GLOWING_SHAPESHIFTER; 
  case MONS_SHAPESHIFTER:         return TILE_CORPSE_SHAPESHIFTER;

  case MONS_DEATH_DRAKE: ch=TILE_CORPSE_DEATH_DRAKE; break;
  case MONS_MERMAID: ch=TILE_CORPSE_MERMAID; break;
  case MONS_MERFOLK: ch=TILE_CORPSE_MERFOLK_FIGHTER; break;

  // all humans
  case MONS_HUMAN:                return TILE_CORPSE_HUMAN;

  return ch;

  
  return TILE_ERROR;

int tileidx_misc(const item_def &item)

static int _tileidx_misc(const item_def &item)

    int ch;

        ch = TILE_MISC_BOTTLED_EFREET;
        break;

        return TILE_MISC_BOTTLED_EFREET;

        ch = TILE_MISC_CRYSTAL_BALL_OF_SEEING;
        break;

        return TILE_MISC_CRYSTAL_BALL_OF_SEEING;

        ch = TILE_MISC_AIR_ELEMENTAL_FAN;
        break;

        return TILE_MISC_AIR_ELEMENTAL_FAN;

        ch = TILE_MISC_LAMP_OF_FIRE;
        break;

        return TILE_MISC_LAMP_OF_FIRE;

        ch = TILE_MISC_STONE_OF_EARTH_ELEMENTALS;
        break;

        return TILE_MISC_STONE_OF_EARTH_ELEMENTALS;

        ch = TILE_MISC_LANTERN_OF_SHADOWS;
        break;

        return TILE_MISC_LANTERN_OF_SHADOWS;

        ch = TILE_MISC_HORN_OF_GERYON;
        break;

        return TILE_MISC_HORN_OF_GERYON;

        ch = TILE_MISC_BOX_OF_BEASTS;
        break;

        return TILE_MISC_BOX_OF_BEASTS;

        ch = TILE_MISC_CRYSTAL_BALL_OF_ENERGY;
        break;

        return TILE_MISC_CRYSTAL_BALL_OF_ENERGY;

        ch = TILE_MISC_EMPTY_EBONY_CASKET;
        break;

        return TILE_MISC_EMPTY_EBONY_CASKET;

        ch = TILE_MISC_CRYSTAL_BALL_OF_FIXATION;
        break;

        return TILE_MISC_CRYSTAL_BALL_OF_FIXATION;

        ch = TILE_MISC_DISC_OF_STORMS;
        break;

        return TILE_MISC_DISC_OF_STORMS;

    {
        int ch = TILE_ERROR;

        break;

        return ch;
    }

        ch = TILE_MISC_RUNE_OF_ZOT;
        break;
    default:
        ch = TILE_ERROR;
        break;

        return TILE_MISC_RUNE_OF_ZOT;

    return ch;

    
    return TILE_ERROR;

    int clas=item.base_type;
    int type=item.sub_type;
    int special=item.special;
    int color=item.colour;

    int clas    = item.base_type;
    int type    = item.sub_type;
    int special = item.special;
    int color   = item.colour;

            return tileidx_fixed_artifact(special); 

            return _tileidx_fixed_artefact(special);

            return tileidx_unrand_artifact(find_unrandart_index(item));

            return _tileidx_unrand_artefact(find_unrandart_index(item));

            return tileidx_weapon(item);

            return _tileidx_weapon(item);

        return tileidx_missile(item);

        return _tileidx_missile(item);

            return tileidx_unrand_artifact(find_unrandart_index(item));

            return _tileidx_unrand_artefact(find_unrandart_index(item));

            return tileidx_armour(item);

            return _tileidx_armour(item);

             return TILE_WAND_FLAME + type;

        {
            return TILE_WAND_FLAME + type;
        }

             return TILE_WAND_OFFSET + special % 12;

            return TILE_WAND_OFFSET + special % 12;

        return tileidx_food(item);

        return _tileidx_food(item);

             return TILE_SCR_IDENTIFY + type;

        {
            return TILE_SCR_IDENTIFY + type;
        }

                return tileidx_unrand_artifact(find_unrandart_index(item));

                return _tileidx_unrand_artefact(find_unrandart_index(item));

        if(type<2)

        if (type < 2)

        if(type==2)

        if (type == 2)

        if(type==3)

        if (type == 3)

        if(type==4)

        if (type == 4)

            return tileidx_corpse(item.plus);

            return _tileidx_corpse(item.plus);

        return tileidx_misc(item);

        return _tileidx_misc(item);

    else if (dx>0)
        return (dy>0) ? 3 : 1;

    else if (dx > 0)
        return (dy > 0) ? 3 : 1;

        return (dy>0) ? 5: 7;

        return (dy > 0) ? 5: 7;

int tileidx_cloud(int type, int decay){

static int _tileidx_cloud(int type, int decay)
{

    if (dur>2) dur = 2;

    if (dur > 2)
        dur = 2;

int tileidx_player(int job){

int tileidx_player(int job)
{

        case 's': ch = TILE_MONS_WOLF_SPIDER;break;
        case 'I': ch = TILE_MONS_ICE_BEAST;break;
        case '8': ch = TILE_MONS_STONE_GOLEM;break;
        case 'D': ch = TILE_MONS_DRAGON;break;
        case 'L': ch = TILE_MONS_LICH;break;
        case '#': ch = TILE_MONS_VAPOUR;break;
        case 'S': ch = TILE_MONS_LAVA_SNAKE;break;
        case 'b': ch = TILE_MONS_GIANT_BAT;break;

        case 's': ch = 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 (ch<32) ch=32;

    if (ch < 32)
        ch = 32;

    if ( (ch>='@' && ch<='Z') || (ch>='a' && ch<='z') || ch=='&'
        || (ch>='1' && ch<='5') || ch == ';')

    if (ch >= '@' && ch <= 'Z' || ch >= 'a' && ch <= 'z'
        || ch == '&' || ch >= '1' && ch <= '5' || ch == ';')

void finalize_tile(unsigned int *tile, bool is_special,
    char wall_flv, char floor_flv, char special_flv)

static void _finalize_tile(unsigned int *tile, bool is_special,
                           char wall_flv, char floor_flv, char special_flv)

    if (parts[TILEP_PART_HELM]-1 >= TILEP_HELM_HELM_OFS)

    if (parts[TILEP_PART_HELM] - 1 >= TILEP_HELM_HELM_OFS)

    if (parts[TILEP_PART_HELM]-1 >= TILEP_HELM_FHELM_OFS)

    if (parts[TILEP_PART_HELM] - 1 >= TILEP_HELM_FHELM_OFS)

            hair = TILEP_HAIR_ELF_YELLOW;

            hair   = TILEP_HAIR_ELF_YELLOW;

            hair = TILEP_HAIR_ELF_WHITE;

            hair   = TILEP_HAIR_ELF_WHITE;

            if(gender==TILEP_GENDER_MALE)

            if (gender == TILEP_GENDER_MALE)

                hair = TILEP_HAIR_SHORT_RED;

                hair  = TILEP_HAIR_SHORT_RED;

                hair = TILEP_HAIR_LONG_RED;

                hair  = TILEP_HAIR_LONG_RED;

            hair = 0;

            hair   = 0;

            hair = 0;

            hair   = 0;

            hair = 0;

            hair   = 0;

            hair = 0;

            hair   = 0;

            {

            }

            hair = 0;

            hair   = 0;

            hair = 0;

            hair   = 0;

            hair = 0;

            hair   = 0;

            result = player_in_water() ? 
                TILEP_BASE_MERFOLK_WATER :
                TILEP_BASE_MERFOLK;

            result = player_in_water() ? TILEP_BASE_MERFOLK_WATER
                                       : TILEP_BASE_MERFOLK;

            if (gender==TILEP_GENDER_MALE)

            if (gender == TILEP_GENDER_MALE)

    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;

    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;

    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;

    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;

            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;

            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;

            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;

            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;

            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;

            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;

            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;

            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;

            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;

            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;

            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;

            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;

            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_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_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_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_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_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_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_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_BODY]= TILEP_BODY_GANDALF_G;
            parts[TILEP_PART_HAND1]= TILEP_HAND1_GANDALF;
            parts[TILEP_PART_HAND2]= TILEP_HAND2_BOOK_CYAN_DIM;

            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_HELM] = TILEP_HELM_GANDALF;

            parts[TILEP_PART_HELM]  = TILEP_HELM_GANDALF;

            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_BODY]  = TILEP_BODY_ROBE_WHITE;
            parts[TILEP_PART_ARM]   = TILEP_ARM_GLOVE_WHITE;
            parts[TILEP_PART_HAND1] = TILEP_SHOW_EQUIP;

            parts[TILEP_PART_BODY]= TILEP_BODY_ROBE_WHITE;
            parts[TILEP_PART_ARM] = TILEP_ARM_GLOVE_WHITE;
            parts[TILEP_PART_HAND1]= 38;

            parts[TILEP_PART_BODY]  = TILEP_BODY_ROBE_WHITE;
            parts[TILEP_PART_ARM]   = TILEP_ARM_GLOVE_WHITE;
            parts[TILEP_PART_HAND1] = 38;

            parts[TILEP_PART_HELM] = TILEP_HELM_FHELM_HEALER;

            parts[TILEP_PART_HELM]  = TILEP_HELM_FHELM_HEALER;