#include "tiles.h"

    void get_texcoord(int idx, float &x, float &y, float &wx, float &wy);

    TilesTexture();

    void get_texcoord_doll(int part, int idx, int ymax, float &x, float &y, float &wx, float &wy, int &wx_pix, int &wy_pix, int &ox, int &oy);

    void set_info(int max, tile_info *info);
    inline const tile_info &get_info(int idx);
    inline void get_coords(int idx, int ofs_x, int ofs_y,
                           float &pos_sx, float &pos_sy,
                           float &pos_ex, float &pos_ey,
                           float &tex_sx, float &tex_sy,
                           float &tex_ex, float &tex_ey,
                           bool centre = true, int ymax = -1);
protected:
    int m_tile_max;
    tile_info *m_tile_info;

inline const tile_info &TilesTexture::get_info(int idx)
{
    assert(idx < m_tile_max);
    return m_tile_info[idx];
}

inline void TilesTexture::get_coords(int idx, int ofs_x, int ofs_y,
                                     float &pos_sx, float &pos_sy,
                                     float &pos_ex, float &pos_ey,
                                     float &tex_sx, float &tex_sy,
                                     float &tex_ex, float &tex_ey,
                                     bool centre, int ymax)
{
    const tile_info &inf = get_info(idx);
    float fwidth = m_width;
    float fheight = m_height;
    // center tiles on x, but allow taller tiles to extend upwards
    int size_ox = centre ? TILE_X / 2 - inf.width / 2 : 0;
    int size_oy = centre ? TILE_Y - inf.height : 0;
    
    int ey = inf.ey;
    if (ymax > 0)
        ey = std::min(inf.sy + ymax - inf.offset_y, ey);
    pos_sx += (ofs_x + inf.offset_x + size_ox) / (float)TILE_X;
    pos_sy += (ofs_y + inf.offset_y + size_oy) / (float)TILE_Y;
    pos_ex = pos_sx + (inf.ex - inf.sx) / (float)TILE_X;
    pos_ey = pos_sy + (ey - inf.sy) / (float)TILE_Y;
    tex_sx = inf.sx / fwidth;
    tex_sy = inf.sy / fheight;
    tex_ex = inf.ex / fwidth;
    tex_ey = ey / fheight;
}

    int new_width = img->w;
    int new_height = img->h;

    int new_width = 1;
    while (new_width < img->w)
        new_width *= 2;
    int new_height = 1;
    while (new_height < img->h)
        new_height *= 2;

        if (img->format->Rmask == 0x000000ff)
            texture_format = GL_RGBA;
        else
            texture_format = GL_BGRA;

        if (new_width != img->w || new_height != img->h)
        {
            SDL_LockSurface(img);
            pixels = new unsigned char[4 * new_width * new_height];
            memset(pixels, 0, 4 * new_width * new_height);
            int dest = 0;
            for (int y = 0; y < img->h; y++)
            {
                for (int x = 0; x < img->w; x++)
                {
                    unsigned char *p = ((unsigned char*)img->pixels
                                      + y * img->pitch + x * bpp);
                    unsigned int pixel = *(unsigned int*)p;
                    SDL_GetRGBA(pixel, img->format, &pixels[dest],
                                &pixels[dest+1], &pixels[dest+2],
                                &pixels[dest+3]);
                    dest += 4;
                }
                dest += 4 * (new_width - img->w);
            }
            SDL_UnlockSurface(img);
        }
        texture_format = GL_RGBA;

        if (img->format->Rmask == 0x000000ff)
            texture_format = GL_RGB;
        else
            texture_format = GL_BGR;

        if (new_width != img->w || new_height != img->h)
        {
            SDL_LockSurface(img);
            pixels = new unsigned char[4 * new_width * new_height];
            memset(pixels, 0, 4 * new_width * new_height);
            int dest = 0;
            for (int y = 0; y < img->h; y++)
            {
                for (int x = 0; x < img->w; x++)
                {
                    unsigned char *p = ((unsigned char*)img->pixels
                                       + y * img->pitch + x * bpp);
                    unsigned int pixel;
                    if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
                        pixel = p[0] << 16 | p[1] << 8 | p[2];
                    else
                        pixel = p[0] | p[1] << 8 | p[2];
                    SDL_GetRGBA(pixel, img->format, &pixels[dest],
                                &pixels[dest+1], &pixels[dest+2],
                                &pixels[dest+3]);
                    dest += 4;
                }
                dest += 4 * (new_width - img->w);
            }
            SDL_UnlockSurface(img);
        }
        texture_format = GL_RGBA;

        // Prefer power-of-two textures to avoid texture bleeding from
        // floating point error.
        // TODO enne - convert non-palettized to power-of-2 as well?
        new_width = 1;
        while (new_width < img->w)
            new_width *= 2;
        new_height = 1;
        while (new_height < img->h)
            new_height *= 2;

        // Find transparent colour
        // TODO enne - this should probably be removed from rltiles
        // TODO enne - is there more than one transparent color??
        int trans_index = -1;
        for (int p = 0; p < pal->ncolors ; p++)
        {
            if (pal->colors[p].r == 71 &&
                pal->colors[p].g == 108 &&
                pal->colors[p].b == 108)
            {
                trans_index = p;
                break;
            }
        }

                pixels[dest*4 + 3] = (index == trans_index) ? 0 : 255;

                pixels[dest*4 + 3] = 255;

void TilesTexture::get_texcoord_doll(int part, int idx, int ymax, float &x, float &y, float &wx, float &wy, int &wx_pix, int &wy_pix, int &ox, int &oy)

TilesTexture::TilesTexture() :
    GenericTexture(), m_tile_max(0), m_tile_info(NULL)

    int tile_idx = tilep_parts_start[part];
    int nx = tilep_parts_nx[part];
    int ny = tilep_parts_ny[part];
    ox = tilep_parts_ox[part];
    oy = tilep_parts_oy[part];
    wx_pix = TILE_X / nx;
    wy_pix = TILE_Y / ny;

    if (!idx)
    {
        wy = -1;
        return;
    }
    idx--;
    tile_idx += idx / (nx * ny);
    if (oy + wy_pix > ymax)
        wy_pix -= oy + wy_pix - ymax;
    int xs = (tile_idx % TILEP_PER_ROW) * TILE_X;
    int ys = (tile_idx / TILEP_PER_ROW) * TILE_Y;
    xs += (idx % nx) * TILE_X / nx;
    ys += ((idx / nx) % ny) * TILE_Y / ny;
    x = xs / (float)m_width;
    y = ys / (float)m_height;
    wx = wx_pix / (float)m_width;
    wy = wy_pix / (float)m_height;

void TilesTexture::get_texcoord(int idx, float &x, float &y, 
                                float &wx, float &wy)

void TilesTexture::set_info(int _max, tile_info *_info)

    const unsigned int tile_size = 32;
    unsigned int tiles_per_row = m_width / tile_size;
    wx = tile_size / (float)m_width;
    wy = tile_size / (float)m_height;
    unsigned int row = idx / tiles_per_row;
    unsigned int col = idx % tiles_per_row;
    x = tile_size * col / (float)m_width;
    y = tile_size * row / (float)m_height;
    ASSERT(row >= 0);
    ASSERT(col >= 0);
    ASSERT(x + wx <= m_width);
    ASSERT(y + wy <= m_height);

    m_tile_max = _max;
    m_tile_info = _info;

#include "tiledef.h"

#include "tiledef-main.h"
#include "tiledef-demon.h"
#include "tiledef-dngn.h"
#include "tiledef-player.h"

#include "tiledef-p.h"

    int parts[TILEP_PARTS_TOTAL];

    int parts[TILEP_PART_MAX];

// Dungeon view window size
#define TILE_DAT_XMAX 35
#define TILE_DAT_YMAX 35

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

    void add_quad(TextureID tex, unsigned int idx, unsigned int x, unsigned int y, int ofs_x = 0, int ofs_y = 0);

    void add_quad(TextureID tex, unsigned int idx, unsigned int x, unsigned int y, int ofs_x = 0, int ofs_y = 0, bool centre = true, int ymax = -1);

    void add_quad_doll(unsigned int part, unsigned int idx, int ymax, unsigned int x, unsigned int y, int ox, int oy);

#include "tiledef-dngn.h"

}
void DungeonRegion::add_quad_doll(unsigned int part, unsigned int idx, int ymax, unsigned int x, unsigned int y, int ox_spec, int oy_spec)
{
    float tex_sx, tex_sy, tex_wx, tex_wy; 
    int ox_extra, oy_extra, wx_pix, wy_pix;
    m_image->m_textures[TEX_DOLL].get_texcoord_doll(part, idx, ymax, tex_sx, tex_sy, tex_wx, tex_wy, wx_pix, wy_pix, ox_extra, oy_extra);
    if (wx_pix <= 0 || wy_pix <= 0)
        return;
    float pos_ox = (ox_spec + ox_extra) / (float)TILE_X;
    float pos_oy = (oy_spec + oy_extra) / (float)TILE_Y;
    float tex_ex = tex_sx + tex_wx;
    float tex_ey = tex_sy + tex_wy;
    float pos_sx = x + pos_ox;
    float pos_sy = y + pos_oy;
    float pos_ex = pos_sx + wx_pix / (float)TILE_X;
    float pos_ey = pos_sy + wy_pix / (float)TILE_Y;
    tile_vert v;
    v.pos_x = pos_sx;
    v.pos_y = pos_sy;
    v.tex_x = tex_sx;
    v.tex_y = tex_sy;
    m_verts.push_back(v);
    v.pos_y = pos_ey;
    v.tex_y = tex_ey;
    m_verts.push_back(v);
    v.pos_x = pos_ex;
    v.tex_x = tex_ex;
    m_verts.push_back(v);
    v.pos_y = pos_sy;
    v.tex_y = tex_sy;
    m_verts.push_back(v);

void TileRegion::add_quad(TextureID tex, unsigned int idx, unsigned int x, unsigned int y, int ofs_x, int ofs_y)

void TileRegion::add_quad(TextureID tex, unsigned int idx, unsigned int x, unsigned int y, int ofs_x, int ofs_y, bool centre, int ymax)

    float tex_sx, tex_sy, tex_wx, tex_wy;
    m_image->m_textures[tex].get_texcoord(idx, tex_sx, tex_sy, tex_wx, tex_wy);
    float tex_ex = tex_sx + tex_wx;
    float tex_ey = tex_sy + tex_wy;
    float pos_sx = x + ofs_x / (float)TILE_X;
    float pos_sy = y + ofs_y / (float)TILE_Y;
    float pos_ex = pos_sx + 1;
    float pos_ey = pos_sy + 1;

    float pos_sx = x;
    float pos_sy = y;
    float pos_ex, pos_ey, tex_sx, tex_sy, tex_ex, tex_ey; 
    m_image->m_textures[tex].get_coords(idx, ofs_x, ofs_y,
                                        pos_sx, pos_sy, pos_ex, pos_ey,
                                        tex_sx, tex_sy, tex_ex, tex_ey,
                                        centre, ymax);

    // TODO enne - handle wx/wy non-standard sizes

        unsigned int offset = flv.special % tile_DNGN_count[IDX_BLOOD];

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

    for (int i = 0; i < TILEP_PARTS_TOTAL; i++)
        player_doll.parts[i] = TILEP_SHOW_EQUIP;

    for (int i = 0; i < TILEP_PART_MAX; i++)
        default_doll.parts[i] = TILEP_SHOW_EQUIP;

    result = player_doll;

    result = default_doll;

    if (result.parts[TILEP_PART_LEG] == TILEP_SHOW_EQUIP)
        result.parts[TILEP_PART_LEG] = 0;
    if (result.parts[TILEP_PART_DRCWING] == TILEP_SHOW_EQUIP)
        result.parts[TILEP_PART_DRCWING] = 0;
    if (result.parts[TILEP_PART_DRCHEAD] == TILEP_SHOW_EQUIP)
        result.parts[TILEP_PART_DRCHEAD] = 0;

    int p_order[TILEP_PARTS_TOTAL] =

    int p_order[TILEP_PART_MAX] =

    int flags[TILEP_PARTS_TOTAL];

    int flags[TILEP_PART_MAX];

    for (int i = 0; i < TILEP_PARTS_TOTAL; i++)

    for (int i = 0; i < TILEP_PART_MAX; i++)

        if (doll.parts[p] && p == TILEP_PART_BOOTS
            && (doll.parts[p] == TILEP_BOOTS_NAGA_BARDING
                || doll.parts[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 = (doll.parts[p] == TILEP_BOOTS_NAGA_BARDING) ?
                            TILEP_SHADOW_NAGA_BARDING :
                            TILEP_SHADOW_CENTAUR_BARDING;
            add_quad_doll(TILEP_PART_SHADOW, tile, TILE_Y, x, y, 0, 0);
        }
        else
        {
            add_quad_doll(p, doll.parts[p], ymax, x, y, 0, 0);
        }

        add_quad(TEX_DOLL, doll.parts[p], x, y, 0, 0, true, ymax);

    for (int i = 0; i < TILEP_PARTS_TOTAL; i++)

    for (int i = 0; i < TILEP_PART_MAX; i++)

        add_quad_doll(TILEP_PART_HAND1, equ_tile, TILE_Y, x, y, ofs_x, ofs_y);

        add_quad(TEX_DOLL, equ_tile, x, y, ofs_x, ofs_y, true, TILE_Y);

            add_quad_doll(TILEP_PART_HAND2, eq2, TILE_Y, x, y, -ofs_x, ofs_y);

            add_quad(TEX_DOLL, eq2, x, y, -ofs_x, ofs_y, true, TILE_Y);

    ASSERT(m_verts.size() > 0);

    int idx = TILE_CHAR00 + (c - 32) / 8;
    int subidx = c & 7;
    float tex_sx, tex_sy, tex_wx, tex_wy;
    m_image->m_textures[TEX_DEFAULT].get_texcoord(idx, tex_sx, tex_sy, tex_wx, tex_wy);
    tex_wx /= 4.0f;
    tex_wy /= 2.0f;
    tex_sx += (subidx % 4) * tex_wx;
    tex_sy += (subidx / 4) * tex_wy;
    float tex_ex = tex_sx + tex_wx;
    float tex_ey = tex_sy + tex_wy;
    float pos_sx = x + ofs_x / (float)TILE_X;
    float pos_sy = y + ofs_y / (float)TILE_Y;
    float pos_ex = pos_sx + 0.25f;
    float pos_ey = pos_sy + 0.5f;
    tile_vert v;
    v.pos_x = pos_sx;
    v.pos_y = pos_sy;
    v.tex_x = tex_sx;
    v.tex_y = tex_sy;
    m_verts.push_back(v);
    v.pos_y = pos_ey;
    v.tex_y = tex_ey;
    m_verts.push_back(v);

    int num = c - '0';
    assert(num >=0 && num <= 9);
    int idx = TILE_NUM0 + num;

    v.pos_x = pos_ex;
    v.tex_x = tex_ex;
    m_verts.push_back(v);
    v.pos_y = pos_sy;
    v.tex_y = tex_sy;
    m_verts.push_back(v);

    add_quad(TEX_DEFAULT, idx, x, y, ofs_x, ofs_y, false);

    m_textures[TEX_DUNGEON].set_info(TILE_DNGN_MAX, &tile_dngn_info[0]);
    m_textures[TEX_DOLL].set_info(TILEP_PLAYER_MAX, &tile_player_info[0]);

                       int idx, bool blend)

                       const tile_info &inf, bool blend)

    const unsigned int tile_size = 32;
    const unsigned int tiles_per_row = width / tile_size;
    unsigned int row = idx / tiles_per_row;
    unsigned int col = idx % tiles_per_row;
    unsigned char *dest = &pixels[4 * 32 * (row * width + col)];

    unsigned char *dest = &pixels[4 * (inf.sy * width + inf.sx)];

    size_t src_row_size = 32 * 4;

    size_t src_row_size = inf.width * 4;

        for (unsigned int r = 0; r < 32; r++)

        for (unsigned int r = 0; r < inf.height; r++)

            for (unsigned int c = 0; c < 32; c++)

            for (unsigned int c = 0; c < inf.width; c++)

        for (unsigned int r = 0; r < 32; r++)

        for (unsigned int r = 0; r < inf.height; r++)

// Copy a 32x32 image at index idx from pixels into dest.

// Copy an image at inf from pixels into dest.

                       unsigned int height, int idx)

                       unsigned int height, const tile_info &inf)

    const unsigned int tile_size = 32;
    const unsigned int tiles_per_row = width / tile_size;

    unsigned char *src = &pixels[4 * (inf.sy * width + inf.sx)];

    unsigned int row = idx / tiles_per_row;
    unsigned int col = idx % tiles_per_row;

    size_t src_row_size = width * 4;
    size_t dest_row_size = inf.width * 4;

    unsigned char *src = &pixels[4 * 32 * (row * width + col)];

    memset(dest, 0, 4 * inf.width * inf.height);

    size_t src_row_size = width * 4;
    size_t dest_row_size = 32 * 4;

    dest += inf.offset_x * 4 + inf.offset_y * dest_row_size;

    for (unsigned int r = 0; r < 32; r++)

    int src_height = inf.ey - inf.sy;
    int src_width = inf.ex - inf.sx;
    for (int r = 0; r < src_height; r++)

        memcpy(dest, src, dest_row_size);

        memcpy(dest, src, src_width * 4);

static void _copy_under(unsigned char *pixels, unsigned int width,

static bool _copy_under(unsigned char *pixels, unsigned int width,

    size_t image_size = 32 * 32 * 4;    

    const tile_info &under = tile_main_info[idx_under];
    const tile_info &over = tile_main_info[idx_over];
    if (over.width != under.width || over.height != under.height)
        return false;
    if (over.ex - over.sx != over.width || over.ey - over.sy != over.height)
        return false;
    if (over.offset_x != 0 || over.offset_y != 0)
        return false;
    size_t image_size = under.width * under.height * 4;

    unsigned char *under = new unsigned char[image_size];
    _copy_into(under, pixels, width, height, idx_under);
    unsigned char *over = new unsigned char[image_size];
    _copy_into(over, pixels, width, height, idx_over);

    unsigned char *under_pixels = new unsigned char[image_size];
    _copy_into(under_pixels, pixels, width, height, under);
    unsigned char *over_pixels = new unsigned char[image_size];
    _copy_into(over_pixels, pixels, width, height, over);

    _copy_onto(pixels, width, height, under, idx_over, false);

    _copy_onto(pixels, width, height, under_pixels, over, false);

    _copy_onto(pixels, width, height, over, idx_over, true);

    _copy_onto(pixels, width, height, over_pixels, over, true);

    delete[] under;
    delete[] over;

    delete[] under_pixels;
    delete[] over_pixels;
    return true;

    bool success = true;

        _copy_under(pixels, width, height, tile0, tile1);

        success &= _copy_under(pixels, width, height, tile0, tile1);

        _copy_under(pixels, width, height, tile0, tile1);

        success &= _copy_under(pixels, width, height, tile0, tile1);

        _copy_under(pixels, width, height, tile0, tile1);

        success &= _copy_under(pixels, width, height, tile0, tile1);

        _copy_under(pixels, width, height, tile0, tile1);
    }
   
    // TODO enne - fix rtiles so that it can accept PNGs.
    {
        size_t image_size = 32 * 32 * 4;    
        unsigned char *mesh = new unsigned char[image_size];
        for (unsigned int i = 0; i < image_size; i += 4)
        {
            mesh[i] = mesh[i+1] = mesh[i+2] = 0;
            mesh[i+3] = 110;
        }
        _copy_onto(pixels, width, height, mesh, TILE_MESH, false);
        for (unsigned int i = 0; i < image_size; i += 4)
        {
            mesh[i] = 70;
            mesh[i+1] = 70;
            mesh[i+2] = 180;
            mesh[i+3] = 120;
        }
        _copy_onto(pixels, width, height, mesh, TILE_MAGIC_MAP_MESH, false);
        delete[] mesh;

        success &= _copy_under(pixels, width, height, tile0, tile1);

    return m_textures[TEX_DEFAULT].load_texture("tile.png", mip, 
                                                &_process_item_image);

    bool success = m_textures[TEX_DEFAULT].load_texture("main.png", mip, 
                                                        &_process_item_image);
    m_textures[TEX_DEFAULT].set_info(TILE_MAIN_MAX, &tile_main_info[0]);
    return success;

       return TILE_DNGN_TRANSIT_PANDEMONIUM;

       return TILE_DNGN_PORTAL;

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

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

        // These types always have four flavors...
        (*tile) = orig + (special_flv % 4);

        (*tile) = orig + (special_flv % tile_dngn_count[orig]);

    for (i = 0; i < TILEP_PARTS_TOTAL; i++)

    for (i = 0; i < TILEP_PART_MAX; i++)

         else if (idx < 0) // no negative value

         else if (idx < 0)

         else if (idx > tilep_parts_total[p]) // bound it
             parts[p] = tilep_parts_total[p];

         // TODO enne - is this right? did the old count end at idx not just subtotal?
         else if (idx > tile_player_part_count[p])
             parts[p] = tile_player_part_count[p];

    for (i = 0; i < TILEP_PARTS_TOTAL; i++)

    for (i = 0; i < TILEP_PART_MAX; i++)

#include "tilecount-dngn.h"

            wall  = IDX_WALL_ZOT_BLUE;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_BLUE;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_RED;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_RED;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_MAGENTA;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_MAGENTA;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_GREEN;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_GREEN;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_CYAN;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_CYAN;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_YELLOW;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_YELLOW;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_GRAY;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_GRAY;
            floor = TILE_FLOOR_TOMB;

            wall = IDX_WALL_FLESH;

            wall = TILE_WALL_FLESH;

            floor = IDX_FLOOR_NERVES;

            floor = TILE_FLOOR_NERVES;

            wall = IDX_WALL_HIVE;

            wall = TILE_WALL_HIVE;

            wall = IDX_WALL_PEBBLE_RED;

            wall = TILE_WALL_PEBBLE_RED;

            wall = IDX_WALL_SLIME;

            wall = TILE_WALL_SLIME;

            wall = IDX_WALL_ICE;

            wall = TILE_WALL_ICE;

            wall = IDX_WALL_HALL;

            wall = TILE_WALL_HALL;

            wall = IDX_WALL_UNDEAD;

            wall = TILE_WALL_UNDEAD;

        floor = IDX_FLOOR_NERVES;

        floor = TILE_FLOOR_NERVES;

        wall  = IDX_WALL_UNDEAD;
        floor = IDX_FLOOR_TOMB;

        wall  = TILE_WALL_UNDEAD;
        floor = TILE_FLOOR_TOMB;

                    wall    = IDX_WALL_BAZAAR_GRAY;
                    floor   = IDX_FLOOR_BAZAAR_GRASS;
                    special = IDX_FLOOR_BAZAAR_GRASS1_SPECIAL;

                    wall    = TILE_WALL_BAZAAR_GRAY;
                    floor   = TILE_FLOOR_BAZAAR_GRASS;
                    special = TILE_FLOOR_BAZAAR_GRASS1_SPECIAL;

                    wall    = IDX_WALL_PEBBLE_RED;
                    floor   = IDX_FLOOR_VAULT;
                    special = IDX_FLOOR_BAZAAR_VAULT_SPECIAL;

                    wall    = TILE_WALL_PEBBLE_RED;
                    floor   = TILE_FLOOR_VAULT;
                    special = TILE_FLOOR_BAZAAR_VAULT_SPECIAL;

                    wall    = IDX_WALL_HIVE;
                    floor   = IDX_FLOOR_BAZAAR_GRASS;
                    special = IDX_FLOOR_BAZAAR_GRASS2_SPECIAL;

                    wall    = TILE_WALL_HIVE;
                    floor   = TILE_FLOOR_BAZAAR_GRASS;
                    special = TILE_FLOOR_BAZAAR_GRASS2_SPECIAL;

                    wall    = IDX_WALL_BAZAAR_STONE;
                    floor   = IDX_FLOOR_BAZAAR_GRASS;
                    special = IDX_FLOOR_BAZAAR_GRASS1_SPECIAL;

                    wall    = TILE_WALL_BAZAAR_STONE;
                    floor   = TILE_FLOOR_BAZAAR_GRASS;
                    special = TILE_FLOOR_BAZAAR_GRASS1_SPECIAL;

                    wall    = IDX_WALL_BAZAAR_STONE;
                    floor   = IDX_FLOOR_BAZAAR_DIRT;
                    special = IDX_FLOOR_BAZAAR_DIRT_SPECIAL;

                    wall    = TILE_WALL_BAZAAR_STONE;
                    floor   = TILE_FLOOR_BAZAAR_DIRT;
                    special = TILE_FLOOR_BAZAAR_DIRT_SPECIAL;

                    wall    = IDX_WALL_VAULT;
                    floor   = IDX_FLOOR_VAULT;
                    special = IDX_FLOOR_BAZAAR_VAULT_SPECIAL;

                    wall    = TILE_WALL_VAULT;
                    floor   = TILE_FLOOR_VAULT;
                    special = TILE_FLOOR_BAZAAR_VAULT_SPECIAL;

            wall  = IDX_WALL_NORMAL;
            floor = IDX_FLOOR_NORMAL;

            wall  = TILE_WALL_NORMAL;
            floor = TILE_FLOOR_NORMAL;

            wall  = IDX_WALL_HIVE;
            floor = IDX_FLOOR_HIVE;

            wall  = TILE_WALL_HIVE;
            floor = TILE_FLOOR_HIVE;

            wall  = IDX_WALL_VAULT;
            floor = IDX_FLOOR_VAULT;

            wall  = TILE_WALL_VAULT;
            floor = TILE_FLOOR_VAULT;

            wall  = IDX_WALL_VINES;
            floor = IDX_FLOOR_VINES;

            wall  = TILE_WALL_VINES;
            floor = TILE_FLOOR_VINES;

            wall  = IDX_WALL_HALL;
            floor = IDX_FLOOR_HALL;

            wall  = TILE_WALL_HALL;
            floor = TILE_FLOOR_HALL;

            wall  = IDX_WALL_UNDEAD;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_UNDEAD;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_TOMB;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_TOMB;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_CYAN;
            floor = IDX_FLOOR_TOMB;

            wall  = TILE_WALL_ZOT_CYAN;
            floor = TILE_FLOOR_TOMB;

            wall  = IDX_WALL_ZOT_RED;
            floor = IDX_FLOOR_ROUGH_RED;

            wall  = TILE_WALL_ZOT_RED;
            floor = TILE_FLOOR_ROUGH_RED;

            wall  = IDX_WALL_ICE;
            floor = IDX_FLOOR_ICE;

            wall  = TILE_WALL_ICE;
            floor = TILE_FLOOR_ICE;

            wall  = IDX_WALL_ORC;
            floor = IDX_FLOOR_ORC;

            wall  = TILE_WALL_ORC;
            floor = TILE_FLOOR_ORC;

            wall  = IDX_WALL_LAIR;
            floor = IDX_FLOOR_LAIR;

            wall  = TILE_WALL_LAIR;
            floor = TILE_FLOOR_LAIR;

            wall  = IDX_WALL_SLIME;
            floor = IDX_FLOOR_SLIME;

            wall  = TILE_WALL_SLIME;
            floor = TILE_FLOOR_SLIME;

            wall  = IDX_WALL_SNAKE;
            floor = IDX_FLOOR_SNAKE;

            wall  = TILE_WALL_SNAKE;
            floor = TILE_FLOOR_SNAKE;

            wall  = IDX_WALL_SWAMP;
            floor = IDX_FLOOR_SWAMP;

            wall  = TILE_WALL_SWAMP;
            floor = TILE_FLOOR_SWAMP;

                wall = IDX_WALL_VINES;

                wall = TILE_WALL_VINES;

                wall = IDX_WALL_YELLOW_ROCK;

                wall = TILE_WALL_YELLOW_ROCK;

            floor = IDX_FLOOR_SAND_STONE;

            floor = TILE_FLOOR_SAND_STONE;

                wall  = IDX_WALL_ZOT_YELLOW;
                floor = IDX_FLOOR_TOMB;

                wall  = TILE_WALL_ZOT_YELLOW;
                floor = TILE_FLOOR_TOMB;

                    wall  = IDX_WALL_ZOT_GREEN;
                    floor = IDX_FLOOR_TOMB;

                    wall  = TILE_WALL_ZOT_GREEN;
                    floor = TILE_FLOOR_TOMB;

                    wall  = IDX_WALL_ZOT_CYAN;
                    floor = IDX_FLOOR_TOMB;

                    wall  = TILE_WALL_ZOT_CYAN;
                    floor = TILE_FLOOR_TOMB;

                    wall  = IDX_WALL_ZOT_BLUE;
                    floor = IDX_FLOOR_TOMB;

                    wall  = TILE_WALL_ZOT_BLUE;
                    floor = TILE_FLOOR_TOMB;

                    wall  = IDX_WALL_ZOT_MAGENTA;
                    floor = IDX_FLOOR_TOMB;

                    wall  = TILE_WALL_ZOT_MAGENTA;
                    floor = TILE_FLOOR_TOMB;

    wall  = IDX_WALL_NORMAL;
    floor = IDX_FLOOR_NORMAL;

    wall  = TILE_WALL_NORMAL;
    floor = TILE_FLOOR_NORMAL;

    int wall_idx;
    int floor_idx;
    int special_idx;
    WallIdx(wall_idx, floor_idx, special_idx);

    WallIdx(wall_tile_idx, floor_tile_idx, special_tile_idx);

    // TODO enne - link floor tile index to the right location rather than
    // starting at floor normal
    floor_tile_idx = tile_DNGN_start[floor_idx];
    floor_flavors  = tile_DNGN_count[floor_idx];
    wall_tile_idx = tile_DNGN_start[wall_idx];
    wall_flavors  = tile_DNGN_count[wall_idx];

    floor_flavors  = tile_dngn_count[floor_tile_idx];
    wall_flavors  = tile_dngn_count[wall_tile_idx];

    if (special_idx != -1)

    if (special_tile_idx != -1)

        special_tile_idx = tile_DNGN_start[special_idx];
        special_flavors = tile_DNGN_count[special_idx];

        special_flavors = tile_dngn_count[special_tile_idx];

    int copy_doll[TILEP_PARTS_TOTAL];

    int copy_doll[TILEP_PART_MAX];

    //int parts[TILEP_PARTS_TOTAL];

    //int parts[TILEP_PART_MAX];

    for (x = 0; x < TILEP_PARTS_TOTAL; x++)

    for (x = 0; x < TILEP_PART_MAX; x++)

    for (x = TILEP_PART_CLOAK; x < TILEP_PARTS_TOTAL; x++)

    for (x = TILEP_PART_CLOAK; x < TILEP_PART_MAX; x++)

bmp2png / png2bmp version 1.62 - Sep 04, 2005
---------------------------------------------
bmp2png/png2bmp is a pair of simple command-line utilities that convert
between Windows BMP format and PNG (Portable Network Graphics).
This software is freeware.
Using them
----------
The basic command line is:
   bmp2png [-options] list of bmp files ...
   png2bmp [-options] list of png files ...
The input files are not modified; the output data is written to files
which have the same names except for extension. bmp2png always uses
".png" for the output file name's extension; png2bmp uses ".bmp".
To list the options, simply type "bmp2png" or "png2bmp" with no
arguments.
Copyright notice, and license
-----------------------------
bmp2png --- conversion from (Windows or OS/2 style) BMP to PNG
png2bmp --- conversion from PNG to (Windows style) BMP
Copyright (C) 1999-2005 MIYASAKA Masaru <alkaid@coral.ocn.ne.jp>
Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear
in supporting documentation. This software is provided "as is"
without express or implied warranty.
The latest version
------------------
To get the latest version of bmp2png/png2bmp, please visit the
bmp2png/png2bmp home page:
  http://hp.vector.co.jp/authors/VA010446/b2p-home/
Major changes
-------------
version 1.60 [August 25, 2004]
  bmp2png now can read all types of BMP file, including
    16/32 bits/pixel BMP, bitfield BMP, and RLE-encoded BMP.
  Added -P option to bmp2png, which allows to make one particular
    color fully transparent.
version 1.61 [September 4, 2004]
  (executable) Fixed a file-corruption bug which was introduced
    in libpng 1.2.6.
  (source code) Added support for emx complier (not tested).
version 1.62 [September 4, 2005]
  Added alpha channel support. (Added -A, -B and -R options.)
[end]

/*
**  bmphed.h - .bmp file header macros
**
**  Public domain by MIYASAKA Masaru (July 13, 2004)
*/
#ifndef BMPHED_H
#define BMPHED_H
	/* BMP file signature */
#define BMP_SIGNATURE		0x4D42
#define BMP_SIG_BYTES		2
	/* BITMAPFILEHEADER */
#define BFH_WTYPE			0		/* WORD         bfType;          */
#define BFH_DSIZE			2		/* DWORD        bfSize;          */
#define BFH_WRESERVED1		6		/* WORD         bfReserved1;     */
#define BFH_WRESERVED2		8		/* WORD         bfReserved2;     */
#define BFH_DOFFBITS		10		/* DWORD        bfOffBits;       */
#define BFH_DBIHSIZE		14		/* DWORD        biSize;          */
#define FILEHED_SIZE		14		/* sizeof(BITMAPFILEHEADER)      */
#define BIHSIZE_SIZE		4		/* sizeof(biSize)                */
	/* BITMAPINFOHEADER, BITMAPV4HEADER, BITMAPV5HEADER */
#define BIH_DSIZE			0		/* DWORD        biSize;          */
#define BIH_LWIDTH			4		/* LONG         biWidth;         */
#define BIH_LHEIGHT			8		/* LONG         biHeight;        */
#define BIH_WPLANES			12		/* WORD         biPlanes;        */
#define BIH_WBITCOUNT		14		/* WORD         biBitCount;      */
#define BIH_DCOMPRESSION	16		/* DWORD        biCompression;   */
#define BIH_DSIZEIMAGE		20		/* DWORD        biSizeImage;     */
#define BIH_LXPELSPERMETER	24		/* LONG         biXPelsPerMeter; */
#define BIH_LYPELSPERMETER	28		/* LONG         biYPelsPerMeter; */
#define BIH_DCLRUSED		32		/* DWORD        biClrUsed;       */
#define BIH_DCLRIMPORANT	36		/* DWORD        biClrImportant;  */
#define B4H_DREDMASK		40		/* DWORD        bV4RedMask;      */
#define B4H_DGREENMASK		44		/* DWORD        bV4GreenMask;    */
#define B4H_DBLUEMASK		48		/* DWORD        bV4BlueMask;     */
#define B4H_DALPHAMASK		52		/* DWORD        bV4AlphaMask;    */
#define B4H_DCSTYPE			56		/* DWORD        bV4CSType;       */
#define B4H_XENDPOINTS		60		/* CIEXYZTRIPLE bV4Endpoints;    */
#define B4H_DGAMMARED		96		/* DWORD        bV4GammaRed;     */
#define B4H_DGAMMAGREEN		100		/* DWORD        bV4GammaGreen;   */
#define B4H_DGAMMABLUE		104		/* DWORD        bV4GammaBlue;    */
#define B5H_DINTENT			108		/* DWORD        bV5Intent;       */
#define B5H_DPROFILEDATA	112		/* DWORD        bV5ProfileData;  */
#define B5H_DPROFILESIZE	116		/* DWORD        bV5ProfileSize;  */
#define B5H_DRESERVED		120		/* DWORD        bV5Reserved;     */
#define INFOHED_SIZE		40		/* sizeof(BITMAPINFOHEADER)      */
#define BMPV4HED_SIZE		108		/* sizeof(BITMAPV4HEADER)        */
#define BMPV5HED_SIZE		124		/* sizeof(BITMAPV5HEADER)        */
	/* BITMAPCOREHEADER */
#define BCH_DSIZE			0		/* DWORD  bcSize;                */
#define BCH_WWIDTH			4		/* WORD   bcWidth;               */
#define BCH_WHEIGHT			6		/* WORD   bcHeight;              */
#define BCH_WPLANES			8		/* WORD   bcPlanes;              */
#define BCH_WBITCOUNT		10		/* WORD   bcBitCount;            */
#define COREHED_SIZE		12		/* sizeof(BITMAPCOREHEADER)      */
	/* RGBQUAD */
#define RGBQ_BLUE			0		/* BYTE   rgbBlue;     */
#define RGBQ_GREEN			1		/* BYTE   rgbGreen;    */
#define RGBQ_RED			2		/* BYTE   rgbRed;      */
#define RGBQ_RESERVED		3		/* BYTE   rgbReserved; */
#define RGBQUAD_SIZE		4		/* sizeof(RGBQUAD)     */
	/* RGBTRIPLE */
#define RGBT_BLUE			0		/* BYTE   rgbtBlue;    */
#define RGBT_GREEN			1		/* BYTE   rgbtGreen;   */
#define RGBT_RED			2		/* BYTE   rgbtRed;     */
#define RGBTRIPLE_SIZE		3		/* sizeof(RGBTRIPLE)   */
	/* Constants for the biCompression field */
#ifndef BI_RGB
#define BI_RGB				0L		/* Uncompressed        */
#define BI_RLE8				1L		/* RLE (8 bits/pixel)  */
#define BI_RLE4				2L		/* RLE (4 bits/pixel)  */
#define BI_BITFIELDS		3L		/* Bitfield            */
#define BI_JPEG				4L		/* JPEG Extension      */
#define BI_PNG				5L		/* PNG Extension       */
#endif
#endif /* BMPHED_H */

/*
**  bmp2png --- conversion from (Windows or OS/2 style) BMP to PNG
**  png2bmp --- conversion from PNG to (Windows style) BMP
**
**  Copyright (C) 1999-2005 MIYASAKA Masaru <alkaid@coral.ocn.ne.jp>
**
**  Permission to use, copy, modify, and distribute this software and
**  its documentation for any purpose and without fee is hereby granted,
**  provided that the above copyright notice appear in all copies and
**  that both that copyright notice and this permission notice appear
**  in supporting documentation. This software is provided "as is"
**  without express or implied warranty.
**
**  NOTE: Comments are partly written in Japanese. Sorry.
*/
#ifndef COMMON_H
#define COMMON_H
#if defined(__RSXNT__) && defined(__CRTRSXNT__)
# include <crtrsxnt.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
	/* for stat() */
#include <sys/types.h>
#include <sys/stat.h>
	/* for utime() */
#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__LCC__)
# include <sys/utime.h>
# if defined(__LCC__)
   int utime(const char *, struct _utimbuf *);
# endif
#else
# include <utime.h>
#endif
	/* for isatty() */
#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) || \
    defined(__LCC__)
# include <io.h>
#else
# include <unistd.h>
#endif
	/* for mkdir() */
#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) || \
    defined(__LCC__)
# include <direct.h>
# if defined(__MINGW32__)
#  define MKDIR(d,m) _mkdir(d)
# else
#  define MKDIR(d,m) mkdir(d)
# endif
#else
# if defined(__GO32__) && !defined(__DJGPP__)	/* DJGPP v.1 */
#  include <osfcn.h>
# else
#  include <sys/stat.h>
# endif
# define MKDIR(d,m) mkdir(d,m)
#endif
#if !defined(BINSTDIO_FDOPEN) && !defined(BINSTDIO_SETMODE)
# if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__EMX__) || \
     defined(_MSC_VER) || defined(__BORLANDC__) || defined(__LCC__) || \
     defined(__DJGPP__) || defined(__GO32__)
#  define BINSTDIO_SETMODE
# endif
# if 0 /* defined(__YOUR_COMPLIER_MACRO__) */
#  define BINSTDIO_FDOPEN
# endif
#endif
	/* for setmode() */
#ifdef BINSTDIO_SETMODE
# include <io.h>
# include <fcntl.h>
#endif
#include "png.h"
#if (PNG_LIBPNG_VER < 10004)
# error libpng version 1.0.4 or later is required.
#endif
#if (PNG_LIBPNG_VER == 10207) || (PNG_LIBPNG_VER == 10206) || \
    (PNG_LIBPNG_VER == 10017) || (PNG_LIBPNG_VER == 10016)
# error Libpng versions 1.2.7, 1.2.6, 1.0.17, and 1.0.16
# error have a bug that will cause png2bmp to crash.
# error Update your libpng to latest version.
# error "http://www.libpng.org/pub/png/libpng.html"
#endif
#if !defined(PNG_READ_tRNS_SUPPORTED) || !defined(PNG_WRITE_tRNS_SUPPORTED)
# error This software requires tRNS chunk support.
#endif
#ifndef png_jmpbuf					/* pngconf.h (libpng 1.0.6 or later) */
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
#endif
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
# define WIN32
#endif
#if defined(__MSDOS__) && !defined(MSDOS)
# define MSDOS
#endif
#if defined(__CYGWIN__)
# undef WIN32
# undef MSDOS
#endif
#if defined(WIN32) || defined(__DJGPP__)
# define WIN32_LFN		/* Win32-style long filename */
#endif
#if defined(WIN32) || defined(MSDOS)
# define PATHDELIM		'\\'
# define DRIVESUFFIX	':'
# define IsPathDelim(c)	((c)==PATHDELIM || (c)=='/')
# define IsOptChar(c)	((c)=='-' || (c)=='/')
# ifdef JAPANESE
#  define IsDBCSLead(c)	((0x81<=(c) && (c)<=0x9F) || (0xE0<=(c) && (c)<=0xFC))
# else
#  define IsDBCSLead(c)	(0)
# endif
#else	/* UNIX */
# define PATHDELIM		'/'
# define IsPathDelim(c)	((c)==PATHDELIM)
# define IsOptChar(c)	((c)=='-')
# define IsDBCSLead(c)	(0)
#endif
typedef char           CHAR;
typedef unsigned char  BYTE;
typedef short          SHORT;
typedef unsigned short WORD;
typedef int            INT;
typedef unsigned int   UINT;
typedef long           LONG;
typedef unsigned long  DWORD;
typedef enum { FALSE = 0, TRUE = 1 } BOOL;
typedef png_color PALETTE;
typedef struct tagIMAGE {
	LONG    width;
	LONG    height;
	UINT    pixdepth;
	UINT    palnum;
	BOOL    topdown;
	BOOL    alpha;
	/* ----------- */
	DWORD   rowbytes;
	DWORD   imgbytes;
	PALETTE *palette;
	BYTE    **rowptr;
	BYTE    *bmpbits;
	/* ----------- */
	png_color_8 sigbit;
} IMAGE;
extern int quietmode;
extern int errorlog;
extern const char errlogfile[];
void xxprintf(const char *, ...);
void set_status(const char *, ...);
void feed_line(void);
void init_progress_meter(png_structp, png_uint_32, png_uint_32);
void row_callback(png_structp, png_uint_32, int);
void png_my_error(png_structp, png_const_charp);
void png_my_warning(png_structp, png_const_charp);
BOOL imgbuf_alloc(IMAGE *);
void imgbuf_free(IMAGE *);
void imgbuf_init(IMAGE *);
int parsearg(int *, char **, int, char **, char *);
char **envargv(int *, char ***, const char *);
int tokenize(char *, const char *);
int makedir(const char *);
int renbak(const char *);
int cpyftime(const char *, const char *);
FILE *binary_stdio(int);
char *suffix(const char *);
char *basname(const char *);
char *addslash(char *);
char *delslash(char *);
char *path_skiproot(const char *);
char *path_nextslash(const char *);
#ifdef WIN32_LFN
int is_dos_filename(const char *);
#endif
#endif /* COMMON_H */

#--------------------------------
#  bmp2png.exe & png2bmp.exe
#  makefile for Borland C++ 5.5
#--------------------------------
!ifndef srcdir
srcdir	= .
!endif
.path.c = $(srcdir)
.path.h = $(srcdir)
ZINC	= $(srcdir)/../zlib
PINC	= $(srcdir)/../libpng
ZLIB	= $(srcdir)/../zlib
PLIB	= $(srcdir)/../libpng
CC	= bcc32
LD	= bcc32
CFLAGS	= $(MODEL) -q -d -O2 -OS -Oi -Oc -DPNG_USER_CONFIG -I$(PINC) \
	  -I$(ZINC) $(COPT)
LDFLAGS	= $(MODEL) -q -WC -L$(PLIB) -L$(ZLIB) $(LOPT)
LIBS	= libpng.lib zlib.lib noeh32.lib
B2POBJ	= bmp2png.obj common.obj
P2BOBJ	= png2bmp.obj common.obj
all : bmp2png.exe png2bmp.exe
bmp2png.exe : $(B2POBJ)
	$(LD) $(LDFLAGS) -e$@ $(B2POBJ) $(LIBS)
png2bmp.exe : $(P2BOBJ)
	$(LD) $(LDFLAGS) -e$@ $(P2BOBJ) $(LIBS)
.c.obj :
	$(CC) $(CFLAGS) -c $*.c
.c.asm :
	$(CC) $(CFLAGS) -S $*.c
clean : mostlyclean
	if exist *.exe del *.exe
mostlyclean :
	if exist *.obj del *.obj
	if exist *.tds del *.tds
bmp2png.obj : bmp2png.c common.h bmphed.h
png2bmp.obj : png2bmp.c common.h bmphed.h
common.obj  : common.c  common.h

#-----------------------------
#  bmp2png.exe & png2bmp.exe
#  makefile for DJGPP V.2
#-----------------------------
srcdir	= .
VPATH	= $(srcdir)
ZINC	= $(srcdir)/../zlib
PINC	= $(srcdir)/../libpng
ZLIB	= $(srcdir)/../zlib
PLIB	= $(srcdir)/../libpng
CC	= gcc
LD	= gcc
CFLAGS	= -O2 -Wall -mcpu=pentium -march=i386 -DPNG_USER_CONFIG \
	  -I$(PINC) -I$(ZINC) $(COPT)
LDFLAGS	= -s -L$(PLIB) -L$(ZLIB) $(LOPT)
LIBS	= -lpng -lz -lm
B2POBJ	= bmp2png.o common.o
P2BOBJ	= png2bmp.o common.o
B2PMAP	= -Wl,-Map,bmp2png.map
P2BMAP	= -Wl,-Map,png2bmp.map
all : bmp2png.exe png2bmp.exe
bmp2png.exe : $(B2POBJ)
	$(LD) $(LDFLAGS) $(B2PMAP) -o $@ $(B2POBJ) $(LIBS)
png2bmp.exe : $(P2BOBJ)
	$(LD) $(LDFLAGS) $(P2BMAP) -o $@ $(P2BOBJ) $(LIBS)
%.o : %.c
	$(CC) $(CFLAGS) -c $<
%.s : %.c
	$(CC) $(CFLAGS) -S -fverbose-asm $<
%.lst : %.s
	$(CC) -Wa,-a=$@ -c -o NUL $<
clean : mostlyclean
	if exist *.exe del *.exe
	if exist *.map del *.map
mostlyclean :
	if exist *.o   del *.o
bmp2png.o : bmp2png.c common.h bmphed.h
png2bmp.o : png2bmp.c common.h bmphed.h
common.o  : common.c  common.h

#-------------------------------------
#  bmp2png & png2bmp
#  makefile for gcc/gmake
#  Thanks to Gary Aviv for this file.
#-------------------------------------
ifndef BINDIR
BINDIR  = /usr/local/bin
endif
CC      = gcc
LD      = gcc
ifndef INSTALL
INSTALL = install -s -m 755
endif
ifndef CFLAGS
CFLAGS  = -O2 -g -Wall
endif
LIBS    = -lpng -lz -lm
B2POBJ  = bmp2png.o common.o
P2BOBJ  = png2bmp.o common.o
all : bmp2png png2bmp
bmp2png : $(B2POBJ)
	$(LD) $(LDFLAGS) -o bmp2png $(B2POBJ) $(LIBS)
png2bmp : $(P2BOBJ)
	$(LD) $(LDFLAGS) -o png2bmp $(P2BOBJ) $(LIBS)
%.o : %.c
	$(CC) $(CFLAGS) -c -o $@ $<
install :
	$(INSTALL) bmp2png png2bmp $(BINDIR)
uninstall :
	rm -f $(BINDIR)/bmp2png $(BINDIR)/png2bmp
clean :
	rm -f $(B2POBJ) $(P2BOBJ) bmp2png png2bmp
bmp2png.o : bmp2png.c common.h bmphed.h
png2bmp.o : png2bmp.c common.h bmphed.h
common.o  : common.c  common.h

#include "bm.h"
int myrand()
{
    static int seed=12345;
    seed *= 65539;
    return(seed&0x7fffffff);
}
int same_hue(int r, int g, int b, int r0, int g0, int b0)
{
    if (r==255)r=256;
    if (g==255)g=256;
    if (b==255)b=256;
    if(r0*g == g0*r && g0*b == b0*g && b0*r == r0*b) return 1;
    return 0;
}
void convert_hue(unsigned char *r, unsigned char *g, unsigned char *b,
                int r0, int g0, int b0, int modif)
{
    int rr,gg,bb;
    int max0 = r0;
    int max = *r;
    if(max<*g) max=*g;
    if(max<*b) max=*b;
    if(max==255) max=256;
    if(max0<g0) max0=g0;
    if(max0<b0) max0=b0;
    if (max <=32) modif /= 4;
    else
    if (max <=64) modif /= 2;
    rr = ( (max+modif) * r0 )/ max0;
    gg = ( (max+modif) * g0 )/ max0;
    bb = ( (max+modif) * b0 )/ max0;
    if(rr>255) rr=255;
    else if(rr<0) rr=0;
    if(gg>255) gg=255;
    else if(gg<0) gg=0;
    if(bb>255) bb=255;
    else if(bb<0) bb=0;
    *r=rr; *g=gg; *b=bb;
}
int main(int argc, char **argv){
unsigned char *ibuf[3];
int x,y;
int i;
char fn[100],st[1024];
char *flag;
unsigned char *nbuf[3];
int ncol[3],ccol[10][3],nccol,ccol2[10][3], modif[10];
FILE *ifp;
int level,l;
int xx,yy,c,f;
float prob,amp;
int thresh;
  stdpal();
  process_cpath(argv[0]);
if(argc!=1)
    strcpy(fn, argv[1]);
else 
    sprintf(fn,"%sshade.txt",cpath);
fprintf(stderr,"FILE=[%s]\n",fn);
ifp=fopen(fn,"r");
myfget(st,ifp);
sprintf(fn,"%s%s.bmp",cpath,st);
fprintf(stderr,"Orig file=[%s]\n",fn);
ibuf[0]=ibuf[1]=ibuf[2]=NULL;
bmread(fn,&x,&y,ibuf );
fprintf(stderr,"loaded  x=%d y=%d\n",x,y);
flag=malloc(x*y);
for(i=0;i<3;i++)nbuf[i]=malloc(x*y);
while(1){
myfget(st,ifp);
if(feof(ifp))break;
level=atoi(st);
//random perturbation amplitude/prob
myfget(st,ifp);
prob=atof(st);
thresh=(int)(0x7fffffff*prob);
if(prob==-1.0)thresh=-1;//ringmail
if(prob==-2.0)thresh=-2;//chainmail
myfget(st,ifp);
amp=atof(st);
printf("P=%f Amp=%f\n",prob,amp);
// Normal col
myfget(st,ifp);
fprintf(stderr,"Normal [%s]\n",st);
sscanf(st,"%d %d %d",&ncol[0],&ncol[1],&ncol[2]);
//Control col
myfget(st,ifp);
if(feof(ifp))break;
nccol=atoi(st);
for(i=0;i<nccol;i++){
	myfget(st,ifp);
	if(feof(ifp))exit(1);
        modif[i]=0;
	l=sscanf(st,"%d %d %d %d %d %d %d",&ccol[i][0],&ccol[i][1],&ccol[i][2]
			,&ccol2[i][0],&ccol2[i][1],&ccol2[i][2], &modif[i]);
	if(l==3){
		ccol2[i][0]=ccol[i][0];
		ccol2[i][1]=ccol[i][1];
		ccol2[i][2]=ccol[i][2];
	}
}//ncol
fprintf(stderr,"Level=%d ccol=%d\n",level,nccol);
fprintf(stderr,"Normal=%d %d %d\n",ncol[0],ncol[1],ncol[2]);
for(xx=0;xx<x;xx++){
for(yy=0;yy<y;yy++){
int ad=xx+yy*x;
flag[ad]=0;
if( same_hue(ibuf[0][ad], ibuf[1][ad], ibuf[2][ad], 
              ncol[0], ncol[1], ncol[2])) flag[ad]=1;
else
{
for(i=0;i<nccol;i++)
    if(same_hue(ibuf[0][ad], ibuf[1][ad], ibuf[2][ad], 
              ccol[i][0], ccol[i][1], ccol[i][2])) flag[ad]=2+i;
}
}}
/***** convert ******/
for(xx=0;xx<x;xx++){
for(yy=0;yy<y;yy++){
	int ad=xx+yy*x;
	int f=flag[ad];
	if(f>1) convert_hue(&ibuf[0][ad],&ibuf[1][ad],&ibuf[2][ad],
                       ccol2[f-2][0],ccol2[f-2][1],ccol2[f-2][2], modif[f-2]);
}
}
/********************************/
for(l=0;l<level;l++){
for(yy=0;yy<y;yy++){
for(xx=0;xx<x;xx++){
int ad=xx+yy*x;
int sum,n;
if(flag[ad]!=1){
for(c=0;c<3;c++)nbuf[c][ad]=ibuf[c][ad];
continue;
}
for(c=0;c<3;c++){
n=0;sum=0; // (int)(ibuf[c][ad])*1;
if(xx>0 && flag[ad-1]!=0){n++;sum+=ibuf[c][ad-1];}
if(xx<x-1 && flag[ad+1]!=0){n++;sum+=ibuf[c][ad+1];}
if(yy>0 && flag[ad-x]!=0){n++;sum+=ibuf[c][ad-x];}
if(yy<y-1 && flag[ad+x]!=0){n++;sum+=ibuf[c][ad+x];}
if(n!=0){
sum +=n/2;
sum/=n;
nbuf[c][ad]=sum;
}else nbuf[c][ad]=ibuf[c][ad];
}/*c*/
ad++;
}}/*xy**/
for(xx=0;xx<x;xx++){
for(yy=0;yy<y;yy++){
int ad=xx+yy*x;
for(c=0;c<3;c++){
ibuf[c][ad]=nbuf[c][ad];}}}
}/*level*/
/**random **/
if(thresh==-1){//ringmail
for(xx=0;xx<x;xx++){
for(yy=0;yy<y;yy++){
	int ad=xx+yy*x;
    if(flag[ad]!=0){
    int dd=0;
    int flag=(xx+2000-3*yy)%5;
    if(flag==0)dd=+64;
    if(flag==3||flag==4)dd=-32;
	for(c=0;c<3;c++){
	  int d=(int)ibuf[c][ad];
	  d=(int)(d+dd);
	  if(d>255)d=255;
	  if(d<0)d=0;
	  ibuf[c][ad]=(unsigned char)d;
	}
}
}}//XY
}//ringmail
if(thresh==-2){//chainmail
for(xx=0;xx<x;xx++){
for(yy=0;yy<y;yy++){
	int ad=xx+yy*x;
if(flag[ad]!=0){
    int dd=0;
    int flag=(xx+2000-2*yy)%4;
    if(flag==0)dd=+64;
	if(flag==1)dd=+32;
    if(flag==3)dd=-32;
	for(c=0;c<3;c++){
	  int d=(int)ibuf[c][ad];
	  d=(int)(d+dd);
	  if(d>255)d=255;
	  if(d<0)d=0;
	  ibuf[c][ad]=(unsigned char)d;
	}
}
}}//XY
}//chainmail
if(thresh>0){
for(xx=0;xx<x;xx++){
for(yy=0;yy<y;yy++){
	int ad=xx+yy*x;
if(myrand()<thresh && flag[ad]!=0){
    double r=1.0-amp+2*amp*(myrand()*1.0/0x7fffffff);
    if(r<0.0)r=0.0;
	for(c=0;c<3;c++){
	  int d=(int)ibuf[c][ad];
	  d=(int)(d*r);
	  if(d>255)d=255;
	  if(d<0)d=0;
	  ibuf[c][ad]=(unsigned char)d;
	}
}
}}//XY
}//if
}/*while*/
sprintf(fn,"%sb.bmp",cpath);
bmwrite_dither(fn,x,y,ibuf ,flag);
fclose(ifp);
}

unsigned char pbuf[1024]= {
/* index   B      G    R     unused */
// Red
/* 0x00 */ 0x00, 0x00, 0xff, 0x00,
/* 0x01 */ 0x00, 0x00, 0xe0, 0x00,
/* 0x02 */ 0x00, 0x00, 0xc0, 0x00,
/* 0x03 */ 0x00, 0x00, 0xa0, 0x00,
/* 0x04 */ 0x00, 0x00, 0x80, 0x00,
/* 0x05 */ 0x00, 0x00, 0x60, 0x00,
/* 0x06 */ 0x00, 0x00, 0x40, 0x00,
/* 0x07 */ 0x00, 0x00, 0x30, 0x00,
// Dark red
/* 0x08 */ 0x00, 0x00, 0x20, 0x00,
/* 0x09 */ 0x00, 0x00, 0x18, 0x00,
/* 0x0a */ 0x00, 0x00, 0x10, 0x00,
//Pale Red
/* 0x0b */ 0x40, 0x40, 0x80, 0x00,
/* 0x0c */ 0x50, 0x50, 0xa0, 0x00,
/* 0x0d */ 0x60, 0x60, 0xc0, 0x00,
/* 0x0e */ 0x70, 0x70, 0xe0, 0x00,
/* 0x0f */ 0x80, 0x80, 0xff, 0x00,
//Red-Orange
/* 0x10 */ 0x00, 0x40, 0xff, 0x00,
/* 0x11 */ 0x00, 0x38, 0xe0, 0x00,
/* 0x12 */ 0x00, 0x30, 0xc0, 0x00,
/* 0x13 */ 0x00, 0x28, 0xa0, 0x00,
/* 0x14 */ 0x00, 0x20, 0x80, 0x00,
/* 0x15 */ 0x00, 0x18, 0x60, 0x00,
/* 0x16 */ 0x00, 0x10, 0x40, 0x00,
/* 0x17 */ 0x00, 0x0c, 0x30, 0x00,
//Dark Yellow
/* 0x18 */ 0x00, 0x20, 0x20, 0x00,
/* 0x19 */ 0x00, 0x18, 0x18, 0x00,
/* 0x1a */ 0x00, 0x10, 0x10, 0x00,
//Pale Yellow
/* 0x1b */ 0x40, 0x80, 0x80, 0x00,
/* 0x1c */ 0x50, 0xa0, 0xa0, 0x00,
/* 0x1d */ 0x60, 0xc0, 0xc0, 0x00,
/* 0x1e */ 0x70, 0xe0, 0xe0, 0x00,
/* 0x1f */ 0x80, 0xff, 0xff, 0x00,
//Orange
/* 0x20 */ 0x00, 0x80, 0xff, 0x00,
/* 0x21 */ 0x00, 0x70, 0xe0, 0x00,
/* 0x22 */ 0x00, 0x60, 0xc0, 0x00,
/* 0x23 */ 0x00, 0x50, 0xa0, 0x00,
/* 0x24 */ 0x00, 0x40, 0x80, 0x00,
/* 0x25 */ 0x00, 0x30, 0x60, 0x00,
/* 0x26 */ 0x00, 0x20, 0x40, 0x00,
/* 0x27 */ 0x00, 0x18, 0x30, 0x00,
//Dark Green
/* 0x28 */ 0x00, 0x20, 0x00, 0x00,
/* 0x29 */ 0x00, 0x18, 0x00, 0x00,
/* 0x2a */ 0x00, 0x10, 0x00, 0x00,
//Pale Green
/* 0x2b */ 0x40, 0x80, 0x40, 0x00,
/* 0x2c */ 0x50, 0xa0, 0x50, 0x00,
/* 0x2d */ 0x60, 0xc0, 0x60, 0x00,
/* 0x2e */ 0x70, 0xe0, 0x70, 0x00,
/* 0x2f */ 0x80, 0xff, 0x80, 0x00,
//Yellow Orange
/* 0x30 */ 0x00, 0xc0, 0xff, 0x00,
/* 0x31 */ 0x00, 0xa8, 0xe0, 0x00,
/* 0x32 */ 0x00, 0x90, 0xc0, 0x00,
/* 0x33 */ 0x00, 0x78, 0xa0, 0x00,
/* 0x34 */ 0x00, 0x60, 0x80, 0x00,
/* 0x35 */ 0x00, 0x48, 0x60, 0x00,
/* 0x36 */ 0x00, 0x30, 0x40, 0x00,
/* 0x37 */ 0x00, 0x24, 0x30, 0x00,
//Dark cyan
/* 0x38 */ 0x20, 0x20, 0x00, 0x00,
/* 0x39 */ 0x18, 0x18, 0x00, 0x00,
/* 0x3a */ 0x10, 0x10, 0x00, 0x00,
//Pale cyan
/* 0x3b */ 0x80, 0x80, 0x40, 0x00,
/* 0x3c */ 0xa0, 0xa0, 0x50, 0x00,
/* 0x3d */ 0xc0, 0xc0, 0x60, 0x00,
/* 0x3e */ 0xe0, 0xe0, 0x70, 0x00,
/* 0x3f */ 0xff, 0xff, 0x80, 0x00,
//Yellow
/* 0x40 */ 0x00, 0xff, 0xff, 0x00,
/* 0x41 */ 0x00, 0xe0, 0xe0, 0x00,
/* 0x42 */ 0x00, 0xc0, 0xc0, 0x00,
/* 0x43 */ 0x00, 0xa0, 0xa0, 0x00,
/* 0x44 */ 0x00, 0x80, 0x80, 0x00,
/* 0x45 */ 0x00, 0x60, 0x60, 0x00,
/* 0x46 */ 0x00, 0x40, 0x40, 0x00,
/* 0x47 */ 0x00, 0x30, 0x30, 0x00,
//Dark Blue
/* 0x48 */ 0x20, 0x00, 0x00, 0x00,
/* 0x49 */ 0x18, 0x00, 0x00, 0x00,
/* 0x4a */ 0x10, 0x00, 0x00, 0x00,
//Pale Blue
/* 0x4b */ 0x80, 0x40, 0x40, 0x00,
/* 0x4c */ 0xa0, 0x50, 0x50, 0x00,
/* 0x4d */ 0xc0, 0x60, 0x60, 0x00,
/* 0x4e */ 0xe0, 0x70, 0x70, 0x00,
/* 0x4f */ 0xff, 0x80, 0x80, 0x00,
//Yellow Green
/* 0x50 */ 0x00, 0xff, 0x80, 0x00,
/* 0x51 */ 0x00, 0xe0, 0x70, 0x00,
/* 0x52 */ 0x00, 0xc0, 0x60, 0x00,
/* 0x53 */ 0x00, 0xa0, 0x50, 0x00,
/* 0x54 */ 0x00, 0x80, 0x40, 0x00,
/* 0x55 */ 0x00, 0x60, 0x30, 0x00,
/* 0x56 */ 0x00, 0x40, 0x20, 0x00,
/* 0x57 */ 0x00, 0x30, 0x18, 0x00,
//Dark magenta
/* 0x58 */ 0x20, 0x00, 0x20, 0x00,
/* 0x59 */ 0x18, 0x00, 0x18, 0x00,
/* 0x5a */ 0x10, 0x00, 0x10, 0x00,
//Pale Magenta
/* 0x5b */ 0x80, 0x40, 0x80, 0x00,
/* 0x5c */ 0xa0, 0x50, 0xa0, 0x00,
/* 0x5d */ 0xc0, 0x60, 0xc0, 0x00,
/* 0x5e */ 0xe0, 0x70, 0xe0, 0x00,
/* 0x5f */ 0xff, 0x80, 0xff, 0x00,
//Green
/* 0x60 */ 0x00, 0xff, 0x00, 0x00,
/* 0x61 */ 0x00, 0xe0, 0x00, 0x00,
/* 0x62 */ 0x00, 0xc0, 0x00, 0x00,
/* 0x63 */ 0x00, 0xa0, 0x00, 0x00,
/* 0x64 */ 0x00, 0x80, 0x00, 0x00,
/* 0x65 */ 0x00, 0x60, 0x00, 0x00,
/* 0x66 */ 0x00, 0x40, 0x00, 0x00,
/* 0x67 */ 0x00, 0x30, 0x00, 0x00,
// Dark Pale Red
/* 0x68 */ 0x30, 0x30, 0x60, 0x00,
/* 0x69 */ 0x20, 0x20, 0x40, 0x00,
/* 0x6a */ 0x18, 0x18, 0x30, 0x00,
//Very Pale Red
/* 0x6b */ 0x60, 0x60, 0x80, 0x00,
/* 0x6c */ 0x78, 0x78, 0xa0, 0x00,
/* 0x6d */ 0x90, 0x90, 0xc0, 0x00,
/* 0x6e */ 0xa8, 0xa8, 0xe0, 0x00,
/* 0x6f */ 0xc0, 0xc0, 0xff, 0x00,
// BlueGreen
/* 0x70 */ 0x80, 0xff, 0x00, 0x00,
/* 0x71 */ 0x70, 0xe0, 0x00, 0x00,
/* 0x72 */ 0x60, 0xc0, 0x00, 0x00,
/* 0x73 */ 0x50, 0xa0, 0x00, 0x00,
/* 0x74 */ 0x40, 0x80, 0x00, 0x00,
/* 0x75 */ 0x30, 0x60, 0x00, 0x00,
/* 0x76 */ 0x20, 0x40, 0x00, 0x00,
/* 0x77 */ 0x18, 0x30, 0x00, 0x00,
// Dark Pale Yellow
/* 0x78 */ 0x30, 0x60, 0x60, 0x00,
/* 0x79 */ 0x20, 0x40, 0x40, 0x00,
/* 0x7a */ 0x18, 0x30, 0x30, 0x00,
//Very Pale Yellow
/* 0x7b */ 0x60, 0x80, 0x80, 0x00,
/* 0x7c */ 0x78, 0xa0, 0xa0, 0x00,
/* 0x7d */ 0x90, 0xc0, 0xc0, 0x00,
/* 0x7e */ 0xa8, 0xe0, 0xe0, 0x00,
/* 0x7f */ 0xc0, 0xff, 0xff, 0x00,
// Cyan
/* 0x80 */ 0xff, 0xff, 0x00, 0x00,
/* 0x81 */ 0xe0, 0xe0, 0x00, 0x00,
/* 0x82 */ 0xc0, 0xc0, 0x00, 0x00,
/* 0x83 */ 0xa0, 0xa0, 0x00, 0x00,
/* 0x84 */ 0x80, 0x80, 0x00, 0x00,
/* 0x85 */ 0x60, 0x60, 0x00, 0x00,
/* 0x86 */ 0x40, 0x40, 0x00, 0x00,
/* 0x87 */ 0x30, 0x30, 0x00, 0x00,
//Dark Pale Green
/* 0x88 */ 0x30, 0x60, 0x30, 0x00,
/* 0x89 */ 0x20, 0x40, 0x20, 0x00,
/* 0x8a */ 0x18, 0x30, 0x18, 0x00,
//Very Plae Green
/* 0x8b */ 0x60, 0x80, 0x60, 0x00,
/* 0x8c */ 0x78, 0xa0, 0x78, 0x00,
/* 0x8d */ 0x90, 0xc0, 0x90, 0x00,
/* 0x8e */ 0xa8, 0xe0, 0xa8, 0x00,
/* 0x8f */ 0xc0, 0xff, 0xc0, 0x00,
//Sky Blue
/* 0x90 */ 0xff, 0x80, 0x00, 0x00,
/* 0x91 */ 0xe0, 0x70, 0x00, 0x00,
/* 0x92 */ 0xc0, 0x60, 0x00, 0x00,
/* 0x93 */ 0xa0, 0x50, 0x00, 0x00,
/* 0x94 */ 0x80, 0x40, 0x00, 0x00,
/* 0x95 */ 0x60, 0x30, 0x00, 0x00,
/* 0x96 */ 0x40, 0x20, 0x00, 0x00,
/* 0x97 */ 0x30, 0x18, 0x00, 0x00,
//Dark Plae Cyan
/* 0x98 */ 0x60, 0x60, 0x30, 0x00,
/* 0x99 */ 0x40, 0x40, 0x20, 0x00,
/* 0x9a */ 0x30, 0x30, 0x18, 0x00,
//Very Pale Cyan
/* 0x9b */ 0x80, 0x80, 0x60, 0x00,
/* 0x9c */ 0xa0, 0xa0, 0x78, 0x00,
/* 0x9d */ 0xc0, 0xc0, 0x90, 0x00,
/* 0x9e */ 0xe0, 0xe0, 0xa8, 0x00,
/* 0x9f */ 0xff, 0xff, 0xc0, 0x00,
// Blue
/* 0xa0 */ 0xff, 0x00, 0x00, 0x00,
/* 0xa1 */ 0xe0, 0x00, 0x00, 0x00,
/* 0xa2 */ 0xc0, 0x00, 0x00, 0x00,
/* 0xa3 */ 0xa0, 0x00, 0x00, 0x00,
/* 0xa4 */ 0x80, 0x00, 0x00, 0x00,
/* 0xa5 */ 0x60, 0x00, 0x00, 0x00,
/* 0xa6 */ 0x40, 0x00, 0x00, 0x00,
/* 0xa7 */ 0x30, 0x00, 0x00, 0x00,
//Dark Pale Blue
/* 0xa8 */ 0x60, 0x30, 0x30, 0x00,
/* 0xa9 */ 0x40, 0x20, 0x20, 0x00,
/* 0xaa */ 0x30, 0x18, 0x18, 0x00,
//Very Pale Blue
/* 0xab */ 0x80, 0x60, 0x60, 0x00,
/* 0xac */ 0xa0, 0x78, 0x78, 0x00,
/* 0xad */ 0xc0, 0x90, 0x90, 0x00,
/* 0xae */ 0xe0, 0xa8, 0xa8, 0x00,
/* 0xaf */ 0xff, 0xc0, 0xc0, 0x00,
// BlueMagenta
/* 0xb0 */ 0xff, 0x00, 0x80, 0x00,
/* 0xb1 */ 0xe0, 0x00, 0x70, 0x00,
/* 0xb2 */ 0xc0, 0x00, 0x60, 0x00,
/* 0xb3 */ 0xa0, 0x00, 0x50, 0x00,
/* 0xb4 */ 0x80, 0x00, 0x40, 0x00,
/* 0xb5 */ 0x60, 0x00, 0x30, 0x00,
/* 0xb6 */ 0x40, 0x00, 0x20, 0x00,
/* 0xb7 */ 0x30, 0x00, 0x18, 0x00,
//Dark Pale Magenta
/* 0xb8 */ 0x60, 0x30, 0x60, 0x00,
/* 0xb9 */ 0x40, 0x20, 0x40, 0x00,
/* 0xba */ 0x30, 0x18, 0x30, 0x00,
//Very Pale Magenta
/* 0xbb */ 0x80, 0x60, 0x80, 0x00,
/* 0xbc */ 0xa0, 0x78, 0xa0, 0x00,
/* 0xbd */ 0xc0, 0x90, 0xc0, 0x00,
/* 0xbe */ 0xe0, 0xa8, 0xe0, 0x00,
/* 0xbf */ 0xff, 0xc0, 0xff, 0x00,
//Magenta
/* 0xc0 */ 0xff, 0x00, 0xff, 0x00,
/* 0xc1 */ 0xe0, 0x00, 0xe0, 0x00,
/* 0xc2 */ 0xc0, 0x00, 0xc0, 0x00,
/* 0xc3 */ 0xa0, 0x00, 0xa0, 0x00,
/* 0xc4 */ 0x80, 0x00, 0x80, 0x00,
/* 0xc5 */ 0x60, 0x00, 0x60, 0x00,
/* 0xc6 */ 0x40, 0x00, 0x40, 0x00,
/* 0xc7 */ 0x30, 0x00, 0x30, 0x00,
//Grayscale
/* 0xc8 */ 0xff, 0xff, 0xff, 0x00,
/* 0xc9 */ 0xe0, 0xe0, 0xe0, 0x00,
/* 0xca */ 0xc0, 0xc0, 0xc0, 0x00,
/* 0xcb */ 0xa0, 0xa0, 0xa0, 0x00,
/* 0xcc */ 0x80, 0x80, 0x80, 0x00,
/* 0xcd */ 0x60, 0x60, 0x60, 0x00,
/* 0xce */ 0x40, 0x40, 0x40, 0x00,
/* 0xcf */ 0x20, 0x20, 0x20, 0x00,
//Red Magenta
/* 0xd0 */ 0x80, 0x00, 0xff, 0x00,
/* 0xd1 */ 0x70, 0x00, 0xe0, 0x00,
/* 0xd2 */ 0x60, 0x00, 0xc0, 0x00,
/* 0xd3 */ 0x50, 0x00, 0xa0, 0x00,
/* 0xd4 */ 0x40, 0x00, 0x80, 0x00,
/* 0xd5 */ 0x30, 0x00, 0x60, 0x00,
/* 0xd6 */ 0x20, 0x00, 0x40, 0x00,
/* 0xd7 */ 0x18, 0x00, 0x30, 0x00,
//Grayscale
/* 0xd8 */ 0xf0, 0xf0, 0xf0, 0x00,
/* 0xd9 */ 0xd0, 0xd0, 0xd0, 0x00,
/* 0xda */ 0xb0, 0xb0, 0xb0, 0x00,
/* 0xdb */ 0x90, 0x90, 0x90, 0x00,
/* 0xdc */ 0x70, 0x70, 0x70, 0x00,
/* 0xdd */ 0x50, 0x50, 0x50, 0x00,
/* 0xde */ 0x30, 0x30, 0x30, 0x00,
/* 0xdf */ 0x10, 0x10, 0x10, 0x00,
// Flesh
/* 0xe0 */ 0x48, 0x5a, 0x7f, 0x00,
/* 0xe1 */ 0x5e, 0x76, 0xa5, 0x00,
/* 0xe2 */ 0x72, 0x8f, 0xca, 0x00,
/* 0xe3 */ 0x82, 0xa2, 0xe5, 0x00,
/* 0xe4 */ 0x91, 0xb6, 0xff, 0x00,
/* 0xe5 */ 0xaf, 0xd3, 0xff, 0x00,
//Gold   12:10:4
#if 0
  //Old Gold colors
  /* 0xe6 */ 0x1f, 0x54, 0x68, 0x00,
  /* 0xe7 */ 0x20, 0x70, 0x80, 0x00,
  /* 0xe8 */ 0x34, 0x88, 0xaa, 0x00,
  /* 0xe9 */ 0x40, 0xa0, 0xc0, 0x00,
  /* 0xea */ 0x4d, 0xc4, 0xf2, 0x00,
  /* 0xeb */ 0x60, 0xe0, 0xf8, 0x00,
  /* 0xec */ 0x99, 0xfc, 0xfc, 0x00,
#endif
// New gold colors r:g:b = 6:5:2
/* 0xe6 */ 0x20, 0x50, 0x60, 0x00,
/* 0xe7 */ 0x2a, 0x6a, 0x80, 0x00,
/* 0xe8 */ 0x35, 0x85, 0xa0, 0x00,
/* 0xe9 */ 0x40, 0xa0, 0xc0, 0x00,
/* 0xea */ 0x4a, 0xba, 0xe0, 0x00,
/* 0xeb */ 0x60, 0xe0, 0xf8, 0x00,
/* 0xec */ 0xa0, 0xff, 0xff, 0x00,
// Zombie 
#if 0
  // Old zombie skin colors
  /* 0xed */ 0x58, 0x69, 0x75, 0x00, -> 607080
  /* 0xee */ 0x6e, 0x87, 0x91, 0x00, -> 788ca0
  /* 0xef */ 0x81, 0x9a, 0xab, 0x00, -> 90a8c0
#endif
  // New zombie skin colors  r:g:b=8:7:6
/* 0xed */ 0x48, 0x54, 0x60, 0x00,
/* 0xee */ 0x60, 0x70, 0x80, 0x00,
/* 0xef */ 0x78, 0x8c, 0xa0, 0x00,
/* 0xf0 */ 0x90, 0xa8, 0xc0, 0x00,
/* 0xf1 */ 0xa8, 0xc4, 0xe0, 0x00,
#if 0
  // Old  Brass  14:12:10,  13:10.5:5
  /* 0xf0 */ 0xa0, 0xc0, 0xe0, 0x00,  -> a8c4e0
  /* 0xf1 */ 0x50, 0xa8, 0xd0, 0x00,  -> 40a0c0
#endif
// Unused
// (reserving 16 colors for the system seemed a reasonable idea
//   when I was using 256 color X-Window display, but it seems
//   an obsolete idea now. However, I should be very careful to
//   introduce new colors.
/* 0xf2 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf3 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf4 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf5 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf6 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf7 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf8 */ 0x00, 0x00, 0x00, 0x00,
/* 0xf9 */ 0x00, 0x00, 0x00, 0x00,
/* 0xfa */ 0x00, 0x00, 0x00, 0x00,
/* 0xfb */ 0x00, 0x00, 0x00, 0x00,
/* 0xfc */ 0x00, 0x00, 0x00, 0x00,
/* 0xfd */ 0x00, 0x00, 0x00, 0x00,
/* 0xfe */ 0x00, 0x00, 0x00, 0x00,
//Transparent color
/* 0xff */ 0x6c, 0x6c, 0x47, 0x00
};

#include "bm.h"
#define WID 64
/** Some global **/
int corpse=0, mesh =0,slant=0;
int rim=0;
int exp_wall;
int dsize;
int sx32 = 16;
int sy32 = 24;
FILE *mfp,*sfp;
char outname[1024], ctgname[100], subsname[100];
char sdir[300];
char realname[1024];
/*** BUFFER MEMORY ***/
#define XX 16
int xx0;
#define YY 30
#define LX (XX)
/*** tmp buffer, floor , final output, final queue ***/
unsigned char *tbuf[3],fbuf[3][128*64],
 *obuf[3],dbuf[3][128*64];
unsigned char wallbuf[4][3][32*48];
unsigned char wall2buf[3][128*64];
int f_wx;
/*** normal floor*/
#define WOADR(x,y,xx,yy) \
((x)*64+xx+  xx0*64*((y)*64+yy))
#define ADR32(x,y) ((x)+(y)*32)
#define ADR64(x,y) ((x)+(y)*64)
/*** output width/height in block ***/
int bx,by;
/**************************/
/* Wrapper routines *******/
/**************************/
int load_it(char *fnam, int *wx, int *wy)
{
  sprintf(realname,"%s%s%c%s.bmp",cpath,sdir,PATHSEP,fnam);
  if(bmread(realname,wx,wy,tbuf)==0) return 0;
  sprintf(realname,"%s%s.bmp",cpath,fnam);
  if(bmread(realname,wx,wy,tbuf)==0) return 0;
  if(subsname[0]){
    sprintf(realname,"%s%s%c%s.bmp",cpath,sdir,PATHSEP,subsname);
    if(bmread(realname,wx,wy,tbuf)==0) return 0;
    sprintf(realname,"%s%s.bmp",cpath,subsname);
    if(bmread(realname,wx,wy,tbuf)==0) return 0;
  }
return 1;
}
void clr_dbuf() {
int xx,yy;
for(xx=0;xx<64;xx++){
for(yy=0;yy<64;yy++){
dbuf[0][ ADR64(xx,yy) ]=0x47;
dbuf[1][ ADR64(xx,yy) ]=0x6c;
dbuf[2][ ADR64(xx,yy) ]=0x6c;
}}
}
#define TILEX 64
#define TILEY 64
void make_rim(){
static unsigned char dflag[TILEX][TILEY];
int x,y,c,dd[3],ad;
int n0,n1,n2;
for(y=0;y<TILEY;y++){
for(x=0;x<TILEX;x++){
  dflag[x][y]=1;
  ad=x + y *TILEX;
  for(c=0;c<3;c++)dd[c]=dbuf[c][ad];
  if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c)) dflag[x][y]=0;
  if( (dd[0]==0)&&(dd[1]==0)&& (dd[2]==0)) dflag[x][y]=2;
}
}
for(x=0;x<TILEX;x++){
for(y=0;y<TILEY;y++){
  ad=x+y*TILEX;
if(dflag[x][y]==2 || dflag[x][y]==0){
n0=n1=n2=0;
if(x>0){ 
 if(dflag[x-1][y]==0) n0++;
 if(dflag[x-1][y]==1) n1++;
 if(dflag[x-1][y]==2) n2++;
}
if(y>0){
 if(dflag[x][y-1]==0) n0++;
 if(dflag[x][y-1]==1) n1++;
 if(dflag[x][y-1]==2) n2++;
}
if(x<TILEX-1){
 if(dflag[x+1][y]==0) n0++;
 if(dflag[x+1][y]==1) n1++;
 if(dflag[x+1][y]==2) n2++;
}
if(y<TILEY-1){
 if(dflag[x][y+1]==0) n0++;
 if(dflag[x][y+1]==1) n1++;
 if(dflag[x][y+1]==2) n2++;
}
if(n1!=0 )
dbuf[0][x+y*TILEX]=dbuf[1][x+y*TILEX]=dbuf[2][x+y*TILEX]=0x10;
}}}
}
void cp_floor_64(){
int xx,yy,c;
for(xx=0;xx<64;xx++)
for(yy=0;yy<64;yy++)
for(c=0;c<3;c++)
dbuf[c][ ADR64(xx,yy) ]=fbuf[c][ ADR64(xx,yy)];
}
void cp_floor_32(){
int xx,yy,c;
for(xx=0;xx<32;xx++)
for(yy=0;yy<32;yy++)
for(c=0;c<3;c++)
dbuf[c][ ADR64(32+xx-yy,32+(xx+yy)/2) ]=fbuf[c][ ADR32(xx,yy)];
}
void cp_monst_32(){
int xx,yy,c,dd[3],ad;
char dflag[32][32];
int xmin,xmax,ymin,ymax;
int ox=0;
int oy=0;
if(corpse==1 ){
	xmin=ymin=31;
	xmax=ymax=0;
	for(xx=0;xx<32;xx++){
	for(yy=0;yy<32;yy++){
		ad=ADR32(xx,yy);
		for(c=0;c<3;c++)dd[c]=tbuf[c][ad];
		if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
		if( (dd[0]==0)&&(dd[1]==0)&& (dd[2]==0))continue;
		if(xx<xmin)xmin=xx;
		if(xx>xmax)xmax=xx;
		if(yy<ymin)ymin=yy;
		if(yy>ymax)ymax=yy;
	}}/*xy**/
	ox=(xmax+xmin)/2-16;
	oy=(ymax+ymin)/2-16;
}
if(slant==1){
  for(xx=0;xx<32;xx++){
  for(yy=0;yy<32;yy++){
    int x1 = xx-yy+32;
    int y1=  32+(xx+yy)/2;
    ad = ADR32(xx,yy);
    for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
    if(mesh==2){
      if( (dd[0]!=0x47)||(dd[1]!=0x6c)|| (dd[2]!=0x6c)){
        if( ((x1+y1)&1) ==0)dd[0]=dd[1]=dd[2]=0;
      }
    }
    if(mesh==1){
      if( (((x1/2)+(y1/2))&1) ==1)dd[0]=dd[1]=dd[2]=0;
    }
    if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
    for(c=0;c<3;c++) {dbuf[c][ADR64(x1,y1)]=dd[c];}
  }}
return;
}
if(dsize==1){
  for(xx=0;xx<32;xx++){
  for(yy=0;yy<32;yy++){
    int x1 = xx*2;
    int y1=  yy*2;
    ad = ADR32(xx,yy);
    for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
    if(mesh==2){
      if( (dd[0]!=0x47)||(dd[1]!=0x6c)|| (dd[2]!=0x6c)){
        if( ((x1+y1)&1) ==0)dd[0]=dd[1]=dd[2]=0;
      }
    }
    if(mesh==1){
      if( (((x1/2)+(y1/2))&1) ==1)dd[0]=dd[1]=dd[2]=0;
    }
    if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
    for(c=0;c<3;c++) 
    {
        dbuf[c][ADR64(x1,y1)]=dd[c];
        dbuf[c][ADR64(x1+1,y1)]=dd[c];
        dbuf[c][ADR64(x1,y1+1)]=dd[c];
        dbuf[c][ADR64(x1+1,y1+1)]=dd[c];
    }
  }}
return;
}
for(xx=0;xx<32;xx++){
for(yy=0;yy<32;yy++){
dflag[xx][yy]=0;
ad=ADR32(xx,yy);
if(corpse==1){
    int x1=xx+ox;
    int y1=(yy+oy)*2-16;
    int cy=18;
    if(xx<4 || xx>=28)cy+=2;else
    if(xx<12 || xx>=20) cy+=1;
    if(yy>=cy-1 && yy<=cy+0)continue;
    x1 += (y1-16)/4;
    if(y1>=cy){y1-=2;x1-=3;}else {y1 +=2;x1+=3;}
    if(x1<0 || x1>=32 || y1<0 || y1>=32)continue;
    ad=ADR32(x1,y1);
}
/*** normal***/
for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
if(mesh==2){
if( (dd[0]!=0x47)||(dd[1]!=0x6c)|| (dd[2]!=0x6c)){
if( ((xx+yy)&1) ==0)dd[0]=dd[1]=dd[2]=0;
}
}
if(mesh==1){
if( (((xx/2)+(yy/2))&1) ==1)dd[0]=dd[1]=dd[2]=0;
}
if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
if( (corpse==1) &&(dd[0]==0)&&(dd[1]==0)&& (dd[2]==0))continue;
for(c=0;c<3;c++) {dbuf[c][ADR64(sx32+xx,sy32+yy)]=dd[c];}
 dflag[xx][yy]=1;
}}
#if 1
if(corpse==1){
for(xx=0;xx<32;xx++){
int cy=18;
if(xx<4 || xx>=28)cy+=2;else
if(xx<12 || xx>=20) cy+=1;
if(dflag[xx][cy-2]==1 && dflag[xx][cy+1]==1 ){
for(yy=cy-1;yy<=cy-0;yy++){ dbuf[0][ADR64(16+xx,32+yy)]=32;
dbuf[1][ADR64(16+xx,32+yy)]=0;dbuf[2][ADR64(16+xx,32+yy)]=0;
dflag[xx][yy]=1;
}}
}
/** shade**/
for(xx=1;xx<32;xx++){
for(yy=1;yy<32;yy++){
if(dflag[xx][yy]==0 && dflag[xx-1][yy-1]==1){
dbuf[0][ADR64(xx,yy)]=0;
dbuf[1][ADR64(xx,yy)]=0;
dbuf[2][ADR64(xx,yy)]=0;
}
}}
for(xx=3;xx<32;xx++){
for(yy=3;yy<32;yy++){
if(dflag[xx][yy]==0 && dflag[xx-1][yy-1]==0
 && dflag[xx-2][yy-2]==1  && dflag[xx-3][yy-3]==1){
dbuf[0][ADR64(xx,yy)]=0;
dbuf[1][ADR64(xx,yy)]=0;
dbuf[2][ADR64(xx,yy)]=0;
}
}}
}
#endif
}
void cp_monst_64(){
int xx,yy,c,dd[3],ad;
for(xx=0;xx<64;xx++){
for(yy=0;yy<64;yy++){
    ad=ADR64(xx,yy);
    /*** normal***/
    for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
    if(mesh==2)
    {
        if( (dd[0]!=0x47)||(dd[1]!=0x6c)|| (dd[2]!=0x6c))
            if( ((xx+yy)&1) ==0)dd[0]=dd[1]=dd[2]=0;
    }
    if(mesh==1)
        if( (((xx/2)+(yy/2))&1) ==1)dd[0]=dd[1]=dd[2]=0;
    if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
    for(c=0;c<3;c++) {dbuf[c][ADR64(xx,yy)]=dd[c];}
}}
}
void cp_monst_4864(){
int xx,yy,c,dd[3],ad;
for(xx=0;xx<48;xx++){
for(yy=0;yy<64;yy++){
    ad= xx+yy*48;
    /*** normal***/
    for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
    if(mesh==2)
    {
        if( (dd[0]!=0x47)||(dd[1]!=0x6c)|| (dd[2]!=0x6c))
            if( ((xx+yy)&1) ==0)dd[0]=dd[1]=dd[2]=0;
    }
    if(mesh==1)
        if( (((xx/2)+(yy/2))&1) ==1)dd[0]=dd[1]=dd[2]=0;
    if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
    for(c=0;c<3;c++) {dbuf[c][8+xx+yy*64]=dd[c];}
}}
}
void bflush(){
int xx,yy,c;
if(rim==1) make_rim();
    fprintf(mfp,"<area shape=\"rect\" coords=\"%d,%d,%d,%d\" href=%s>\n",
    bx*WID,by*WID,bx*WID+WID-1,by*WID+WID-1,
    realname);
for(xx=0;xx<64;xx++){
for(yy=0;yy<64;yy++){
for(c=0;c<3;c++){
obuf[c][WOADR(bx,by,xx,yy)]= dbuf[c][ADR64(xx,yy)];
}}}
}
void copy_wall(int wall_ix, int xofs, int yofs){
int xx,yy,c;
unsigned char dd[3];
     for(xx=0;xx<64;xx++){
     for(yy=0;yy<64;yy++){
       int x=xx-xofs-16;
       int y=yy-yofs-8;
       int ad = x+y*32;
       if(x<0 || y<0 || x>=32 || y>=48) continue;
       for(c=0;c<3;c++){dd[c]=wallbuf[wall_ix][c][ad];}
       if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
       for(c=0;c<3;c++) {dbuf[c][ADR64(xx,yy)]=dd[c];}
     }}
}
void copy_wall_vert(int wall_ix, int xofs, int yofs){
int xx,yy,c,ymax;
unsigned char dd[3];
    for(xx=0;xx<64;xx++){
    for(yy=0;yy<64;yy++){
	int x=xx-xofs-16;
	int y=yy-yofs-8;
	int ad = x+y*32;
	if(x<0 || y<0 || x>=32 || y>=48) continue;
	ymax= 8+x/2;
	if(ymax> 8+(31-x)/2) ymax=8+(31-x)/2;
	if(y<=ymax) continue;
 
        for(c=0;c<3;c++){dd[c]=wallbuf[wall_ix][c][ad];}
        if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
	//Mesh
//	if( ((x/2+y/2)&1) == 0) dd[0]=dd[1]=dd[2]=0;
        for(c=0;c<3;c++) {dbuf[c][ADR64(xx,yy)]=dd[c];}
    }}
}
void expand_wall(){
//unsigned char wallbuf[4][3][32*48];
int xx,yy,c,ix;
exp_wall=1;
for(ix=0;ix<4;ix++){
for(xx=0;xx<32;xx++){
for(yy=0;yy<48;yy++){
wallbuf[ix][0][xx+yy*32]=0x47;
wallbuf[ix][1][xx+yy*32]=0x6c;
wallbuf[ix][2][xx+yy*32]=0x6c;
}}}
//decompose wall bmp
for(xx=0;xx<32;xx++){
  int ymax= 8+xx/2;
  if(ymax> 8+(31-xx)/2) ymax=8+(31-xx)/2;
  for(yy=0;yy<ymax;yy++){
    ix=0;
    if(2*yy+xx >=32)ix +=1;
    if(2*yy-xx >=0 )ix +=2;
    for(c=0;c<3;c++)wallbuf[ix][c][xx+yy*32]=tbuf[c][xx+yy*32];
  }
  for(yy=ymax;yy<48;yy++){
    if(xx<8) ix=2;else if(xx<24) ix=3; else ix=1;
    for(c=0;c<3;c++)wallbuf[ix][c][xx+yy*32]=tbuf[c][xx+yy*32];
  }
}//xx
/*
    0
1  1 2  2
  3 4 5
 6 7 8 9
  A B C
4  D E  8
    F
*/
for(ix=0;ix<16;ix++){
     clr_dbuf();
    if(f_wx==32)cp_floor_32(); else cp_floor_64();
    if((ix&3)==3) copy_wall(3,0,-16);
    if(ix&1) copy_wall(1,-16,-8);
    if(ix&2) copy_wall(2,16,-8);
    if(ix&1) copy_wall(3,-16,-8);
    copy_wall(0, 0,0);
    if(ix&2) copy_wall(3,16,-8);
    if((ix&5)==5) {copy_wall(1,-32,0);copy_wall_vert(2,-16,0);}
    copy_wall(2,0,0);
    copy_wall(1,0,0);
    if((ix&10)==10) {copy_wall(2,32,0);copy_wall_vert(1,16,0);}
    if(ix&4) {copy_wall(0,-16,8);copy_wall_vert(3,-16,0);}
    copy_wall(3,0,0);
    if(ix&8) {copy_wall(0,16,8);copy_wall_vert(3,16,0);}
    if(ix&4) {copy_wall(1,-16,8);copy_wall_vert(2,0,8);}
    if(ix&8) {copy_wall(2,16,8); copy_wall_vert(1,0,8);}
    if((ix&12)==12) {copy_wall(0,0,16);copy_wall_vert(3,0,8);}
    bflush();
    bx++;if(bx==xx0){bx=0;by++;}
  }/*ix*/
}
static void copy_wall2_h1(int ix, int xofs, int yofs){
int xx,yy,c,ad;
unsigned char dd[3];
     for(xx=0;xx<64;xx++){
     for(yy=0;yy<64;yy++){
       int x=xx-xofs;
       int y=yy-yofs;;
       ad = x+64+y*128;
       if (x<0 || y<0 || x>63 || y>63)continue;
	   if(2*y>=x+32) continue;
	   if(2*y>=95-x) continue;
       if((ix%3)==0) if (2*y>=47-x)continue;
       if((ix%3)==1) if ((2*y<47-x) || (2*y>=79-x))continue;
       if((ix%3)==2) if(2*y<79-x)continue;
       if((ix/3)==0) if(2*y>=x-16)continue;
       if((ix/3)==1) if((2*y<x-16) || (2*y>=x+16))continue;
       if((ix/3)==2) if(2*y<x+16) continue;
        for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
        if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
        for(c=0;c<3;c++) {dbuf[c][ADR64(xx,yy)]=dd[c];}
     }}
}
void copy_wall2_h2(int ix, int xofs, int yofs){
int xx,yy,c,ad;
unsigned char dd[3];
     for(xx=0;xx<64;xx++){
     for(yy=0;yy<64;yy++){
       int x=xx-xofs;
       int y=yy-yofs;;
       ad = x+y*128;
       if (x<0 || y<0 || x>63 || y>63)continue;
       if(2*y>=x+32) continue;
	   if(2*y>=95-x) continue;
	   
       if ((ix%2)==0)if (2*y>=63-x)continue;
       if((ix%2)==1) if (2*y<63-x)continue;
       	 
       if((ix/2)==0)if(2*y>=x)continue;
       if((ix/2)==1)if(2*y<x)continue;
        for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
        if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
        for(c=0;c<3;c++) {dbuf[c][ADR64(xx,yy)]=dd[c];}
     }}
}
void copy_wall_v2(int ix, int kind, int xofs, int yofs){
int xx,yy,c,ymax,ad;
unsigned char dd[3];
    for(xx=0;xx<64;xx++){
    for(yy=0;yy<64;yy++){
	int x=xx-xofs;
	int y=yy-yofs;
	ad = x+kind*64+y*128;
	if(x<0 || y<0 || x>=64 || y>=64) continue;
	ymax= 16+x/2;
	if(x>=32) ymax=16+(63-x)/2;
	if(y<ymax) continue;
    if(y>ymax+32)continue;
    if(ix==0) if(x>=8)continue;
    if(ix==1) if(x<8 || x>=24)continue;
    if(ix==2) if(x<24 || x>=40)continue;
    if(ix==3) if(x<40 || x>=56)continue;
    if(ix==4) if(x<56)continue;
    
    for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
        if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
        for(c=0;c<3;c++) {dbuf[c][ADR64(xx,yy)]=dd[c];}
    }}
}
void expand_wall2(){
//void copy_wall2_h(int kind, int ix, int xofs, int yofs)
int ix;
exp_wall=1;
for(ix=0;ix<16;ix++){
     clr_dbuf();
    if(f_wx==32)cp_floor_32(); else cp_floor_64();
if((ix&3)==0) copy_wall2_h1(0,   0,  8);
if((ix&3)==1) copy_wall2_h1(1, -16,  0);
if((ix&3)==2) copy_wall2_h1(3,  16,  0);
if((ix&3)==3) copy_wall2_h2(0, 0, 0);
if((ix&5)==0) copy_wall2_h1(6,  16,  0);
if((ix&5)==1) copy_wall2_h1(7,   0, -8);
if((ix&5)==4) copy_wall2_h1(3,   0,  8);
if((ix&5)==5) copy_wall2_h2(2, 0, 0);
if((ix&10)==0) copy_wall2_h1(2, -16,  0);
if((ix&10)==2) copy_wall2_h1(5,   0, -8);
if((ix&10)==8) copy_wall2_h1(1,   0,  8);
if((ix&10)==10) copy_wall2_h2(1, 0, 0);
if((ix&12)==0) copy_wall2_h1(8,   0, -8);
if((ix&12)==4) copy_wall2_h1(5, -16,  0);
if((ix&12)==8) copy_wall2_h1(7,  16,  0);
if((ix&12)==12) copy_wall2_h2(3, 0, 0);
if((ix&5)==5) copy_wall_v2(0, 0,  0,  0);
if((ix&10)==10) copy_wall_v2(4, 0,  0,  0);
if((ix&4)!=0) copy_wall_v2(1, 0,  0,  0);
if((ix&8)!=0) copy_wall_v2(3, 0,  0,  0);
if((ix&12)==12) copy_wall_v2(2, 0,  0,  0);
if((ix&5)==1) copy_wall_v2(1, 1,  0,  -8);
if((ix&12)==8) copy_wall_v2(1, 1,  16,  0);
if((ix&10)==2) copy_wall_v2(3, 1,  0,  -8);
if((ix&12)==4) copy_wall_v2(3, 1, -16,  0);
if((ix&5)==0)  copy_wall_v2(0, 1,  16,  0);
if((ix&10)==0) copy_wall_v2(4, 1, -16,  0);
if((ix&12)==0) copy_wall_v2(2, 1,   0, -8);
    bflush();
    bx++;if(bx==xx0){bx=0;by++;}
}
}
void  load_monst(fnam) char *fnam;{
int wx, wy;
    if( load_it(fnam, &wx, &wy))
    {
	 printf("no file %s.bmp\n",fnam);
        getchar();
	exit(1);
    }
    exp_wall=0;
    if(wx==128 && wy==64) expand_wall2();
    else if(wx==48 && wy==64) cp_monst_4864();
    else if(wx==32 && wy==48) expand_wall();
    else if(wx==32)cp_monst_32();
    else if(wx==64)cp_monst_64();
    bflush();
}
void process_config(char *fname)
{
  int i,j;
  char tmp[100],st[1024];
  char *nuke;
  FILE *fp=fopen(fname,"r");
  if(fp==NULL){
    printf("Error no config file %s\nHit return",fname);
    getchar();
    exit(1);
  }
while(1){
  fgets(tmp,99,fp);
  if(feof(fp))break;
  i=0;while(i<99 && tmp[i]>=32)i++;
  tmp[i]=0;
fprintf(stderr,"[%s]\n",tmp);
  if(getname(tmp,"back",st))
  {
    /*** Set Background BMP (format "%back bmpname") ***/
    if(strncmp(st,"none",4)==0)
    {
       /**  clear **/
       for(i=0;i<32*32;i++){fbuf[0][i]=0x47;fbuf[1][i]=fbuf[2][i]=0x6c;}
       f_wx=64;
    }
    else
    {
       int wy;
       load_it(st, &f_wx, &wy);
       for(i=0;i<f_wx*wy;i++)for(j=0;j<3;j++)fbuf[j][i]=tbuf[j][i];
    }
    continue;
  }
  if (getname(tmp,"include",st)){
   char fn2[200];
   sprintf(fn2,"%s%s",cpath, st);
   if(strcmp(fname,fn2)!=0) process_config(fn2);
   continue;
  }
  if (getval(tmp,"slant",&slant)) continue;
  if (getval(tmp,"dsize",&dsize)) continue;
  if (getval(tmp,"mesh",&mesh)) continue;
  if (getval(tmp,"rim",&rim)) continue;
  if (getval(tmp,"corpose",&corpse)) continue;
  if (getname(tmp,"ctg",ctgname)) continue;
  if (getname(tmp,"subst",subsname)) continue;
  if (getname(tmp,"sdir",sdir)) continue;
  if (getname(tmp,"name", outname)) continue;
  if (getval(tmp,"width",&xx0)) continue;
  if (getval(tmp,"sx",&sx32)) continue;
  if (getval(tmp,"sy",&sy32)) continue;
  if (tmp[0]=='#' || tmp[0]<32){
    if(tmp[0]<32)  {}
    else fprintf(sfp,"\n//%s\n",tmp);
    continue;
  } 
   /*** normal bitmap ***/
    clr_dbuf();
    if(f_wx==32)cp_floor_32(); else cp_floor_64();
    i=0;while(i<99 && tmp[i]>32)i++;
    tmp[i]=0; strcpy(st, &tmp[i+1]);
    load_monst(tmp);
    if(!strstr(st,"IGNORE_COMMENT"))
    {
        nuke=strstr(st,"/*");if(nuke)*nuke=0;
        if(exp_wall)
        fprintf(sfp,"TILE_%s, (TILE_TOTAL+%d),\n",st,bx+by*xx0-16);
	else
        fprintf(sfp,"TILE_%s, (TILE_TOTAL+%d),\n",st,bx+by*xx0);
    }
    if(!exp_wall){bx++;if(bx==xx0){bx=0;by++;}}
}/* while */
 fclose(fp);
}
int main(argc,argv)
int argc;
char *argv[];
{
  int i;
  char fn[100];
  fixalloc(tbuf,256*256);
  slant=corpse=mesh=dsize=0;
  bx=by=0;
  process_cpath(argv[0]);
  fixalloc(obuf, LX*64*(YY)*64);
  xx0=XX;
  ctgname[0]=0;
  subsname[0]=0;
  sdir[0]=0;
  stdpal();
  strcpy(outname,"tile");
sprintf(fn,"%stiledef-qv.h",cpath);
sfp=fopen(fn,"w");
if(sfp==NULL){
        printf("Error could not open %s\nHit return",fn);
        getchar();
        exit(1);
}
mfp=fopen("map.htm","w");
fprintf(mfp,"<HTML><head>\n");
fprintf(mfp,"<base href=\"http://cvs.sourceforge.net/viewcvs.py/rltiles/rltiles/
\">\n");
fprintf(mfp,"</head><body><MAP NAME=\"nhmap\">\n");
fprintf(sfp,"/* Automatically generated by tile generator. */\n");
fprintf(sfp,"const int tile_qv_pair_table[] ={\n");
  printf("%s\ncpath=%s\n",argv[0],cpath);
  if(argc==1)
    sprintf(fn,"%sdc-qv.txt",cpath);
  else strcpy(fn,argv[1]);
  process_config(fn);
fprintf(sfp,"-1, -1 };\n");
fprintf(sfp,"\n#define TILE_TOTAL_EX %d\n",bx+by*xx0);
fprintf(sfp,"#define TILE_PER_ROW_EX %d\n",xx0);
fclose(sfp);
i=by*64;if(bx!=0)i+=64;
sprintf(fn,"%s%s.bmp",cpath,outname);
bmwrite(fn,xx0*64,i,obuf);
fprintf(mfp,"<IMG SRC=http://rltiles.sf.net/%s.png USEMAP=\"#nhmap\" >\n</body>\
n</html>\n", outname);
fclose(mfp);
return 0;
}

#include "bm.h"
/** Some global **/
int corpse, mesh,slant, rim;
FILE *mfp,*sfp;
char outname[1024], ctgname[100], subsname[100];
char sdir[300];
char realname[1024];
/*** BUFFER MEMORY ***/
#define XX 30
int xx0;
#define YY 90
#define LX (XX)
/*** tmp buffer, floor , final output, final queue ***/
unsigned char *tbuf[3],fbuf[3][32*32], *obuf[3],dbuf[3][32*32];
/*** normal floor*/
#define WOADR(x,y,xx,yy) \
((x)*32+xx+  xx0*32*((y)*32+yy))
#define ADR(x,y) ((x)+(y)*32)
/*** output width/height in block ***/
int bx,by;
/****************************************/
/* Wrapper routines **************/
/**************************/
int load_pxxx(fnam) char *fnam;{
int x,y;
sprintf(realname,"%s%s%c%s.bmp",cpath,sdir,PATHSEP,fnam);
if(bmread(realname,&x,&y,tbuf)==0) return 0;
sprintf(realname,"%s%s.bmp",cpath,fnam);
if(bmread(realname,&x,&y,tbuf)==0) return 0;
if(subsname[0]){
    sprintf(realname,"%s%s%c%s.bmp",cpath,sdir,PATHSEP,subsname);
    if(bmread(realname,&x,&y,tbuf)==0) return 0;
    sprintf(realname,"%s%s.bmp",cpath,subsname);
    if(bmread(realname,&x,&y,tbuf)==0) return 0;
}
return 1;
}
void clr_buf() {
int xx,yy;
for(xx=0;xx<32;xx++){
for(yy=0;yy<32;yy++){
dbuf[0][ ADR(xx,yy) ]=0x47;
dbuf[1][ ADR(xx,yy) ]=0x6c;
dbuf[2][ ADR(xx,yy) ]=0x6c;
}}
}
void cp_floor(){
int xx,yy,c;
for(xx=0;xx<32;xx++)
for(yy=0;yy<32;yy++)
for(c=0;c<3;c++)
dbuf[c][ ADR(xx,yy) ]=fbuf[c][ ADR(xx,yy)];
}
#define TILEX 32
#define TILEY 32
void make_rim(){
static unsigned char dflag[TILEX][TILEY];
int x,y,c,dd[3],ad;
int n0,n1,n2;
for(y=0;y<TILEY;y++){
for(x=0;x<TILEX;x++){
  dflag[x][y]=1;
  ad=ADR(x,y);
  for(c=0;c<3;c++)dd[c]=dbuf[c][ad];
  if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c)) dflag[x][y]=0;
  if( (dd[0]==0)&&(dd[1]==0)&& (dd[2]==0)) dflag[x][y]=2;
}
}
for(x=0;x<TILEX;x++){
for(y=0;y<TILEY;y++){
  ad=x+y*TILEX;
if(dflag[x][y]==2 || dflag[x][y]==0){
n0=n1=n2=0;
if(x>0){ 
 if(dflag[x-1][y]==0) n0++;
 if(dflag[x-1][y]==1) n1++;
 if(dflag[x-1][y]==2) n2++;
}
if(y>0){
 if(dflag[x][y-1]==0) n0++;
 if(dflag[x][y-1]==1) n1++;
 if(dflag[x][y-1]==2) n2++;
}
if(x<31){
 if(dflag[x+1][y]==0) n0++;
 if(dflag[x+1][y]==1) n1++;
 if(dflag[x+1][y]==2) n2++;
}
if(y<31){
 if(dflag[x][y+1]==0) n0++;
 if(dflag[x][y+1]==1) n1++;
 if(dflag[x][y+1]==2) n2++;
}
if(n1!=0 )
dbuf[0][x+y*32]=dbuf[1][x+y*32]=dbuf[2][x+y*32]=0x10;
}}}
}
void cp_monst_32(){
int xx,yy,c,dd[3],ad;
char dflag[32][32];
int xmin,xmax,ymin,ymax,ox,oy;
if(corpse==1 ){
	xmin=ymin=31;
	xmax=ymax=0;
	for(xx=0;xx<32;xx++){
	for(yy=0;yy<32;yy++){
		ad=ADR(xx,yy);
		for(c=0;c<3;c++)dd[c]=tbuf[c][ad];
		if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
		if( (dd[0]==0)&&(dd[1]==0)&& (dd[2]==0))continue;
		if(xx<xmin)xmin=xx;
		if(xx>xmax)xmax=xx;
		if(yy<ymin)ymin=yy;
		if(yy>ymax)ymax=yy;
}}/*xy**/
ox=(xmax+xmin)/2-16;
oy=(ymax+ymin)/2-16;
}
for(xx=0;xx<32;xx++){
for(yy=0;yy<32;yy++){
dflag[xx][yy]=0;
ad=ADR(xx,yy);
if(corpse==1){
int x1=xx+ox;
int y1=(yy+oy)*2-16;
int cy=18;
if(xx<4 || xx>=28)cy+=2;else
if(xx<12 || xx>=20) cy+=1;
if(yy>=cy-1 && yy<=cy+0)continue;
x1 += (y1-16)/4;
if(y1>=cy){y1-=2;x1-=3;}else {y1 +=2;x1+=3;}
if(x1<0 || x1>=32 || y1<0 || y1>=32)continue;
ad=ADR(x1,y1);
}
/*** normal***/
for(c=0;c<3;c++){dd[c]=tbuf[c][ad];}
if(mesh==2){
if( (dd[0]!=0x47)||(dd[1]!=0x6c)|| (dd[2]!=0x6c)){
if( ((xx+yy)&1) ==0)dd[0]=dd[1]=dd[2]=0;
}
}
if(mesh==1){
if( (((xx/2)+(yy/2))&1) ==1)dd[0]=dd[1]=dd[2]=0;
}
if( (dd[0]==0x47)&&(dd[1]==0x6c)&& (dd[2]==0x6c))continue;
if( (corpse==1) &&(dd[0]==0)&&(dd[1]==0)&& (dd[2]==0))continue;
for(c=0;c<3;c++) {dbuf[c][ADR(xx,yy)]=dd[c];}
 dflag[xx][yy]=1;
}}
#if 1
if(corpse==1){
for(xx=0;xx<32;xx++){
int cy=18;
if(xx<4 || xx>=28)cy+=2;else
if(xx<12 || xx>=20) cy+=1;
if(dflag[xx][cy-2]==1 && dflag[xx][cy+1]==1 ){
for(yy=cy-1;yy<=cy-0;yy++){ dbuf[0][ADR(xx,yy)]=32;
dbuf[1][ADR(xx,yy)]=0;dbuf[2][ADR(xx,yy)]=0;
dflag[xx][yy]=1;
}}
}
/** shade**/
for(xx=1;xx<32;xx++){
for(yy=1;yy<32;yy++){
if(dflag[xx][yy]==0 && dflag[xx-1][yy-1]==1){
dbuf[0][ADR(xx,yy)]=0;
dbuf[1][ADR(xx,yy)]=0;
dbuf[2][ADR(xx,yy)]=0;
}
}}
for(xx=3;xx<32;xx++){
for(yy=3;yy<32;yy++){
if(dflag[xx][yy]==0 && dflag[xx-1][yy-1]==0
 && dflag[xx-2][yy-2]==1  && dflag[xx-3][yy-3]==1){
dbuf[0][ADR(xx,yy)]=0;
dbuf[1][ADR(xx,yy)]=0;
dbuf[2][ADR(xx,yy)]=0;
}
}}
}
#endif
if(rim==1)make_rim();
}
void bflush(){
int xx,yy,c;
for(xx=0;xx<32;xx++){
for(yy=0;yy<32;yy++){
for(c=0;c<3;c++){
obuf[c][WOADR(bx,by,xx,yy)]= dbuf[c][ADR(xx,yy)];
}}}
}
void  load_monst(fnam) char *fnam;{
	if( load_pxxx(fnam)){
		 printf("no file pxxx/%s.bmp or %s/%s.bmp\n",fnam,sdir,fnam);
                getchar();
		exit(1);
	}
	cp_monst_32();
	bflush();
}
void process_config(char *fname)
{
  int i,j;
  char tmp[100],st[1024];
  char *nuke;
  FILE *fp=fopen(fname,"r");
  if(fp==NULL){
    printf("Error no config file %s\nHit return",fname);
    getchar();
    exit(1);
  }
while(1){
fgets(tmp,99,fp);
if(feof(fp))break;
i=0;while(i<99 && tmp[i]>=32)i++;
tmp[i]=0;
  if(getname(tmp,"back",st))
  {
    /*** Set Background BMP (format "%back bmpname") ***/
    if(strncmp(st,"none",4)==0)
    {
       /**  clear **/
       for(i=0;i<32*32;i++){fbuf[0][i]=0x47;fbuf[1][i]=fbuf[2][i]=0x6c;}
    }
    else
    {
       load_pxxx(st);
       for(i=0;i<32*32;i++)for(j=0;j<3;j++)fbuf[j][i]=tbuf[j][i];
    }
    continue;
  }
  if (getname(tmp,"include",st)){
   char fn2[200];
   sprintf(fn2,"%s%s",cpath, st);
   if(strcmp(fname,fn2)!=0) process_config(fn2);
   continue;
  }
  if (getval(tmp,"slant",&slant)) continue;
  if (getval(tmp,"rim",&rim)) continue;
  if (getval(tmp,"mesh",&mesh)) continue;
  if (getval(tmp,"corpse",&corpse)) continue;
  if (getname(tmp,"ctg",ctgname)) continue;
  if (getname(tmp,"subst",subsname)) continue;
  if (getname(tmp,"sdir",sdir)) continue;
  if (getname(tmp,"name", outname)) continue;
  if (getval(tmp,"width",&xx0)) continue;
  if (tmp[0]=='#' || tmp[0]<32){
    if(tmp[0]=='#')fprintf(sfp,"//%s\n",tmp);
    if(tmp[0]<32) fprintf(sfp,"\n");
    continue;
  } 
/*** normal bitmap ***/
#define WID 32
clr_buf();cp_floor();
i=0;while(i<99 && tmp[i]>32)i++;
tmp[i]=0; strcpy(st, &tmp[i+1]);
 load_monst(tmp);
fprintf(mfp,"<area shape=\"rect\" coords=\"%d,%d,%d,%d\" href=%s>\n",
bx*WID,by*WID,bx*WID+WID-1,by*WID+WID-1,
realname);
if(!strstr(st,"IGNORE_COMMENT")){
nuke=strstr(st,"/*");if(nuke)*nuke=0;
fprintf(sfp,"#define TILE_%s %d\n",st,bx+by*xx0);
}
bx++;if(bx==xx0){bx=0;by++;;}
}/* while */
 fclose(fp);
}
int main(argc,argv)
int argc;
char *argv[];
{
  int i;
  char fn[100],st2[100];
  slant=corpse=mesh=rim=0;
  bx=by=0;
  process_cpath(argv[0]);
  xx0=XX;
  ctgname[0]=0;
  subsname[0]=0;
  sdir[0]=0;
  stdpal();
  fixalloc(tbuf,256*256);
  fixalloc(obuf, LX*64*(YY)*64);
  strcpy(outname,"tile");
sprintf(fn,"%smap.htm",cpath);
mfp=fopen(fn,"w");
if(mfp==NULL){
	printf("Error could not open %s\nHit return",fn);
	getchar();
	exit(1);
}
sprintf(fn,"%stiledef.h",cpath);
sfp=fopen(fn,"w");
if(sfp==NULL){
        printf("Error could not open %s\nHit return",fn);
        getchar();
        exit(1);
}
fprintf(sfp,"/* Automatically generated by tile generator. */\n");
fprintf(mfp,"<HTML><head>\n");
fprintf(mfp,"<base href=\"http://cvs.sourceforge.net/viewcvs.py/rltiles/rltiles/\">\n");
fprintf(mfp,"</head><body><MAP NAME=\"nhmap\">\n");
  printf("%s\ncpath=%s\n",argv[0],cpath);
  if(argc==1)
    sprintf(fn,"%sdc-all.txt",cpath);
  else strcpy(fn,argv[1]);
  process_config(fn);
fprintf(sfp,"#define TILE_TOTAL %d\n",bx+by*xx0);
fprintf(sfp,"#define TILE_PER_ROW %d\n",xx0);
fprintf(mfp,"<IMG SRC=http://rltiles.sf.net/%s.png USEMAP=\"#nhmap\" >\n</body>\n</html>\n", outname);
fclose(mfp);
fclose(sfp);
i=by*32;if(bx!=0)i+=32;
sprintf(fn,"%s%s.bmp",cpath,outname);
bmwrite(fn,xx0*32,i,obuf);
}