#define simple_iso_tile(x) (x)

void tile_set_force_redraw_tiles(bool redraw);
void tile_set_force_redraw_inv(bool redraw);

//�^�C�g��

// MAY_STAB, FLAG_STAB, and FLAG_PET are mutually exclusive
#define TILE_FLAG_MAY_STAB 0xC000 // May stab brand is always fg
#define TILE_FLAG_STAB    0x8000 // Stab brand is always fg
#define TILE_FLAG_PET     0x4000 //pet is always fg

enum tile_flags
{
    // Foreground flags
    TILE_FLAG_S_UNDER   = 0x00000800,
    TILE_FLAG_FLYING    = 0x00001000,
    TILE_FLAG_NET       = 0x00002000,
    TILE_FLAG_PET       = 0x00004000,
    TILE_FLAG_STAB      = 0x00008000,
    TILE_FLAG_MAY_STAB  = 0x0000C000,

#define TILE_FLAG_NET     0x2000 //nets are always in fg
#define TILE_FLAG_FLYING  0x1000 //flying object is always fg
#define TILE_FLAG_S_UNDER 0x800 //fg
#define TILE_FLAG_CURSOR  0xc000 //cursor is always bg
#define TILE_FLAG_CURSOR1 0x8000 //cursor is always bg
#define TILE_FLAG_CURSOR2 0x4000 //cursor is always bg
#define TILE_FLAG_CURSOR3 0xc000 //cursor is always bg
#define TILE_FLAG_CURSOR0 0x0000 //cursor is always bg
#define TILE_FLAG_UNSEEN 0x2000 //unseen flag is set to bg
#define TILE_FLAG_MM_UNSEEN 0x1000
#define TILE_FLAG_RAY    0x800

    // Background flags
    TILE_FLAG_RAY       = 0x00000800,
    TILE_FLAG_MM_UNSEEN = 0x00001000,
    TILE_FLAG_UNSEEN    = 0x00002000,
    TILE_FLAG_CURSOR0   = 0x00000000,
    TILE_FLAG_CURSOR1   = 0x00008000,
    TILE_FLAG_CURSOR2   = 0x00004000,
    TILE_FLAG_CURSOR3   = 0x0000C000,
    TILE_FLAG_CURSOR    = 0x0000C000,

#define TILE_FLAG_MASK   0x07ff

    // General
    TILE_FLAG_MASK      = 0x000007FF
};

static void init_tileflag();

static bool force_redraw_tile = false;
static bool force_redraw_inv = false;

bool force_redraw_tile;
bool force_redraw_inv = false;

void tile_set_force_redraw_tiles(bool redraw)
{
    force_redraw_tile = redraw;
}
void tile_set_force_redraw_inv(bool redraw)
{
    force_redraw_inv = redraw;
}

unsigned char tile_flag[TILE_TOTAL2];
#define TFLAG_A 0x80
#define TFLAG_B 0x40
#define TFLAG_C 0x20
#define TFLAG_D 0x10
#define TFLAG_F 0x08
#define TFLAG_G 0x04
#define TFLAG_H 0x02
#define TFLAG_I 0x01

#define tile_check_blank(tile,region) \
    if( (tile_flag[tile & TILE_FLAG_MASK]&(region))==0) (tile) &= ~TILE_FLAG_MASK;

/* BG tile priority */
static unsigned char tile_prio[TILE_TOTAL2];
#define PRIO_WALL 10
#define tile_is_wall(tile) (tile_prio[(tile)&TILE_FLAG_MASK]==PRIO_WALL)

    init_tileflag();

        t2buf[x][y]=simple_iso_tile(TILE_DNGN_UNSEEN)|TILE_FLAG_UNSEEN;

        t2buf[x][y]=TILE_DNGN_UNSEEN|TILE_FLAG_UNSEEN;

/*** Investigate a region of specific tile whether it contains any
     picture, or it is blank ***/
int init_tileflag_aux(int tile, int xs, int ys, int wx, int wy){
    int x,y, sx,sy;
    img_type src=TileImg;
    ASSERT(tile<TILE_TOTAL2);
    sx = tile % TILE_PER_ROW;
    sx *= TILE_X;
    sy = tile / TILE_PER_ROW;
    sy *= TILE_Y;
    for(x=xs;x<xs+wx;x++){
    for(y=ys;y<ys+wy;y++){
        if(!ImgIsTransparentAt(src, sx+x, sy+y))
            return 1;
    }}
    return 0;
}
void init_tileflag(){
    int tile, flag;
    for(tile=0;tile<TILE_TOTAL2;tile++){
        flag = 0;
        tile_flag[tile]=flag;
        tile_prio[tile]=0;
    }
    for(tile=0;tile<4;tile++)
    {
        tile_prio[simple_iso_tile(TILE_DNGN_LAVA)+tile]=2;
        tile_prio[simple_iso_tile(TILE_DNGN_SHALLOW_WATER)+tile]=2;
        tile_prio[simple_iso_tile(TILE_DNGN_DEEP_WATER)+tile]=3;
    }
}

    *bbg=simple_iso_tile(TILE_DNGN_FLOOR);

    *bbg=TILE_DNGN_FLOOR;

    if (fg == 0 || (fg & TILE_FLAG_FLYING)!=0) return 0;
/*
    if ( bg0 == simple_iso_tile(TILE_DNGN_SHALLOW_WATER))
        return TILE_MASK_SHALLOW_WATER;
    if ( bg0 == simple_iso_tile(TILE_DNGN_DEEP_WATER))
        return TILE_MASK_DEEP_WATER;
    if ( bg0 >= simple_iso_tile(TILE_DNGN_LAVA) &&
         bg0 <= simple_iso_tile(TILE_DNGN_LAVA)+3)
        return TILE_MASK_LAVA;
*/
    if ( bg0 >= simple_iso_tile(TILE_DNGN_LAVA) &&
         bg0 <= simple_iso_tile(TILE_DNGN_SHALLOW_WATER) + 3)

    if (fg == 0 || (fg & TILE_FLAG_FLYING) != 0)
        return 0;
    if ( bg0 >= TILE_DNGN_LAVA &&
         bg0 <= TILE_DNGN_SHALLOW_WATER + 3)

        int result = TILE_SINK_MASK;//simple_iso_tile(TILE_SINK_MASK);
        if ((fg & TILE_FLAG_MASK) >= TILE_NORMAL)
            result = simple_iso_tile(TILE_SINK_MASK);
        //if ((fg & TILE_FLAG_MASK) >= TILE_NORMAL) result++;
        return result;

        return TILE_SINK_MASK;

    if(!TileImg)return;

    if(!TileImg)
        return;

    t2buf[x][y]=simple_iso_tile(TILE_DNGN_UNSEEN)|TILE_FLAG_UNSEEN;

    t2buf[x][y]=TILE_DNGN_UNSEEN|TILE_FLAG_UNSEEN;

    //Hack: call it again
    init_tileflag();

#if 0
void libgui_load_prefs(struct pref_data *pref, int nprefs)
{
    int i;
    strcpy(font_name, my_getenv("CRAWL_X11_FONT", 
		"-alias-fixed-bold-r-normal--16-*"));
    strcpy(font_name, my_getenv("CRAWL_X11_FONT", "9x15"));
    *crt_x = my_getenv_int("CRAWL_X11_CRTX",80);
    *crt_y = my_getenv_int("CRAWL_X11_CRTY",25);
    *msg_x = my_getenv_int("CRAWL_X11_MSGX",80);
    *msg_y = my_getenv_int("CRAWL_X11_MSGY",8);
    *map_x = my_getenv_int("CRAWL_X11_MAPX",3);
    *map_y = my_getenv_int("CRAWL_X11_MAPY",3);
    *dngn_x = my_getenv_int("CRAWL_X11_DNGNX",17);
    *dngn_y = my_getenv_int("CRAWL_X11_DNGNY",17);
}
void libgui_save_prefs()
{
}
#endif

extern TextRegionClass *region_crt;

    static char newtip[512];
    static char oldtip[512];
    char tbuf[35];
    strncpy(newtip, tip, 500);
    char* pc = strchr(newtip, '\n');
    if (pc)
        *pc = 0;

    const unsigned int tip_size = 512;
    static char old_tip[tip_size];
    char new_tip[tip_size];

    if (strncmp(oldtip, newtip, 500)==0)

    if (strncmp(old_tip, tip, tip_size) == 0)

    strncpy(oldtip, newtip, 500);

    const bool is_main_screen = (win_main->active_layer == 0);
    const unsigned int height = is_main_screen ? region_tip->my : 1;
    const unsigned int width = is_main_screen ? region_tip->mx : region_crt->mx;
    strncpy(new_tip, tip, tip_size);
    strncpy(old_tip, new_tip, tip_size);

    strncpy(tbuf,tip,34);
    tbuf[34]=0;

    if (is_main_screen)
    {
        region_tip->clear();
    }

    if (win_main->active_layer == 0)

    char *next_tip = new_tip;
    for (unsigned int i = 0; next_tip && i < height; i++)

        // avoid overruns...
        if ((int)strlen(newtip) > region_tip->mx)

        char *this_tip = next_tip;
        // find end of line
        char *pc = strchr(next_tip, '\n');
        if (pc)
        {
            *pc = 0;
            next_tip = pc + 1;
        }
        else
        {
            next_tip = 0;
        }
        if (strlen(this_tip) > width)

            char *ins = strchr(newtip, '{');
            if (ins && ins[-1] == ' ') ins--;
            if (ins && (ins - newtip <= region_tip->mx))

            char *ins = strchr(this_tip, '{');
            if (ins && ins[-1] == ' ')
                ins--;
            if (ins && (ins - this_tip <= (int)width))

                char *state = strchr(newtip, '(');
                if (state && state[-1] == ' ') state--;
                if (state && (state - newtip <= region_tip->mx))

                char *state = strchr(this_tip, '(');
                if (state && state[-1] == ' ')
                    state--;
                if (state && (state - this_tip <= (int)width))

                    newtip[region_tip->mx] = 0;
                    newtip[region_tip->mx-1] = '.';
                    newtip[region_tip->mx-2] = '.';

                    this_tip[width] = 0;
                    this_tip[width-1] = '.';
                    this_tip[width-2] = '.';

        region_tip->clear();
        region_tip->gotoxy(1,1);
        region_tip->addstr(newtip);
        region_tip->make_active();
    }
    else
    {
        textattr( WHITE );
        gotoxy(1, get_number_of_lines() + 1);
        cprintf("%s", oldtip);
        clear_to_end_of_line();

        if (is_main_screen)
        {
            region_tip->gotoxy(1, 1 + i);
            region_tip->addstr(this_tip);
            region_tip->make_active();
        }
        else
        {
            ASSERT(i == 0);
            textattr(WHITE);
            gotoxy(1, get_number_of_lines() + 1);
            cprintf("%s", this_tip);
            clear_to_end_of_line();
        }

#define deblog(x)  {FILE *ddfp=fopen("log.txt","a");fprintf(ddfp,x);fprintf(ddfp,"\n");fclose(ddfp);}
#define deblog2(x,y)  {FILE *ddfp=fopen("log.txt","a");fprintf(ddfp,"%s %d\n",x,y);fclose(ddfp);}

extern bool force_redraw_tile;
extern bool force_redraw_inv;

    region_tip = new TextRegionClass(region_stat->mx, 1, 0, 0);

    const unsigned int region_tip_height = 3;
    region_tip = new TextRegionClass(region_stat->mx, region_tip_height, 0, 0);

            force_redraw_tile = true;

            tile_set_force_redraw_tiles(true);

        force_redraw_inv = true;

        tile_set_force_redraw_inv(true);

                    desc += EOL "[L-Click] *Pickup(g)";

                    desc += EOL "[L-Click] Pick up (g)";

                            desc += "*(w)ield";

                            desc += "Wield (w)";

                            desc += "unwield";

                            desc += "Unwield";

                                desc += "draw a card";

                                desc += "Draw a card (E)";

                            desc += "*(E)voke";

                            desc += "Evoke (E)";

                            desc += "*(W)ear";

                            desc += "Wear (W)";

                            desc += "*(T)ake off";

                            desc += "Take off (T)";

                            desc += "*(P)ut on";

                            desc += "Put on (P)";

                            desc += "*(R)emove";

                            desc += "Remove (R)";

                            desc += "*(t)hrow";

                            desc += "Throw (t)";

                            desc += "*(z)ap";

                            desc += "Zap (z)";

                                desc += "*(M)emorize";

                                desc += "Memorize (M)";

                            desc += "*(r)ead";

                            desc += "Read (r)";

                            desc += "*(q)uaff";

                            desc += "Quaff (q)";

                            desc += "*(e)at";

                            desc += "Eat (e)";

                                desc += "drink blood";

                                desc += "Drink blood (e)";

                            desc += "*Use it";

                            desc += "Use";

                    desc += EOL "[Shift-L-Click] *(d)rop";

                    desc += EOL "[Shift-L-Click] Drop (d)";

            desc += EOL "[L-Click] *Search 1 turn(s)";

            desc += EOL "[L-Click] Search 1 turn";

            desc += EOL "[R-Click] Overview(%)";

            desc += EOL "[R-Click] Overview (%)";

            update_tip_text("[L-Click] Rest/Search for a while");

            update_tip_text("[L-Click] Rest / Search for a while");