#include "include.h"
#include "func.h"

#if TRACE_EN
#define TRACE(...) printf(__VA_ARGS__)
#else
#define TRACE(...)
#endif
#ifdef TJD_BIRD_GAME_16M
typedef struct f_game_t_ {
    uint32_t tick;
    int16_t  speed;
    s16      bird_y_pos;
    s16      pipe_x_pos;
    s16      pipe_y_pos;
    uint8_t  pipe_index;
    uint8_t  pipe_cut;
    uint8_t  status;          //游戏状态
    uint8_t  bird_anim_cnt;
} f_game_t;

enum
{
    COMPO_ID_GAME_STOP_PIC = 1,
    COMPO_ID_GAME_BIRD_PIC,
    COMPO_ID_GAME_PIPE_PIC_START,
    COMPO_ID_GAME_PIPE_PIC_END = 6,
    COMPO_ID_GAME_FAIL_PIC,
    COMPO_ID_GAME_FINISH_PIC,
    COMPO_ID_GAME_STOP_BTN,
    COMPO_ID_GAME_START_BTN,
    COMPO_ID_GAME_NOTICE,   
};

enum
{
    GAME_STATUS_STOP,
    GAME_STATUS_WAIT_RUN,
    GAME_STATUS_RUNING,
    GAME_STATUS_GAMEOVER,
    GAME_STATUS_FINISH,
    GAME_STATUS_RESULT_WAIT,
};

#define GAME_DOWN_ACC_V                         1                           //向下加速度
#define GAME_UP_ACC_V                           5                           //向上加速度
#define BIRD_X_POS                              (GUI_SCREEN_CENTER_X / 2)   //小鸟图X坐标
#define BIRD_WIDTH                              44
#define BIRD_HEIGHT                             (30)
#define PIPE_SPEED                              3                           //管道移动速度
#define PIPE_X_GAP                              (GUI_SCREEN_CENTER_X + 80)  //管道水平间隔
#define PIPE_Y_GAP                              100                         //管道纵向间隔
#define PIPE_PIC_WIDTH                          50                          //管道图片宽度
#define PIPE_PIC_HEIGHT                         168                         //管道图片高度
#define GAME_VALID_HEIGHT                       280                         //有效界面高度

#define GAME_CARD_WIDTH_ORG            80
#define GAME_CARD_HEIGHT_ORG           50

//计算上管道y坐标(中心参考点)
#define CAL_PIPE_UP_Y_POS(pipe_down_y_pos, pipe_down_cut)    ((pipe_down_y_pos) - (PIPE_PIC_HEIGHT / (pipe_down_cut) / 2) - (PIPE_PIC_HEIGHT / 2) - PIPE_Y_GAP)
//计算下管道y坐标(中心参考点)
#define CAL_PIPE_DOWM_Y_POS(pipe_down_cut)                   (GAME_VALID_HEIGHT - (PIPE_PIC_HEIGHT / (pipe_down_cut)) / 2)


//创建游戏界面
compo_form_t *func_game_form_create(void)
{
    compo_form_t *frm;
    component_t *compo;
    compo_cardbox_t * cardbox;
    uint8_t i;
    uint32_t pipe_bin_addr[] = {UI_BUF_GAME_GAME_PIPE_UP_BIN, UI_BUF_GAME_GAME_PIPE_DOWN_BIN};

    //新建窗体和背景
    frm = compo_form_create(true);

    //背景图
    compo = (component_t *)compo_picturebox_create(frm, UI_BUF_GAME_GAME_BG_BIN);
    compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y);

    //stop pic
    compo = (component_t *)compo_picturebox_create(frm, UI_BUF_GAME_GAME_START_BIN);
    compo_setid(compo, COMPO_ID_GAME_STOP_PIC);
    compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y);

    //bird pic
    compo = (component_t *)compo_picturebox_create(frm, UI_BUF_GAME_GAME_BIRD_BIN);
    compo_setid(compo, COMPO_ID_GAME_BIRD_PIC);
    compo_picturebox_cut((compo_picturebox_t *)compo, 0, 3);
    compo_picturebox_set_pos((compo_picturebox_t *)compo, BIRD_X_POS, GUI_SCREEN_CENTER_Y);
    compo_picturebox_set_visible((compo_picturebox_t *)compo, false);

    //pipe pic
    for(i = 0; i < 4; i++) {
        compo = (component_t *)compo_picturebox_create(frm, pipe_bin_addr[i % 2]);
        compo_setid(compo, COMPO_ID_GAME_PIPE_PIC_START + i);
        compo_picturebox_set_visible((compo_picturebox_t *)compo, false);
    }

    //fail pic

    compo_shape_t *compo_shape =  (compo_shape_t *)compo_radius_shape_create(frm,COMPO_SHAPE_TYPE_ROUNDED_RECTANGLE,20);
    compo_shape_set_color(compo_shape, make_color(128, 128, 128));
    compo_shape_set_alpha(compo_shape,200);
    compo_setid(compo_shape, COMPO_ID_GAME_FAIL_PIC);
    compo_shape_set_location(compo_shape, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y, 220, 140);
    compo_shape_set_visible(compo_shape, false);

    //finish pic
    compo_shape =  compo_radius_shape_create(frm,COMPO_SHAPE_TYPE_ROUNDED_RECTANGLE,20);
    compo_shape_set_color(compo_shape, make_color(128, 128, 128));
    compo_shape_set_alpha(compo_shape,200);
    compo_setid(compo_shape, COMPO_ID_GAME_FINISH_PIC);
    compo_shape_set_location(compo_shape, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y, 220, 140);
    compo_shape_set_visible(compo_shape, false);

    cardbox = compo_cardbox_create(frm, 1, 0, 1, GAME_CARD_WIDTH_ORG, GAME_CARD_HEIGHT_ORG);
    compo_cardbox_set_pos(cardbox, 60, 160+ GAME_CARD_HEIGHT_ORG/2);
    compo_setid(cardbox, COMPO_ID_GAME_STOP_BTN);
    // compo_cardbox_set_alpha(cardbox,48);
    compo_cardbox_rect_set_location(cardbox, 0, 0, 0, GAME_CARD_WIDTH_ORG, GAME_CARD_HEIGHT_ORG, 20);
    compo_cardbox_rect_set_color(cardbox, 0, make_color(48,48,48));
    compo_cardbox_text_set(cardbox, 0, i18n[STR_STOP]);    //语音助手
    compo_cardbox_text_set_location(cardbox, 0, 0, 0 , GAME_CARD_WIDTH_ORG - 16, 30);
    compo_cardbox_text0_scroll_process(cardbox);
    compo_cardbox_set_visible(cardbox, false);

    cardbox = compo_cardbox_create(frm, 1, 0, 1, GAME_CARD_WIDTH_ORG, GAME_CARD_HEIGHT_ORG);
    compo_cardbox_set_pos(cardbox, 180, 160+ GAME_CARD_HEIGHT_ORG/2);
    compo_setid(cardbox, COMPO_ID_GAME_START_BTN);
    // compo_cardbox_set_alpha(cardbox,48);
    compo_cardbox_rect_set_location(cardbox, 0, 0, 0, GAME_CARD_WIDTH_ORG, GAME_CARD_HEIGHT_ORG, 20);
    compo_cardbox_rect_set_color(cardbox, 0, make_color(48,48,48));
    compo_cardbox_text_set(cardbox, 0, i18n[STR_START]);    //语音助手
    compo_cardbox_text_set_location(cardbox, 0, 0, 0 , GAME_CARD_WIDTH_ORG - 16, 30);
    compo_cardbox_text0_scroll_process(cardbox);
    compo_cardbox_set_visible(cardbox, false);


     compo_textbox_t *txt = compo_textbox_create(frm, 300);
     compo_textbox_set_font(txt, UI_BUF_0FONT_FONT_BIN);  
     compo_setid(txt, COMPO_ID_GAME_NOTICE);      
     compo_textbox_set_location(txt, GUI_SCREEN_CENTER_X, 110, 220, 20);       
     compo_textbox_set_visible(txt,false);
     return frm;
}


//游戏初始化
static void func_game_init(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    compo_picturebox_t *compo;
    compo_shape_t *compo_shape;
    uint8_t i;

    compo_shape = compo_getobj_byid(COMPO_ID_GAME_FAIL_PIC);
    if(compo_shape) {
        compo_shape_set_visible(compo_shape, false);
    }

    compo_shape = compo_getobj_byid(COMPO_ID_GAME_FINISH_PIC);
    if(compo_shape) {
        compo_shape_set_visible(compo_shape, false);
    }

    compo = compo_getobj_byid(COMPO_ID_GAME_STOP_PIC);
    if(compo) {
        compo_picturebox_set_visible(compo, true);
    }

    compo = compo_getobj_byid(COMPO_ID_GAME_BIRD_PIC);
    if(compo) {
        compo_picturebox_set_visible(compo, false);
        compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X / 2, GUI_SCREEN_CENTER_Y);
    }

    game->pipe_cut = 1;
    for(i = 0; i < 4; i++) {
        if(!(i % 2)) {
            compo = compo_getobj_byid(COMPO_ID_GAME_PIPE_PIC_START + i);
            if(compo) {
                compo_picturebox_cut((compo_picturebox_t *)compo, 0, game->pipe_cut + i/2);
            }
        }
    }
    compo_cardbox_t *compo_button = compo_getobj_byid(COMPO_ID_GAME_STOP_BTN);
    if(compo_button) {
        compo_cardbox_set_visible(compo_button, false);
    }

    compo_button = compo_getobj_byid(COMPO_ID_GAME_START_BTN);
    if(compo_button) {
        compo_cardbox_set_visible(compo_button, false);
    }


    game->bird_anim_cnt = 0;
    game->speed = 0;
    game->tick = tick_get();
    game->bird_y_pos = GUI_SCREEN_CENTER_Y;
    game->pipe_index = 0;
    game->pipe_x_pos = GUI_SCREEN_WIDTH + GUI_SCREEN_CENTER_X;
    game->pipe_y_pos = CAL_PIPE_DOWM_Y_POS(game->pipe_cut);
    game->status = GAME_STATUS_WAIT_RUN;
}


//游戏中
static void func_game_runing(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    compo_picturebox_t *compo;
    uint8_t i;
    uint16_t id;
    s16  x_pos, y_pos;
    uint8_t pipe_cut;
    s16 diff;

    if (tick_check_expire(game->tick, 1000 / 24)) //24hz
    {
        //bird pic refresh
        game->tick = tick_get();
        game->bird_y_pos += game->speed;
        game->speed += GAME_DOWN_ACC_V;
        if(game->bird_y_pos >= GUI_SCREEN_HEIGHT) {
            game->status = GAME_STATUS_GAMEOVER;
        } 
        
        if(game->bird_y_pos <=  BIRD_HEIGHT/2) {
            game->bird_y_pos = BIRD_HEIGHT/2;
        }
        printf("game->bird_y_pos = %d\n",game->bird_y_pos);
        compo = compo_getobj_byid(COMPO_ID_GAME_BIRD_PIC);
        if(compo) {
            compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X / 2, game->bird_y_pos);
            compo_picturebox_cut((compo_picturebox_t *)compo, game->bird_anim_cnt, 3);
            game->bird_anim_cnt ++;
            game->bird_anim_cnt %= 3;
        }

        //pipe pic refresh
        x_pos = game->pipe_x_pos;
        y_pos = game->pipe_y_pos;
        pipe_cut = game->pipe_cut;

        for (i = 0; i < 4; i++) {
            id = COMPO_ID_GAME_PIPE_PIC_START + (game->pipe_index + i) % 4;
            compo = compo_getobj_byid(id);
            if(compo) {
                if(i % 2) {
                    y_pos = CAL_PIPE_UP_Y_POS(y_pos, pipe_cut);
                }
                if(i == 2) {
                    x_pos += PIPE_X_GAP;
                    pipe_cut = 1 + (pipe_cut + 1) % 3;
                    y_pos = CAL_PIPE_DOWM_Y_POS(pipe_cut);
                }
                compo_picturebox_set_pos((compo_picturebox_t *)compo, x_pos, y_pos);
            }
        }
        if(game->pipe_x_pos > (-PIPE_PIC_WIDTH / 2)) {

            //碰撞检测
            if ((game->pipe_x_pos + PIPE_PIC_WIDTH / 2) >= (BIRD_X_POS - BIRD_WIDTH / 2)) {
                diff = (game->pipe_x_pos - PIPE_PIC_WIDTH / 2) - (BIRD_X_POS + BIRD_WIDTH / 2);
                if(diff <= 0) {
                    y_pos = CAL_PIPE_DOWM_Y_POS(game->pipe_cut);
                    if((y_pos - PIPE_PIC_HEIGHT / game->pipe_cut / 2) <= (game->bird_y_pos + BIRD_HEIGHT / 2)) {
                        game->status = GAME_STATUS_GAMEOVER;
                    }
                    y_pos = CAL_PIPE_UP_Y_POS(y_pos, game->pipe_cut);
                    if((y_pos + PIPE_PIC_HEIGHT / 2) >= (game->bird_y_pos - BIRD_HEIGHT / 2)) {
                        game->status = GAME_STATUS_GAMEOVER;
                    }
                }
            }
            else {  //下一管道
                diff = ((game->pipe_x_pos + PIPE_X_GAP) - PIPE_PIC_WIDTH / 2) - (BIRD_X_POS + BIRD_WIDTH / 2);
                if (diff <= 0) {
                    y_pos = CAL_PIPE_DOWM_Y_POS(pipe_cut);
                    if((y_pos - PIPE_PIC_HEIGHT / pipe_cut / 2) <= (game->bird_y_pos + BIRD_HEIGHT / 2)) {
                        game->status = GAME_STATUS_GAMEOVER;
                    }
                    y_pos = CAL_PIPE_UP_Y_POS(y_pos, pipe_cut);
                    if((y_pos + PIPE_PIC_HEIGHT / 2) >= (game->bird_y_pos - BIRD_HEIGHT / 2)) {
                        game->status = GAME_STATUS_GAMEOVER;
                    }
                }
            }

            if(diff > 0 && diff < PIPE_SPEED) {
                game->pipe_x_pos -= diff;
            } else {
                game->pipe_x_pos -= PIPE_SPEED;
            }

        } else {
            //前管道视野消失，位置切换至下一个管道
            game->pipe_x_pos = x_pos;
            game->pipe_y_pos = CAL_PIPE_DOWM_Y_POS(pipe_cut);
            game->pipe_cut = pipe_cut;

            if (game->pipe_index) {
                game->pipe_index = 0;
            } else {
                game->pipe_index = 2;
            }

            id = COMPO_ID_GAME_PIPE_PIC_START + (game->pipe_index + 2) % 4;
            compo = compo_getobj_byid(id);
            if(compo) {
                compo_picturebox_cut((compo_picturebox_t *)compo, 0, 1 + (pipe_cut + 1) % 3);
            }
        }
    }
}


//游戏失败
static void func_game_fail(void)
{
    compo_picturebox_t *compo;

    uint8_t i;

    compo_shape_t *compo_shape  = compo_getobj_byid(COMPO_ID_GAME_FAIL_PIC);
    if(compo_shape) {
        compo_shape_set_visible(compo_shape, true);
    }

    compo_cardbox_t *compo_button = compo_getobj_byid(COMPO_ID_GAME_STOP_BTN);
    if(compo_button) {
        compo_cardbox_set_visible(compo_button, true);
    }

    compo_button = compo_getobj_byid(COMPO_ID_GAME_START_BTN);
    if(compo_button) {
        compo_cardbox_set_visible(compo_button, true);
    }


    compo_textbox_t *txt  = compo_getobj_byid(COMPO_ID_GAME_NOTICE);
    if(txt) {
        compo_textbox_set(txt, i18n[STR_GAME_OVER]);
        compo_textbox_set_visible(txt, true);
    }  

    compo = compo_getobj_byid(COMPO_ID_GAME_BIRD_PIC);
    if(compo) {
        compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y - 130);
    }

    for(i = 0; i < 4; i++) {
        compo = compo_getobj_byid(COMPO_ID_GAME_PIPE_PIC_START + i);
        if(compo) {
            compo_picturebox_set_visible(compo, false);
        }
    }
}


//游戏成功
static void func_game_finish(void)
{
    compo_picturebox_t *compo;
    uint8_t i;

    compo_shape_t *compo_shape = compo_getobj_byid(COMPO_ID_GAME_FINISH_PIC);
    if(compo_shape) {
        compo_shape_set_visible(compo_shape, true);
    }

    compo_shape = compo_getobj_byid(COMPO_ID_GAME_FINISH_PIC);
    if(compo_shape) {
        compo_shape_set_visible(compo_shape, true);
    }

    compo_cardbox_t *compo_button = compo_getobj_byid(COMPO_ID_GAME_STOP_BTN);
    if(compo_button) {
        compo_cardbox_set_visible(compo_button, true);
    }

    compo_button = compo_getobj_byid(COMPO_ID_GAME_START_BTN);
    if(compo_button) {
        compo_cardbox_set_visible(compo_button, true);
    }

    compo_textbox_t *txt  = compo_getobj_byid(COMPO_ID_GAME_NOTICE);
    if(txt) {
        compo_textbox_set(txt, i18n[STR_GAME_OVER]); //STR_GAME_PASS
        compo_textbox_set_visible(txt, true);
    }  

    compo = compo_getobj_byid(COMPO_ID_GAME_BIRD_PIC);
    if(compo) {
        compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y - 100);
    }

    for(i = 0; i < 4; i++) {
        compo = compo_getobj_byid(COMPO_ID_GAME_PIPE_PIC_START + i);
        if(compo) {
            compo_picturebox_set_visible(compo, false);
        }
    }
}


//游戏过程状态机
static void func_game_process(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;

    switch (game->status)
    {
        case GAME_STATUS_WAIT_RUN:
        case GAME_STATUS_RESULT_WAIT:
            break;

        case GAME_STATUS_STOP:
            func_game_init();
            game->status = GAME_STATUS_WAIT_RUN;
            break;

        case GAME_STATUS_RUNING:
            func_game_runing();
            break;

        case GAME_STATUS_GAMEOVER:
            func_game_fail();
            game->status = GAME_STATUS_RESULT_WAIT;
            break;

        case GAME_STATUS_FINISH:
            func_game_finish();
            game->status = GAME_STATUS_RESULT_WAIT;
            break;

        default:
            break;
    }
}


//单击处理
static void func_game_click(void)
{
    int btn_id = compo_get_button_id();
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    compo_picturebox_t *compo;
    uint8_t i;
    compo_textbox_t *txt  = compo_getobj_byid(COMPO_ID_GAME_NOTICE);

    point_t pt = ctp_get_sxy();
    for(u8 i= COMPO_ID_GAME_STOP_BTN; i<= COMPO_ID_GAME_START_BTN; i++) {
        if (compo_cardbox_btn_is(compo_getobj_byid(i), pt)) {
            btn_id = i;
        }
    }   

    printf("func_game_click = %d %d\n",game->status,btn_id);
    if (GAME_STATUS_WAIT_RUN == game->status) {
        compo = compo_getobj_byid(COMPO_ID_GAME_STOP_PIC);
        if(compo) {
            compo_picturebox_set_visible(compo, false);
        }

        if(txt) {
            compo_textbox_set_visible(txt, false);
        }

        compo = compo_getobj_byid(COMPO_ID_GAME_BIRD_PIC);
        if(compo) {
            compo_picturebox_set_visible(compo, true);
        }

        for(i = 0; i < 4; i++) {
            compo = compo_getobj_byid(i + COMPO_ID_GAME_PIPE_PIC_START);
            if(compo) {
                compo_picturebox_set_visible(compo, true);
            }
        }

        game->status = GAME_STATUS_RUNING;

    } else if (GAME_STATUS_RUNING == game->status) {
        if(txt) {
            compo_textbox_set_visible(txt, false);
        }

        if(game->bird_y_pos <= BIRD_HEIGHT/2) {
            game->speed = 0;
        } else {
            if(game->speed > 0) {
                game->speed = -GAME_UP_ACC_V;
            } else {
                game->speed -= GAME_UP_ACC_V;
            }
        }
    } else if (GAME_STATUS_RESULT_WAIT == game->status) {
        if (COMPO_ID_GAME_STOP_BTN == btn_id) {
            game->status = GAME_STATUS_STOP;

            if(txt) {
            compo_textbox_set_visible(txt, false);
            }
        } else if (COMPO_ID_GAME_START_BTN == btn_id) {
            func_game_init();

            compo = compo_getobj_byid(COMPO_ID_GAME_STOP_PIC);
            if(compo) {
                compo_picturebox_set_visible(compo, false);
            }

            if(txt) {
                compo_textbox_set_visible(txt, false);
            }

            compo = compo_getobj_byid(COMPO_ID_GAME_BIRD_PIC);
            if(compo) {
                compo_picturebox_set_visible(compo, true);
            }

            for(i = 0; i < 4; i++) {
                compo = compo_getobj_byid(i + COMPO_ID_GAME_PIPE_PIC_START);
                if(compo) {
                    compo_picturebox_set_visible(compo, true);
                }
            }
			delay_ms(40);
            game->status = GAME_STATUS_RUNING;
        }
    }
}


//消息处理
static void func_game_message(size_msg_t msg)
{
    switch (msg) {
    case MSG_CTP_CLICK:
        func_game_click();
        break;

    case MSG_CTP_SHORT_UP:
    case MSG_CTP_SHORT_DOWN:
        break;

    case MSG_CTP_SHORT_LEFT:
        if (func_cb.flag_sort) {
            func_message(msg);
        }
        break;


    case MSG_CTP_LONG:
        break;

    default:
        func_message(msg);
        break;
    }
}


//进入游戏功能
static void func_game_enter(void)
{
    func_cb.f_cb = func_zalloc(sizeof(f_game_t));
    func_cb.frm_main = func_game_form_create();
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    game->status = GAME_STATUS_STOP;
}


//退出游戏功能
static void func_game_exit(void)
{
    func_cb.last = FUNC_GAME;
}


//游戏功能
void func_game(void)
{
    printf("%s\n", __func__);
    func_game_enter();
    while (func_cb.sta == FUNC_GAME) {
        func_game_process();
        func_process();
        func_game_message(msg_dequeue());
    }
    func_game_exit();
}
#else
#define CENTER_X(w)                             ((GUI_SCREEN_WIDTH - w) >> 1)
#define GAME_ABS(x)                             ((x) > 0 ? (x) : (-(x)))

#define LEVEL_ICO_X                             40 // 92
#define LEVEL_ICO_Y                             4  // 18
#define LEVEL_X                                 (LEVEL_ICO_X + 30)
#define LEVEL_Y                                 (LEVEL_ICO_Y + 6)

#define SCORE_ICO_X                             (LEVEL_X + 40)
#define SCORE_ICO_Y                             LEVEL_ICO_Y
#define SCORE_X                                 (SCORE_ICO_X + 30)
#define SCORE_Y                                 (LEVEL_Y)

#define DLG_BG_CX                               130
#define DLG_BG_X                                CENTER_X(DLG_BG_CX)
#define DLG_BG_Y                                120

#define PASS_LABLE_X                            CENTER_X(49)
#define PASS_LABLE_Y                            (DLG_BG_Y + 15)

#define PASS_DLG_BTN_CX                         84
#define PASS_DLG_BTN_CY                         28

#define PASS_DLG_BTN_START_X                    CENTER_X(PASS_DLG_BTN_CX)
#define PASS_DLG_BTN_START_Y                    (PASS_LABLE_Y + 28)

#define PASS_DLG_BTN_END_X                      (PASS_DLG_BTN_START_X + PASS_DLG_BTN_CX)
#define PASS_DLG_BTN_END_Y                      (PASS_DLG_BTN_START_Y + PASS_DLG_BTN_CY)

#define PASS_ALL_LABLE_X                        CENTER_X(115)
#define PASS_ALL_LABLE_Y                        PASS_LABLE_Y

#define GAME_OVER_LABLE_X                       CENTER_X(100)
#define GAME_OVER_LABLE_Y                       PASS_LABLE_Y

#define GAME_OVER_BTN_OK_CX                     64
#define GAME_OVER_BTN_OK_CY                     28

#define BTN_OK_START_X                          CENTER_X(64)
#define BTN_OK_START_Y                          PASS_DLG_BTN_START_Y

#define NORMAL_BARRIER                          0x00
#define RLS_UP_BARRIER                          0x10  /*释放上面的障碍物*/
#define RLS_DOWN_BARRIER                        0x20  /*释放下面的障碍物*/
#define RLS_UPDOWN_BARRIER                      0x30  /*释放上面和下面的障碍物*/

#define BARRIER_TYPE_NUM                        BARRIER_UP_DOWN

#define RESOURCE_CX                             32
#define RESOURCE_CY                             32
#define BARRIER_1_CX                            26
#define BARRIER_1_CY                            26

#define BIRD_FLY_V                              12 /*小鸟向上飞行初速度*/
#define BIRD_FALL_G                             2  /*小鸟向下掉的重力加速度*/

#define BIRDFLY_ZOOM_X                          0
#define BIRDFLY_ZOOM_Y                          30
#define BIRDFLY_ZOOM_CX                         240
#define BIRDFLY_ZOOM_CY                         264

#define BIRDFLY_GROUND_HEIGHT                   0 // 地面高度

#define BIRD_VALID_STARTX                       2
#define BIRD_VALID_STARTY                       16

#define BIRD_VALID_ENDX                         62
#define BIRD_VALID_ENDY                         46

#define BIRD_VALID_WIDTH                        (BIRD_VALID_ENDX - BIRD_VALID_STARTX)
#define BIRD_VALID_HEIGHT                       (BIRD_VALID_ENDY - BIRD_VALID_STARTY)

#define BIRD_WIDTH                              54
#define BIRD_HEIGHT                             54

#define HIT_WIDTH                               59
#define HIT_HEIGHT                              59
#define START_LBL_HEIGHT                        15

#define MAX_RESOURCE_DATA_NUM                   10  /* 资源数据个数*/
#define MAX_BARRIER_DATA_NUM                    4   /* 障碍物数据个数*/

#define MAX_BARRIER_NUM                         4   /* 最多障碍物块个数 */
#define SCORE_MAX_NUM                           4   /* 得分最多位数 */

#define BIRDFLY_ANI_TIME_GAP                    40
#define BIRDFLY_TIME_GAP                        80
#define QUICKFLY_TIMEOUT_TIME                   5000 // 快速飞5秒
#define RLS_BARRIER_TIMEOUT_TIME                5000

#define INIT_MAKE_BARRIER_TIME                  60
#define INIT_MAKE_RESOURCE_RAND_MAX_NUM         360

#define DIGIT_CX 14

enum
{
    LEVENT_NULL,
    LEVENT_READY,
    LEVENT_BIRD_FLYING_ON,       //  向上飞
    LEVENT_BIRD_GLIDING,         //  滑翔模式
    LEVENT_BIRD_QUICK_RIGHT_FLY, //  快速右飞
    LEVENT_BIRD_DIE_FALLDOWN,    //	小鸟被撞死

    LEVENT_GAMEOVER_DLG,
};

enum
{
    RES_NULL,
    RES_GOLD,
    RES_UP,
    RES_DOWN,
    RES_UP_DOWN,
    RES_RIGHT,
    RES_LIFE,
    RES_DEATH
};

enum
{
    BARRIER_NULL,
    BARRIER_UP,
    BARRIER_DOWN,
    BARRIER_UP_DOWN
};

typedef struct Bird_st
{
    short x;  // 该小鸟x坐标
    short y;  // 该小鸟y坐标
    short cx; // 该飞机图标的宽度
    short cy; // 该飞机图标的高度
    u8 idx;
    u8 flag; // 为0表示不显示任何图标, 即无数据
    u8 reserved[2];
} Bird_t;

typedef struct Resource_st
{
    short x;  // 该资源x坐标
    short y;  // 该资源y坐标
    short cx; // 该资源图标的宽度
    short cy; // 该资源图标的高度
    u8 idx;
    u8 attrib; // 资源属性: 0: 无资源; 1:金币; 2: UP; 3:DOWN; 4: UP_DOWN; 5: RIGHT; 6: LIFE;  7: DEATH;
    u8 reserved[2];
} Resource_t;

typedef struct Barrier_st
{
    short x;        // 该障碍物x坐标
    short cx;       // 该障碍物宽度
    short cy;       // 该障碍物高度
    u8 attrib;      // 障碍物属性, 0:表示无障碍物
    u8 num;         //
    u8 reserved[3]; //
} Barrier_t;

typedef struct f_game_t_
{
    /* 游戏运行参数 */
    Bird_t *pBird;
    Bird_t *pBirdHit;
    Barrier_t *pBarrier;
    Resource_t *pResource;

    u8 bird_num;            // 剩余小鸟个数
    u8 gold_spin_idx;
    u8 BirdFly_status;
    u8 Barrier_status;
    bool has_to_redraw;

    short bird_y_speed;     // 小鸟速度, >0: 向上飞; <0: 向下掉
    u16 make_barrier_time;
    u16 make_resource_max_rand;

    u32 x_offset;
    u32 game_score;

    /* 游戏运行任务*/
    bool bird_fly_task_flag;
    bool animation_task_flag;
    bool quick_fly_task_flag;
    bool rls_barrier_task_flag;

    u32 bird_fly_task_tick;
    u32 animation_task_tick;
    u32 quick_fly_task_tick;
    u32 rls_barrier_task_tick;
} f_game_t;

enum
{
    COMPO_ID_GAME_PIC_BG = 0x01,
    COMPO_ID_GAME_PIC_BIRD,
    COMPO_ID_GAME_PIC_START,
    COMPO_ID_GAME_PIC_START_TIP,

    /* 障碍物 */
    COMPO_ID_GAME_PIC_BARRIER,
    COMPO_ID_GAME_PIC_BARRIER_MAX = COMPO_ID_GAME_PIC_BARRIER + (MAX_BARRIER_NUM * MAX_BARRIER_DATA_NUM * 2),

    /* 资源 */
    COMPO_ID_GAME_RESOURCE_PIC,
    COMPO_ID_GAME_RESOURCE_PIC_MAX = COMPO_ID_GAME_RESOURCE_PIC + MAX_RESOURCE_DATA_NUM,

    /* 小鸟生命 */
    COMPO_ID_GAME_PIC_BIRD_LIFE,
    COMPO_ID_GAME_PIC_BIRD_LIFE_MAX = COMPO_ID_GAME_PIC_BIRD_LIFE + SCORE_MAX_NUM,

    /* 得分 */
    COMPO_ID_GAME_PIC_SCORE,
    COMPO_ID_GAME_PIC_SCORE_MAX = COMPO_ID_GAME_PIC_SCORE + SCORE_MAX_NUM,

    /* 击中 */
    COMPO_ID_GAME_PIC_BOOM,

    /* 游戏结束 */
    COMPO_ID_GAME_PIC_DLG_BG,
    COMPO_ID_GAME_PIC_GAME_OVER,
    COMPO_ID_GAME_PIC_GAME_OK,
};

static const u32 Flying_Bird_Pic_arr[] = {
    UI_BUF_GAME_BIRD_FLY0_BIN,
    UI_BUF_GAME_BIRD_FLY1_BIN,
    UI_BUF_GAME_BIRD_FLY2_BIN,
    UI_BUF_GAME_BIRD_FLY3_BIN,
    UI_BUF_GAME_BIRD_FLY4_BIN};

static const u32 Hit_Bird_Boom_pic_arr[] = {
    UI_BUF_GAME_HIT_0_BIN,
    UI_BUF_GAME_HIT_1_BIN,
    UI_BUF_GAME_HIT_2_BIN,
    UI_BUF_GAME_HIT_3_BIN,
    UI_BUF_GAME_HIT_4_BIN,
    UI_BUF_GAME_HIT_5_BIN};

static const u32 Death_Bird_Fall_pic_arr[] = {
    UI_BUF_GAME_BIRD_FALL0_BIN,
    UI_BUF_GAME_BIRD_FALL1_BIN,
    UI_BUF_GAME_BIRD_FALL2_BIN,
    UI_BUF_GAME_BIRD_FALL3_BIN,
    UI_BUF_GAME_BIRD_FALL4_BIN,
    UI_BUF_GAME_BIRD_FALL5_BIN,
    UI_BUF_GAME_BIRD_FALL6_BIN,
    UI_BUF_GAME_BIRD_FALL7_BIN,
    UI_BUF_GAME_BIRD_FALL8_BIN,
    UI_BUF_GAME_BIRD_FALL9_BIN,
};

static const u32 gold_pic_arr[] = {
    UI_BUF_GAME_GOLD_0_BIN,
    UI_BUF_GAME_GOLD_1_BIN,
    UI_BUF_GAME_GOLD_2_BIN,
    UI_BUF_GAME_GOLD_3_BIN,
    UI_BUF_GAME_GOLD_4_BIN,
    UI_BUF_GAME_GOLD_5_BIN,
    UI_BUF_GAME_GOLD_6_BIN,
    UI_BUF_GAME_GOLD_7_BIN,
};

static const u32 digit_id_arr[] = {
    UI_BUF_GAME_GAME_DIGIT_0_BIN,
    UI_BUF_GAME_GAME_DIGIT_1_BIN,
    UI_BUF_GAME_GAME_DIGIT_2_BIN,
    UI_BUF_GAME_GAME_DIGIT_3_BIN,
    UI_BUF_GAME_GAME_DIGIT_4_BIN,
    UI_BUF_GAME_GAME_DIGIT_5_BIN,
    UI_BUF_GAME_GAME_DIGIT_6_BIN,
    UI_BUF_GAME_GAME_DIGIT_7_BIN,
    UI_BUF_GAME_GAME_DIGIT_8_BIN,
    UI_BUF_GAME_GAME_DIGIT_9_BIN,
};

void tjd_show_game_over_dlg(void)
{
    compo_button_t *dlg_bg_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_DLG_BG);
    compo_picturebox_t *game_over_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_GAME_OVER);
    compo_picturebox_t *game_ok_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_GAME_OK);

    compo_button_set_visible(dlg_bg_pic, true);
    compo_picturebox_set_visible(game_over_pic, true);
    compo_picturebox_set_visible(game_ok_pic, true);
}

static void tjd_malloc_bird_fly_buffer(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    if (!game->pBird)
    {
        game->pBird = func_zalloc(sizeof(Bird_t));
    }
    if (!game->pBirdHit)
    {
        game->pBirdHit = func_zalloc(sizeof(Bird_t));
    }

    if (!game->pResource)
    {
        game->pResource = func_zalloc(sizeof(Resource_t) * MAX_RESOURCE_DATA_NUM);
    }
    if (!game->pBarrier)
    {
        game->pBarrier = func_zalloc(sizeof(Barrier_t) * MAX_BARRIER_DATA_NUM);
    }
}

static void tjd_free_bird_fly_buffer(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    if (game->pBird)
    {
        func_free(game->pBird);
        game->pBird = NULL;
    }
    if (game->pBirdHit)
    {
        func_free(game->pBirdHit);
        game->pBirdHit = NULL;
    }
    if (game->pResource)
    {
        func_free(game->pResource);
        game->pResource = NULL;
    }
    if (game->pBarrier)
    {
        func_free(game->pBarrier);
        game->pBarrier = NULL;
    }
}

static void tjd_init_birdfly_data(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->x_offset = 0;
    game->bird_y_speed = 0; // 小鸟速度, >0: 向上飞; <0: 向下掉

    game->pBird->x = BIRDFLY_ZOOM_X + CENTER_X(BIRD_WIDTH);
    game->pBird->y = BIRDFLY_ZOOM_Y + ((BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT - BIRD_HEIGHT) >> 1);
    game->pBird->cx = BIRD_VALID_WIDTH;
    game->pBird->cy = BIRD_VALID_HEIGHT;
    game->pBird->idx = 4;
    game->pBird->flag = 1;
}

void tjd_ready_birdfly(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->has_to_redraw = TRUE;

    tjd_init_birdfly_data();

    memset(game->pBirdHit, 0, sizeof(Bird_t));
    memset(game->pResource, 0, sizeof(Resource_t) * MAX_RESOURCE_DATA_NUM);
    memset(game->pBarrier, 0, sizeof(Barrier_t) * MAX_BARRIER_DATA_NUM);

    game->BirdFly_status = LEVENT_READY;
}

void tjd_reset_birdfly(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->has_to_redraw = TRUE;
    game->game_score = 0;
    game->bird_num = 1; // 剩余小鸟个数
    game->make_barrier_time = INIT_MAKE_BARRIER_TIME;
    game->make_resource_max_rand = INIT_MAKE_RESOURCE_RAND_MAX_NUM;

    tjd_init_birdfly_data();
    memset(game->pBirdHit, 0, sizeof(Bird_t));
    memset(game->pResource, 0, sizeof(Resource_t) * MAX_RESOURCE_DATA_NUM);
    memset(game->pBarrier, 0, sizeof(Barrier_t) * MAX_BARRIER_DATA_NUM);

    game->BirdFly_status = LEVENT_READY;
}

static void tjd_birdfly_start_play(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->bird_fly_task_flag = true;

    game->animation_task_flag = true;
}

void tjd_birdfly_stop(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->bird_fly_task_flag = false;

    game->animation_task_flag = false;

    game->quick_fly_task_flag = false;

    game->rls_barrier_task_flag = false;
}

static void tjd_change_all_resource_to_gold(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    u16 i;
    Resource_t *pRes;

    for (i = 0; i < MAX_RESOURCE_DATA_NUM; i++)
    {
        pRes = game->pResource + i;
        if (pRes->attrib)
        {
            pRes->attrib = RES_GOLD;
        }
    }
}

static void tjd_end_rls_barrier_mode(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    printf("<<<<<<< NORMAL_BARRIER >>>>>>>>>>");
    game->rls_barrier_task_flag = false;
    game->Barrier_status = NORMAL_BARRIER;
}

static void set_rls_barrier_mode(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->rls_barrier_task_flag = true;
    game->rls_barrier_task_tick = tick_get();
}

static void tjd_end_quick_fly_mode(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->quick_fly_task_flag = false;
    game->Barrier_status = NORMAL_BARRIER;
    game->BirdFly_status = LEVENT_BIRD_GLIDING;
}

static void set_quick_fly_mode(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->quick_fly_task_tick = tick_get();
    game->quick_fly_task_flag = true;
}

static void tjd_bird_die(Bird_t *pBird)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    if (game->bird_num > 0)
    {
        game->bird_num--;
    }

    game->pBirdHit->x = pBird->x + (BIRD_WIDTH >> 1) - (HIT_WIDTH >> 1);
    game->pBirdHit->y = pBird->y + (BIRD_HEIGHT >> 1) - (HIT_HEIGHT >> 1);

    game->pBirdHit->cx = HIT_WIDTH;
    game->pBirdHit->cy = HIT_HEIGHT;
    game->pBirdHit->idx = 0;
    game->pBirdHit->flag = 1;
}

// 检查小鸟是否得到资源
static bool tjd_check_bird_get_resource(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    u16 i;
    long x1, x2, y1, y2, xd, yd;
    short delta_x, delta_y;
    Resource_t *pRes;

    x1 = game->pBird->x + (BIRD_WIDTH >> 1);
    y1 = game->pBird->y + (BIRD_HEIGHT >> 1);
    for (i = 0; i < MAX_RESOURCE_DATA_NUM; i++)
    {
        pRes = game->pResource + i;
        if (pRes->attrib)
        {
            x2 = pRes->x + (pRes->cx >> 1);
            y2 = pRes->y + (pRes->cy >> 1);
            xd = ((BIRD_VALID_WIDTH + RESOURCE_CX) >> 1) - 4;
            yd = ((BIRD_VALID_HEIGHT + RESOURCE_CY) >> 1) - 2;
            delta_x = GAME_ABS(x1 - x2);
            delta_y = GAME_ABS(y1 - y2);
            if (delta_x < xd && delta_y < yd)
            {
                // Get到资源
                if (pRes->attrib == RES_GOLD)
                {
                    game->game_score += 1;
                }
                else if (pRes->attrib == RES_UP)
                {
                    if (game->Barrier_status == NORMAL_BARRIER)
                    {
                        set_rls_barrier_mode();
                        game->Barrier_status = RLS_UP_BARRIER;
                    }
                }
                else if (pRes->attrib == RES_DOWN)
                {
                    if (game->Barrier_status == NORMAL_BARRIER)
                    {
                        set_rls_barrier_mode();
                        game->Barrier_status = RLS_DOWN_BARRIER;
                    }
                }
                else if (pRes->attrib == RES_UP_DOWN)
                {
                    if (game->Barrier_status == NORMAL_BARRIER)
                    {
                        set_rls_barrier_mode();
                        game->Barrier_status = RLS_UPDOWN_BARRIER;
                    }
                }
                else if (pRes->attrib == RES_RIGHT)
                {
                    game->BirdFly_status = LEVENT_BIRD_QUICK_RIGHT_FLY;
                    game->Barrier_status = RLS_UPDOWN_BARRIER;
                    tjd_change_all_resource_to_gold();
                    game->pBird->y = BIRDFLY_ZOOM_Y + (BIRDFLY_ZOOM_CY >> 1) - (BIRD_HEIGHT >> 1);
                    game->pBird->idx = 4; // 展翅的图片
                    set_quick_fly_mode();
                }
                else if (pRes->attrib == RES_LIFE)
                {
                    game->bird_num += 1;
                }
                else if (pRes->attrib == RES_DEATH)
                {
                    game->BirdFly_status = LEVENT_BIRD_DIE_FALLDOWN;
                    game->pBird->idx = 0;
                    game->bird_y_speed = 0;
                    tjd_bird_die(game->pBird);
                }
                pRes->attrib = 0;
            }
        }
    }
    return TRUE;
}

#define X_DEVIATION 2
#define Y_DEVIATION 2

// 检查小鸟是否撞到障碍物
static bool tjd_check_bird_ram_barrier(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    u16 i;
    long x1, x2, xd, yd, y1, y2;
    Barrier_t *pBarrier;
    if (LEVENT_BIRD_FLYING_ON != game->BirdFly_status           // 正常飞翔模式
        && LEVENT_BIRD_GLIDING != game->BirdFly_status          //  滑翔模式
        && LEVENT_BIRD_QUICK_RIGHT_FLY != game->BirdFly_status) //  快速右飞
    {
        return FALSE;
    }

    x1 = game->pBird->x + (BIRD_WIDTH >> 1);
    y1 = game->pBird->y + (BIRD_HEIGHT >> 1);
    for (i = 0; i < MAX_BARRIER_DATA_NUM; i++)
    {
        pBarrier = game->pBarrier + i;

        if (pBarrier->attrib == BARRIER_UP)
        {
            if ((game->Barrier_status != RLS_UP_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
            {
                x2 = pBarrier->x + (pBarrier->cx >> 1);
                xd = ((BIRD_VALID_WIDTH + pBarrier->cx) >> 1) - X_DEVIATION;
                if (GAME_ABS(x1 - x2) < xd)
                {
                    y2 = BIRDFLY_ZOOM_Y + pBarrier->cy * pBarrier->num;
                    yd = GAME_ABS(y1 - y2) - Y_DEVIATION;
                    // if (yd <= (BIRD_VALID_HEIGHT>>1))
                    if (game->pBird->y <= y2)
                    {
                        // 撞击到上边沿

                        game->BirdFly_status = LEVENT_BIRD_DIE_FALLDOWN;
                        game->pBird->idx = 0;
                        game->bird_y_speed = 0;
                        tjd_bird_die(game->pBird);
                        printf("BIRD RAM A \n x1:%d, y1:%d, x2:%d, y2:%d, xd:%d, yd:%d\n", x1, y1, x2, y2, xd, yd);
                        if (game->pBird->x + (BIRD_WIDTH >> 1) < pBarrier->x)
                        {
                            game->pBird->x -= 6;
                        }
                        return FALSE;
                    }
                }
            }
        }
        else if (pBarrier->attrib == BARRIER_DOWN)
        {
            if ((game->Barrier_status != RLS_DOWN_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
            {
                x2 = pBarrier->x + (pBarrier->cx >> 1);
                xd = ((BIRD_VALID_WIDTH + pBarrier->cx) >> 1) - X_DEVIATION;
                if (GAME_ABS(x1 - x2) < xd)
                {
                    y2 = BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - pBarrier->cy * pBarrier->num;
                    yd = GAME_ABS(y1 - y2) - Y_DEVIATION;
                    if ((y1 + (BIRD_VALID_HEIGHT >> 1)) >= y2) //(yd <= (BIRD_VALID_HEIGHT>>1))
                    {
                        // 撞击到下边沿
                        game->BirdFly_status = LEVENT_BIRD_DIE_FALLDOWN;
                        game->pBird->idx = 0;
                        game->bird_y_speed = 0;
                        tjd_bird_die(game->pBird);
                        printf("BIRD RAM B x1:%d, y1:%d, x2:%d, y2:%d, xd:%d, yd:%d, num:%d\n", x1, y1, x2, y2, xd, yd, pBarrier->num);
                        if (game->pBird->x + (BIRD_VALID_WIDTH >> 1) > pBarrier->x)
                        {
                            game->pBird->x = pBarrier->x + pBarrier->cx;
                        }
                        else
                        {
                            game->pBird->x -= 6;
                        }

                        return FALSE;
                    }
                }
            }
        }
        else if (pBarrier->attrib == BARRIER_UP_DOWN)
        {
            x2 = pBarrier->x + (pBarrier->cx >> 1);
            xd = ((BIRD_VALID_WIDTH + pBarrier->cx) >> 1) - X_DEVIATION;
            if (GAME_ABS(x1 - x2) < xd)
            {
                if ((game->Barrier_status != RLS_UP_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
                {
                    y2 = BIRDFLY_ZOOM_Y + pBarrier->cy * pBarrier->num - Y_DEVIATION;
                    yd = GAME_ABS(y1 - y2) - Y_DEVIATION;
                    if ((y1 - (BIRD_VALID_HEIGHT >> 1)) <= y2) //(yd <= (BIRD_VALID_HEIGHT>>1))
                    {
                        // 撞击到上边沿
                        game->BirdFly_status = LEVENT_BIRD_DIE_FALLDOWN;
                        game->bird_y_speed = 0;
                        game->pBird->idx = 0;
                        tjd_bird_die(game->pBird);
                        printf("BIRD RAM C x1:%d, y1:%d, x2:%d, y2:%d, xd:%d, yd:%d\n", x1, y1, x2, y2, xd, yd);

                        if (game->pBird->x + (BIRD_WIDTH >> 1) < pBarrier->x)
                        {
                            game->pBird->x -= 6;
                        }
                        return FALSE;
                    }
                }
                if ((game->Barrier_status != RLS_DOWN_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
                {
                    y2 = BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - pBarrier->cy * (MAX_BARRIER_NUM - pBarrier->num);
                    yd = GAME_ABS(y1 - y2) - Y_DEVIATION;
                    if ((y1 + (BIRD_VALID_HEIGHT >> 1)) >= y2) //(yd <= (BIRD_VALID_HEIGHT>>1))
                    {
                        // 撞击到下边沿
                        game->BirdFly_status = LEVENT_BIRD_DIE_FALLDOWN;
                        game->bird_y_speed = 0;
                        // 小鸟被撞击到地面
                        game->pBird->idx = 0;
                        tjd_bird_die(game->pBird);
                        printf("BIRD RAM D x1:%d, y1:%d, x2:%d, y2:%d, xd:%d, yd:%d, num:%d\n", x1, y1, x2, y2, xd, yd, pBarrier->num);

                        if (game->pBird->x + (BIRD_WIDTH >> 1) > pBarrier->x)
                        {
                            game->pBird->x = pBarrier->x + pBarrier->cx;
                        }
                        else
                        {
                            game->pBird->x -= 6;
                        }
                        return FALSE;
                    }
                }
            }
        }
    }
    return TRUE;
}

static void tjd_birdfly_send_draw_evt(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->has_to_redraw = TRUE;
}

void tjd_show_digit(u16 x, u16 y, char *pDigitStr, u32 id)
{
    u16 i;
    char *pStr;
    u32 temp;
    pStr = pDigitStr;

    /* 显示得分 */
    for (i = 0; i < SCORE_MAX_NUM && *pStr; i++)
    {
        compo_picturebox_t *digit_pic = compo_getobj_byid(id + i);

        if (*pStr >= '0' && *pStr <= '9')
        {
            temp = *pStr - '0';

            compo_picturebox_set(digit_pic, digit_id_arr[temp]);
            compo_picturebox_set_pos(digit_pic, x, y);
            compo_picturebox_set_visible(digit_pic, true);

            x += DIGIT_CX;
        }
        pStr++;
    }

    /* 隐藏掉不需要显示部分 */
    for (; i < SCORE_MAX_NUM; i++)
    {
        compo_picturebox_t *digit_pic = compo_getobj_byid(id + i);
        compo_picturebox_set_visible(digit_pic, false);
    }
}

void tjd_show_score(u16 x, u16 y, u32 score)
{
    char str[6] = {0};
    sprintf(str, "%d", score);

    tjd_show_digit(x + 32, y + 3, str, COMPO_ID_GAME_PIC_SCORE);
}

static void tjd_make_resource(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    static u8 re_idx = 0;
    Resource_t *pRes;
    if (LEVENT_BIRD_QUICK_RIGHT_FLY == game->BirdFly_status)
    {
        pRes = game->pResource + re_idx;
        pRes->idx = 0;
        pRes->attrib = RES_GOLD;
        pRes->cx = RESOURCE_CX;
        pRes->cy = RESOURCE_CY;

        pRes->x = BIRDFLY_ZOOM_X + BIRDFLY_ZOOM_CX;
        pRes->y = BIRDFLY_ZOOM_Y + (BIRDFLY_ZOOM_CY >> 1) - (RESOURCE_CY >> 1); 
        re_idx++;
        if (re_idx >= MAX_RESOURCE_DATA_NUM)
        {
            re_idx = 0;
        }
    }
    else if (LEVENT_BIRD_FLYING_ON == game->BirdFly_status || LEVENT_BIRD_GLIDING == game->BirdFly_status)
    {
        u8 rand;
        rand = get_random(game->make_resource_max_rand);

        pRes = game->pResource + re_idx;
        pRes->idx = 0;
        pRes->cx = RESOURCE_CX;
        pRes->cy = RESOURCE_CY;
        pRes->x = BIRDFLY_ZOOM_X + BIRDFLY_ZOOM_CX;
        pRes->y = BIRDFLY_ZOOM_Y + (BIRDFLY_ZOOM_CY >> 1) - (RESOURCE_CY >> 1);

        if (rand == 0 || rand == 1 || rand == 2)
        {
            pRes->attrib = RES_DEATH;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }
        else if (rand == 10)
        {
            pRes->attrib = RES_UP;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }
        else if (rand == 15)
        {
            pRes->attrib = RES_DOWN;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }
        else if (rand == 20)
        {
            pRes->attrib = RES_UP_DOWN;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }
        else if (rand == 30 || rand == 31 || rand == 32 || rand == 32)
        {
            pRes->attrib = RES_RIGHT;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }
        else if (rand == 50)
        {
            pRes->attrib = RES_LIFE;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }
        else
        {
            pRes->attrib = RES_GOLD;
            if (game->make_resource_max_rand >= 10)
            {
                game->make_resource_max_rand--;
            }
        }

        re_idx++;
        if (re_idx >= MAX_RESOURCE_DATA_NUM)
        {
            re_idx = 0;
        }
    }
}

static void tjd_make_barrier(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    static u8 Barrier_idx = 0;
    Barrier_t *pBarrier;

    //	printf("Barrier_idx:%d\n", Barrier_idx);

    pBarrier = game->pBarrier + Barrier_idx;
    pBarrier->x = BIRDFLY_ZOOM_X + BIRDFLY_ZOOM_CX + BARRIER_1_CX;
    pBarrier->cx = BARRIER_1_CX;
    pBarrier->cy = BARRIER_1_CY;
    pBarrier->attrib = get_random(BARRIER_TYPE_NUM) + 1;
    if (pBarrier->attrib == BARRIER_UP_DOWN)
    {
        pBarrier->num = get_random(MAX_BARRIER_NUM - 1) + 1;
    }
    else
    {
        pBarrier->num = get_random(MAX_BARRIER_NUM) + 1;
    }
    Barrier_idx++;
    if (Barrier_idx >= MAX_BARRIER_DATA_NUM)
    {
        Barrier_idx = 0;
    }
}

static void tjd_bird_fly_proc(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    static u8 ani_cnt;
    
    u16 idx;
    u16 speed;
    u16 flying_bird_pic_num;

    flying_bird_pic_num = sizeof(Flying_Bird_Pic_arr) / sizeof(Flying_Bird_Pic_arr[0]);

    /* 金币旋转 */
    game->gold_spin_idx = (game->gold_spin_idx + 1) % (sizeof(gold_pic_arr) / sizeof(gold_pic_arr[0]));

    if (LEVENT_BIRD_FLYING_ON == game->BirdFly_status)
    {
        game->bird_y_speed = game->bird_y_speed - BIRD_FALL_G;
        speed = game->bird_y_speed;
        if (game->bird_y_speed > -2)
        {
            speed = game->bird_y_speed;
            idx = flying_bird_pic_num - 1 - speed * flying_bird_pic_num / BIRD_FLY_V;
            if (idx < 0)
            {
                idx = 0;
            }
            else if (idx >= flying_bird_pic_num)
            {
                idx = flying_bird_pic_num - 1;
            }

            game->pBird->idx = idx;
        }
        else
        {
            game->pBird->idx = 3;
        }
        game->pBird->y -= game->bird_y_speed;
        if (game->pBird->y <= (BIRDFLY_ZOOM_Y)) 
        {
            game->pBird->y = BIRDFLY_ZOOM_Y;
            game->bird_y_speed = 0;
        }
        if (game->bird_y_speed <= 0)
        {

            game->BirdFly_status = LEVENT_BIRD_GLIDING;
        }
    }
    else if (LEVENT_BIRD_GLIDING == game->BirdFly_status)
    {
        game->bird_y_speed = game->bird_y_speed - BIRD_FALL_G;
        game->pBird->idx = 3;
        game->pBird->y -= game->bird_y_speed;
        if ((game->pBird->y + (BIRD_HEIGHT >> 1) - (BIRD_VALID_HEIGHT >> 1)) > (BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT)) 
        {
            game->BirdFly_status = LEVENT_BIRD_DIE_FALLDOWN;
            game->pBird->idx = 0;
            game->pBird->flag = 0;
            // 小鸟被撞击到地面
            game->pBird->y = (BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT + 3);
            tjd_bird_die(game->pBird);
        }
    }
    else if (LEVENT_BIRD_DIE_FALLDOWN == game->BirdFly_status)
    {
        game->pBird->y -= game->bird_y_speed;

        if (game->pBirdHit->flag)
        {
            game->pBirdHit->idx++;

            if (game->pBirdHit->idx >= sizeof(Hit_Bird_Boom_pic_arr) / sizeof(Hit_Bird_Boom_pic_arr[0]))
            {
                printf("end bird boom\n");
                game->pBirdHit->idx = 0;
                game->pBirdHit->flag = 0;
            }
        }
        if (game->pBird->flag)
        {
            game->pBird->idx++;

            if (game->pBird->idx >= sizeof(Death_Bird_Fall_pic_arr) / sizeof(Death_Bird_Fall_pic_arr[0]) || (game->pBird->y + (BIRD_HEIGHT >> 1) - BIRD_VALID_HEIGHT >> 1) >= (BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT))
            {
                printf("end bird fall\n");
                game->pBird->idx = 0;
                game->pBird->flag = 0;
            }
            game->bird_y_speed = game->bird_y_speed - BIRD_FALL_G;
        }
        if (game->pBirdHit->flag == 0 && game->pBird->flag == 0)
        {
            if (game->bird_num > 0)
            {
                tjd_ready_birdfly();
                tjd_birdfly_send_draw_evt();
            }
            else
            {
                printf("GAMEOVER\n");
                game->BirdFly_status = LEVENT_GAMEOVER_DLG;
                tjd_birdfly_stop();

                tjd_birdfly_send_draw_evt();
            }
        }
    }
}

static void tjd_bird_fly_task(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    static u16 cnt = 0;

    cnt++;
    if (cnt >= 200)
    {
        cnt = 0;
        if (game->make_barrier_time > 10)
        {
            game->make_barrier_time--;
        }
    }
    tjd_bird_fly_proc();
    if (game->BirdFly_status == LEVENT_BIRD_QUICK_RIGHT_FLY)
    {
        if (cnt % 2 == 0)
        {
            // 生成资源
            tjd_make_resource();
        }
    }
    else
    {
        if (cnt % 10 == 0)
        {
            // 生成资源
            tjd_make_resource();
        }
    }
    if (cnt % game->make_barrier_time == 3)
    {
        // 生成障碍物
        if (game->Barrier_status == NORMAL_BARRIER)
        {
            tjd_make_barrier();
        }
    }
}

static void TJD_Bird_FlyOn(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    printf("TJD_Bird_FlyOn");

    game->bird_y_speed = BIRD_FLY_V;

    game->BirdFly_status = LEVENT_BIRD_FLYING_ON;
    game->pBird->idx = 0;
}

static void tjd_resource_move(u16 x_offset)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    u16 i;
    Resource_t *pRes;

    /* 资源位置移动 */
    for (i = 0; i < MAX_RESOURCE_DATA_NUM; i++)
    {
        pRes = game->pResource + i;
        if (pRes->attrib)
        {   
            pRes->x -= x_offset;
            if (pRes->x + pRes->cx <= BIRDFLY_ZOOM_X)
            {
                pRes->attrib = 0;
            }
        }
    }
}

static void TJD_barrier_move(u16 x_offset)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    u16 i;
    Barrier_t *pBarrier;

    for (i = 0; i < MAX_BARRIER_DATA_NUM; i++)
    {
        pBarrier = game->pBarrier + i;
        if (pBarrier->attrib)
        {
            if (pBarrier->x <= BIRDFLY_ZOOM_X - pBarrier->cx)
            {
                pBarrier->attrib = 0;
            }
            else
            {
                pBarrier->x -= x_offset;
            }
        }
    }
}

static void tjd_bird_fly_animation_task(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    u16 x_offset;
    if (LEVENT_BIRD_QUICK_RIGHT_FLY == game->BirdFly_status)
    {
        x_offset = 10;
    }
    else if (LEVENT_BIRD_FLYING_ON == game->BirdFly_status || LEVENT_BIRD_GLIDING == game->BirdFly_status)
    {
        x_offset = 2;
    }
    else
    {
        x_offset = 0;
    }
    game->x_offset += x_offset;
    if (game->x_offset > 10000)
    {
        game->x_offset = 0;
    }

    tjd_resource_move(x_offset);
    TJD_barrier_move(x_offset);
    tjd_check_bird_ram_barrier();
    tjd_check_bird_get_resource();

    tjd_birdfly_send_draw_evt();
}

static void tjd_draw_bird(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    compo_picturebox_t *bird_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BIRD);
    if ((game->pBird->y + (BIRD_HEIGHT >> 1) - (BIRD_VALID_HEIGHT >> 1)) >= BIRDFLY_ZOOM_Y && (game->pBird->y + (BIRD_HEIGHT >> 1) - (BIRD_VALID_HEIGHT >> 1)) <= (BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT))
    {
        if (game->pBird->flag)
        {
            compo_picturebox_set(bird_pic, Flying_Bird_Pic_arr[game->pBird->idx]);
            compo_picturebox_set_pos(bird_pic, game->pBird->x, game->pBird->y);
            compo_picturebox_set_visible(bird_pic, true);
        }
    }

    compo_picturebox_t *start_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_START);
    compo_picturebox_t *figure_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_START_TIP);
    if (LEVENT_READY == game->BirdFly_status)
    {
        compo_picturebox_set_visible(start_pic, true);
        compo_picturebox_set_visible(figure_pic, true);
    }
    else
    {
        compo_picturebox_set_visible(start_pic, false);
        compo_picturebox_set_visible(figure_pic, false);
    }
}

static void tjd_draw_bird_hit(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    compo_picturebox_t *hit_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BOOM);
    if (game->pBirdHit->flag)
    {
        compo_picturebox_set(hit_pic, Hit_Bird_Boom_pic_arr[game->pBirdHit->idx]);
        compo_picturebox_set_pos(hit_pic, game->pBirdHit->x, game->pBirdHit->y);
        compo_picturebox_set_visible(hit_pic, true);
    }
}

static void tjd_draw_falling_death_bird(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    compo_picturebox_t *bird_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BIRD);
    if ((game->pBird->y + (BIRD_HEIGHT >> 1) - (BIRD_VALID_HEIGHT >> 1)) >= BIRDFLY_ZOOM_Y && (game->pBird->y + (BIRD_HEIGHT >> 1) - (BIRD_VALID_HEIGHT >> 1)) <= (BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT))
    {
        if (game->pBird->flag)
        {
            compo_picturebox_set(bird_pic, Death_Bird_Fall_pic_arr[game->pBird->idx]);
            compo_picturebox_set_pos(bird_pic, game->pBird->x, game->pBird->y);
            compo_picturebox_set_visible(bird_pic, true);
        }
    }
}

static void tjd_draw_resource(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    Resource_t *pRes;

    for (u16 i = 0; i < MAX_RESOURCE_DATA_NUM; i++)
    {
        compo_picturebox_t *resource_pic = compo_getobj_byid(COMPO_ID_GAME_RESOURCE_PIC + i);
        compo_picturebox_set_visible(resource_pic, false);

        pRes = game->pResource + i;
        if (pRes->attrib)
        {
            if (pRes->x >= BIRDFLY_ZOOM_X && (pRes->x <= (BIRDFLY_ZOOM_X + BIRDFLY_ZOOM_CX - pRes->cx)))
            {
                compo_picturebox_set_visible(resource_pic, true);

                if (pRes->attrib == RES_GOLD)
                {   
                    compo_picturebox_set(resource_pic, gold_pic_arr[game->gold_spin_idx]);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else if (pRes->attrib == RES_UP)
                {
                    compo_picturebox_set(resource_pic, UI_BUF_GAME_BIRD_UP_BIN);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else if (pRes->attrib == RES_DOWN)
                {
                    compo_picturebox_set(resource_pic, UI_BUF_GAME_BIRD_DOWN_BIN);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else if (pRes->attrib == RES_UP_DOWN)
                {
                    compo_picturebox_set(resource_pic, UI_BUF_GAME_BIRD_UP_DOWN_BIN);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else if (pRes->attrib == RES_RIGHT)
                {
                    compo_picturebox_set(resource_pic, UI_BUF_GAME_BIRD_RIGHT_BIN);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else if (pRes->attrib == RES_LIFE)
                {
                    compo_picturebox_set(resource_pic, UI_BUF_GAME_BIRD_LIFE_BIN);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else if (pRes->attrib == RES_DEATH)
                {
                    compo_picturebox_set(resource_pic, UI_BUF_GAME_BIRD_DEATH_BIN);
                    compo_picturebox_set_pos(resource_pic, pRes->x, pRes->y);
                }
                else
                {
                    compo_picturebox_set_visible(resource_pic, false);
                }
            }
        }
    }
}

static void tjd_draw_barrier(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    Barrier_t *pBarrier;
    //	if (LEVENT_PLAYING == g_Airscraft_status)
    {
        for (int i = 0; i < MAX_BARRIER_DATA_NUM; i++)
        {
            pBarrier = game->pBarrier + i;

            /* 释放资源不需要显示 */
            if (pBarrier->attrib == BARRIER_NULL || game->Barrier_status == RLS_UPDOWN_BARRIER || game->Barrier_status == RLS_UP_BARRIER || game->Barrier_status == RLS_DOWN_BARRIER)
            {
                if (pBarrier->attrib == BARRIER_NULL || game->Barrier_status == RLS_UPDOWN_BARRIER)
                {
                    for (int j = 0; j < MAX_BARRIER_NUM * 2; j++)
                    {
                        compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + (i * 8 + j));
                        compo_picturebox_set_visible(barrier_pic, false);
                    }
                    continue;
                }
                else if (game->Barrier_status == RLS_UP_BARRIER)
                {
                    for (int j = 0; j < MAX_BARRIER_NUM; j++)
                    {
                        compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + (i * 8 + j));
                        compo_picturebox_set_visible(barrier_pic, false);
                    }
                }
                else if (game->Barrier_status == RLS_DOWN_BARRIER)
                {
                    for (int j = 0; j < MAX_BARRIER_NUM; j++)
                    {
                        compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + ((i * 8 + MAX_BARRIER_NUM) + j));
                        compo_picturebox_set_visible(barrier_pic, false);
                    }
                }
            }

            /* 显示有效移动部分 */
            if (pBarrier->x >= BIRDFLY_ZOOM_X - pBarrier->cx && pBarrier->x <= (BIRDFLY_ZOOM_X + BIRDFLY_ZOOM_CX + pBarrier->cx))
            {
                if (pBarrier->attrib == BARRIER_UP && (game->Barrier_status != RLS_UP_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
                {
                    u16 y;
                    y = BIRDFLY_ZOOM_Y;
                    for (int j = 0; j < pBarrier->num; j++)
                    {
                        compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + (i * 8 + j));
                        compo_picturebox_set_pos(barrier_pic, pBarrier->x, y);
                        compo_picturebox_set_visible(barrier_pic, true);

                        y += pBarrier->cy;
                    }
                }
                else if (pBarrier->attrib == BARRIER_DOWN && (game->Barrier_status != RLS_DOWN_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
                {
                    u16 y;
                    y = BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - pBarrier->cy;
                    for (int j = 0; j < pBarrier->num; j++)
                    {
                        compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + ((i * 8 + MAX_BARRIER_NUM) + j));
                        compo_picturebox_set_pos(barrier_pic, pBarrier->x, y);
                        compo_picturebox_set_visible(barrier_pic, true);

                        y -= pBarrier->cy;
                    }
                }
                else if (pBarrier->attrib == BARRIER_UP_DOWN)
                {
                    u16 y;

                    if ((game->Barrier_status != RLS_UP_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
                    {
                        y = BIRDFLY_ZOOM_Y;
                        for (int j = 0; j < pBarrier->num; j++)
                        {
                            compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + (i * 8 + j));
                            compo_picturebox_set_pos(barrier_pic, pBarrier->x, y);
                            compo_picturebox_set_visible(barrier_pic, true);

                            y += pBarrier->cy;
                        }
                    }

                    if ((game->Barrier_status != RLS_DOWN_BARRIER && game->Barrier_status != RLS_UPDOWN_BARRIER))
                    {
                        y = BIRDFLY_ZOOM_Y + BIRDFLY_ZOOM_CY - pBarrier->cy;
                        for (int j = 0; j < MAX_BARRIER_NUM - pBarrier->num; j++)
                        {
                            compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + ((i * 8 + MAX_BARRIER_NUM) + j));
                            compo_picturebox_set_pos(barrier_pic, pBarrier->x, y);
                            compo_picturebox_set_visible(barrier_pic, true);

                            y -= pBarrier->cy;
                        }
                    }
                }
            }
        }
    }
}

static void tjd_show_bird_life(u16 x, u16 y, u16 level)
{
    char str[6] = {0};
    sprintf(str, "%d", level);
    tjd_show_digit(x + 32, y + 3, str, COMPO_ID_GAME_PIC_BIRD_LIFE);
}

static void tjd_bird_fly_redraw_proc(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    //	printf("TJD_Bird_Fly_redraw_proc:%d\n", game->BirdFly_status);
    if (game->has_to_redraw)
    {
        game->has_to_redraw = false;
        if (LEVENT_BIRD_FLYING_ON == game->BirdFly_status || LEVENT_BIRD_GLIDING == game->BirdFly_status || LEVENT_BIRD_QUICK_RIGHT_FLY == game->BirdFly_status)
        {
            /* 显示部分 */
            tjd_draw_bird();
            tjd_draw_barrier();
            tjd_draw_resource();
            tjd_show_bird_life(LEVEL_ICO_X, LEVEL_ICO_Y, game->bird_num);
            tjd_show_score(SCORE_ICO_X, SCORE_ICO_Y, game->game_score);

            /* 隐藏部分 */
            compo_picturebox_t *hit_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BOOM);
            compo_picturebox_set_visible(hit_pic, false);
        }
        else if (LEVENT_BIRD_DIE_FALLDOWN == game->BirdFly_status)
        {
            /* 显示部分 */
            tjd_draw_falling_death_bird();
            tjd_draw_bird_hit();
            tjd_draw_resource();
            tjd_draw_barrier();
            tjd_show_bird_life(LEVEL_ICO_X, LEVEL_ICO_Y, game->bird_num);
            tjd_show_score(SCORE_ICO_X, SCORE_ICO_Y, game->game_score);
        }
        else if (LEVENT_GAMEOVER_DLG == game->BirdFly_status)
        {
            /* 显示部分 */
            tjd_draw_resource();
            tjd_draw_barrier();
            tjd_show_bird_life(LEVEL_ICO_X, LEVEL_ICO_Y, game->bird_num);
            tjd_show_score(SCORE_ICO_X, SCORE_ICO_Y, game->game_score);
            tjd_show_game_over_dlg();

            /* 隐藏部分 */
            compo_picturebox_t *bird_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BIRD);
            compo_picturebox_t *start_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_START);
            compo_picturebox_t *figure_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_START_TIP);
            compo_picturebox_set_visible(bird_pic, false);
            compo_picturebox_set_visible(start_pic, false);
            compo_picturebox_set_visible(figure_pic, false);

            compo_picturebox_t *hit_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BOOM);
            compo_picturebox_set_visible(hit_pic, false);
        }
        else if (LEVENT_READY == game->BirdFly_status)
        {
            /* 显示部分 */
            tjd_draw_bird();

            tjd_show_bird_life(LEVEL_ICO_X, LEVEL_ICO_Y, game->bird_num);
            tjd_show_score(SCORE_ICO_X, SCORE_ICO_Y, game->game_score);

            /* 隐藏部分 */
            compo_picturebox_t *hit_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BOOM);
            compo_picturebox_set_visible(hit_pic, false);

            for (int i = 0; i < MAX_BARRIER_DATA_NUM; i++)
            {
                for (int j = 0; j < (MAX_BARRIER_NUM * 2); j++)
                {
                    compo_picturebox_t *barrier_pic = compo_getobj_byid(COMPO_ID_GAME_PIC_BARRIER + (i * (MAX_BARRIER_NUM * 2) + j));
                    compo_picturebox_set_visible(barrier_pic, false);
                }
            }

            for (int i = 0; i < MAX_RESOURCE_DATA_NUM; i++)
            {
                compo_picturebox_t *resource_pic = compo_getobj_byid(COMPO_ID_GAME_RESOURCE_PIC + i);
                compo_picturebox_set_visible(resource_pic, false);
            }
        }
    }
}

void tjd_bird_fly_entry(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    game->has_to_redraw = TRUE;
    game->bird_num = 1;
    game->game_score = 0;

    tjd_malloc_bird_fly_buffer();

    game->BirdFly_status = LEVENT_READY;
    tjd_reset_birdfly();

    tjd_birdfly_send_draw_evt();
}

void tjd_birdfly_exit(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    printf("BirdFly_exit\n");

    tjd_birdfly_stop();
    game->BirdFly_status = LEVENT_NULL;
    tjd_free_bird_fly_buffer();
}

// 创建游戏界面
compo_form_t *func_game_form_create(void)
{
    compo_form_t *frm;

    // 新建窗体和背景
    frm = compo_form_create(true);

    /* 主背景 */
    compo_picturebox_t *pic = compo_picturebox_create(frm, UI_BUF_GAME_BIRD_BG1_BIN);
    compo_setid(pic, COMPO_ID_GAME_PIC_BG);
    compo_picturebox_set_pos(pic, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y);

    /* 小鸟 */
    pic = compo_picturebox_create(frm, UI_BUF_GAME_BIRD_FLY4_BIN);
    compo_setid(pic, COMPO_ID_GAME_PIC_BIRD);
    widget_set_align_center(pic->img, false);
    compo_picturebox_set_pos(pic, BIRDFLY_ZOOM_X + CENTER_X(BIRD_WIDTH), BIRDFLY_ZOOM_Y + ((BIRDFLY_ZOOM_CY - BIRDFLY_GROUND_HEIGHT - BIRD_HEIGHT) >> 1));

    /* 开始指示 */
    pic = compo_picturebox_create(frm, UI_BUF_GAME_START_LBL_BIN);
    compo_setid(pic, COMPO_ID_GAME_PIC_START);
    compo_picturebox_set_pos(pic, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y + BIRD_HEIGHT - 5);

    pic = compo_picturebox_create(frm, UI_BUF_GAME_FIGURE_BIN);
    compo_setid(pic, COMPO_ID_GAME_PIC_START_TIP);
    compo_picturebox_set_pos(pic, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y + BIRD_HEIGHT + START_LBL_HEIGHT + 15);

    /* 障碍物 - 箱子 */
    for (int i = 0; i < COMPO_ID_GAME_PIC_BARRIER_MAX - COMPO_ID_GAME_PIC_BARRIER; i++)
    {
        pic = compo_picturebox_create(frm, UI_BUF_GAME_BARRIER_1_BIN);
        compo_setid(pic, COMPO_ID_GAME_PIC_BARRIER + i);
        widget_set_align_center(pic->img, false);
        compo_picturebox_set_visible(pic, false);
    }

    /* 生成资源 */
    for (int i = 0; i < COMPO_ID_GAME_RESOURCE_PIC_MAX - COMPO_ID_GAME_RESOURCE_PIC; i++)
    {
        pic = compo_picturebox_create(frm, gold_pic_arr[0]);
        compo_setid(pic, COMPO_ID_GAME_RESOURCE_PIC + i);
        widget_set_align_center(pic->img, false);
        compo_picturebox_set_visible(pic, false);
    }

    /* 头部背景 */
    pic = compo_picturebox_create(frm, UI_BUF_GAME_GAME_HEAD_BIN);
    widget_set_align_center(pic->img, false);
    compo_picturebox_set_pos(pic, 0, 0);

    /* 小鸟生命 */
    pic = compo_picturebox_create(frm, UI_BUF_GAME_BIRD_LIFE_BIN);
    widget_set_align_center(pic->img, false);
    compo_picturebox_set_pos(pic, LEVEL_ICO_X, LEVEL_ICO_Y);
    for (int i = 0; i < COMPO_ID_GAME_PIC_BIRD_LIFE_MAX - COMPO_ID_GAME_PIC_BIRD_LIFE; i++)
    {

        pic = compo_picturebox_create(frm, digit_id_arr[1]);
        compo_setid(pic, COMPO_ID_GAME_PIC_BIRD_LIFE + i);
        widget_set_align_center(pic->img, false);
        compo_picturebox_set_pos(pic, LEVEL_ICO_X + 32, LEVEL_ICO_Y + 3);
    }

    /* 得分 */
    pic = compo_picturebox_create(frm, UI_BUF_GAME_GOLD_0_BIN);
    widget_set_align_center(pic->img, false);
    compo_picturebox_set_pos(pic, SCORE_ICO_X, SCORE_ICO_Y);
    for (int i = 0; i < COMPO_ID_GAME_PIC_SCORE_MAX - COMPO_ID_GAME_PIC_SCORE; i++)
    {
        pic = compo_picturebox_create(frm, digit_id_arr[0]);
        compo_setid(pic, COMPO_ID_GAME_PIC_SCORE + i);
        widget_set_align_center(pic->img, false);
        compo_picturebox_set_pos(pic, SCORE_ICO_X + 32, SCORE_ICO_Y + 3);
    }

    /* 击中 */
    pic = compo_picturebox_create(frm, Hit_Bird_Boom_pic_arr[0]);
    compo_setid(pic, COMPO_ID_GAME_PIC_BOOM);
    widget_set_align_center(pic->img, false);
    compo_picturebox_set_visible(pic, false);

    /* 游戏结束图片 */
    compo_button_t *btn = compo_button_create_by_image(frm, UI_BUF_GAME_DLG_BG_BIN);
    compo_setid(btn, COMPO_ID_GAME_PIC_DLG_BG);
    compo_button_set_pos(btn, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y);
    compo_button_set_visible(btn, false);

    pic = compo_picturebox_create(frm, UI_BUF_GAME_GAME_OVER_BIN);
    compo_setid(pic, COMPO_ID_GAME_PIC_GAME_OVER);
    compo_picturebox_set_pos(pic, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y - 20);
    compo_picturebox_set_visible(pic, false);

    pic = compo_picturebox_create(frm, UI_BUF_GAME_GAME_OK_BTN_BIN);
    compo_setid(pic, COMPO_ID_GAME_PIC_GAME_OK);
    compo_picturebox_set_pos(pic, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y + 20);
    compo_picturebox_set_visible(pic, false);

    return frm;
}

static void func_game_click(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    int btn_id = compo_get_button_id();

    if (game->BirdFly_status != LEVENT_GAMEOVER_DLG)
    {
        if (LEVENT_BIRD_FLYING_ON == game->BirdFly_status || LEVENT_BIRD_GLIDING == game->BirdFly_status)
        {
            TJD_Bird_FlyOn();
        }
        else if (game->BirdFly_status == LEVENT_READY)
        {
            game->BirdFly_status = LEVENT_BIRD_FLYING_ON;
            tjd_birdfly_start_play();
            TJD_Bird_FlyOn();
        }
    }
    else if (btn_id == COMPO_ID_GAME_PIC_DLG_BG)
    {
        if (game->BirdFly_status == LEVENT_GAMEOVER_DLG)
        {
            func_back_to();
        }
    }
}

// 消息处理
static void func_game_message(size_msg_t msg)
{
    switch (msg)
    {
    case MSG_CTP_CLICK:
        func_game_click();
        break;

    case MSG_CTP_SHORT_UP:
    case MSG_CTP_SHORT_DOWN:
        break;

    case MSG_CTP_SHORT_LEFT:
        if (func_cb.flag_sort)
        {
            func_message(msg);
        }
        break;

    case MSG_CTP_LONG:
        break;

    default:
        func_message(msg);
        break;
    }
}

// 游戏过程状态机
static void func_game_process(void)
{
    f_game_t *game = (f_game_t *)func_cb.f_cb;
    if (game == NULL) {
        return;
    }

    /* 游戏运行任务 */
    if (tick_check_expire(game->bird_fly_task_tick, BIRDFLY_TIME_GAP) && game->bird_fly_task_flag)
    {
        game->bird_fly_task_tick = tick_get();
        tjd_bird_fly_task();
    }
    if (tick_check_expire(game->animation_task_tick, BIRDFLY_ANI_TIME_GAP) && game->animation_task_flag)
    {
        game->animation_task_tick = tick_get();
        tjd_bird_fly_animation_task();
    }
    if (tick_check_expire(game->quick_fly_task_tick, QUICKFLY_TIMEOUT_TIME) && game->quick_fly_task_flag)
    {
        game->quick_fly_task_tick = tick_get();
        tjd_end_quick_fly_mode();
    }
    if (tick_check_expire(game->rls_barrier_task_tick, RLS_BARRIER_TIMEOUT_TIME) && game->rls_barrier_task_flag)
    {
        game->rls_barrier_task_tick = tick_get();
        tjd_end_rls_barrier_mode();
    }

    /* 游戏过程不熄灭屏幕 */
    reset_sleep_delay_all();

    /* 更新游戏画面 */
    tjd_bird_fly_redraw_proc();
}

// 进入游戏功能
static void func_game_enter(void)
{
    func_cb.f_cb = func_zalloc(sizeof(f_game_t));

    func_cb.frm_main = func_game_form_create();
    f_game_t *game = (f_game_t *)func_cb.f_cb;

    tjd_bird_fly_entry();
}

// 退出游戏功能
static void func_game_exit(void)
{
    tjd_birdfly_exit();

    func_cb.last = FUNC_GAME;
}

// 游戏功能
void func_game(void)
{
    printf("%s\n", __func__);
    func_game_enter();
    while (func_cb.sta == FUNC_GAME) {
        func_game_process();
        func_process();
        func_game_message(msg_dequeue());
    }
    func_game_exit();
}
#endif