games_gopher.c

几个嵌入式手机平台小游戏c源代码

        case KEY_6:
            if (inGame)
                judgeHit(1, 2);
            break;
                       
        case KEY_7:
            if (inGame)
                judgeHit(2, 0);
            break;
            
        case KEY_8:
            if (inGame)
                judgeHit(2, 1);
            break;

         case KEY_9:
            if (inGame)
                judgeHit(2, 2);
            break;

        case KEY_STAR:
            if (inGame)
                judgeHit(3, 0);
            break;

        case KEY_0:
            if (inGame)
                judgeHit(3, 1);
            break;
            
        case KEY_POUND:
            if (inGame)
                judgeHit(3, 2);
            break;
           
        case KEY_SOFT_LEFT:
            if(gamesApp_data.popupwin == OP_NULL)  /* if there is a popup, it means that a game is over */
            {
                if (inGame)
                {            
                    inGame=OP_FALSE;     /* pause the game */
                }
                else
                {
                    inGame=OP_TRUE;    /* restart the game */
                    OPUS_Start_Timer(OPUS_TIMER_GAME_TIMING, 100, 0,  PERIODIC);
                }
            }
            break;
            
        case KEY_SOFT_RIGHT:
        case KEY_CLEAR:
            if(gamesApp_data.popupwin != OP_NULL)
            {
                inGame=OP_FALSE;
                close_old_popup();
                OPUS_Stop_Timer(OPUS_TIMER_GAME_TIMING);
                Games_change_state((OP_UINT8) APP_GAMES_STATE_MENU);
            }
            else
            {
                ShowGameOver(score);
            }
            break;
              
        case KEY_END:
            inGame=OP_FALSE;
            OPUS_Stop_Timer(OPUS_TIMER_GAME_TIMING);
            break;
           
        default:
            break;
    }
    
 }

/*==================================================================================================
    FUNCTION: Paint

    DESCRIPTION:
        Description of this specific function.

    ARGUMENTS PASSED:
        
    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void Paint(void)
{
    OP_UINT8  i,j;
    for(i=0;i<rowNum;i++)
        for(j=0;j<colNum;j++)
        {
            DrawSquare(j,i, field[i][j]);
        };
    ShowScore();
    ds_refresh();

}

/*==================================================================================================
    FUNCTION: DrawSquare

    DESCRIPTION:
        Description of this specific function.

    ARGUMENTS PASSED:
        
    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void DrawSquare(OP_INT8 col,OP_INT8 row, OP_UINT8 state)
{
    OP_UINT8 x,y;
    RM_BMP_ID_T bitmap_id = NULL_BITMAP;
    
    x = xoffset+col*SQUAREWIDTH;
    y = yoffset+row*SQUAREHEIGHT;
    switch (state)
    {
        case 0:
            bitmap_id = BMP_GOPHER_HOLE;
            break;
        case 1 :  
            bitmap_id = BMP_GOPHER_GOPHER1;
             break;
        case 2 : 
            bitmap_id = BMP_GOPHER_GOPHER2;
             break;
        case 3 :  
            bitmap_id = BMP_GOPHER_GOPHER3;
             break;
        case 4 :  
            bitmap_id = BMP_GOPHER_GOPHER3;
             break;
        case 5 : 
            bitmap_id = BMP_GOPHER_GOPHER2;
             break;
        case 6 :  
            bitmap_id = BMP_GOPHER_GOPHER1;
             break;
        case 7:  
            bitmap_id = BMP_GOPHER_HURT1;
             break;
        case 8:  
            bitmap_id = BMP_GOPHER_HURT2;
             break;
        default:
            break;
    }

    if (bitmap_id != NULL_BITMAP)
    {
        ds_draw_bitmap_image_rm((OP_UINT16)x,(OP_UINT16)y,bitmap_id);
    }
}

/*==================================================================================================
    FUNCTION: judgeHit

    DESCRIPTION:
        Description of this specific function.

    ARGUMENTS PASSED:
        
    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void judgeHit(OP_INT8 row, OP_INT8 col)
{
    if ( field[row][col]>0 && field[row][col] < 5 && !hasHit[row][col])
    {
        hasHit[row][col]=OP_TRUE;
        score++;
        missed--;  /* minus 1 from missed because we have add 1 to it as default */
        if (gamesApp_data.audio_on == OP_TRUE)
        {
            SP_Audio_play_request(sound_list[1], gamesApp_data.volume, OP_FALSE);
        }
        if (score % 10 == 0)
        {
            levelPassed = OP_TRUE;
            current_level++;
            if (interval > 120)
                interval -= 30;
        }

    }
    else if (gamesApp_data.audio_on == OP_TRUE)
    {
        SP_Audio_play_request(sound_list[2], gamesApp_data.volume, OP_FALSE);
    }
}

/*==================================================================================================
    FUNCTION: GopherRun

    DESCRIPTION:
        Description of this specific function.

    ARGUMENTS PASSED:

    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void GopherRun(void )
{
    OP_UINT8 MX, MY;
    OP_UINT8 i, j;
    OP_BOOLEAN needRedraw;
    
    OPUS_Stop_Timer(OPUS_TIMER_GAME_TIMING);

    ShowScore();
    
    for (i=0; i<rowNum; i++)
        for (j=0; j<colNum; j++)
        {
            if (field[i][j] == 0 )
            {
                needRedraw = OP_FALSE;
            }
            else
            {
                needRedraw = OP_TRUE;
            }
            if(field[i][j]>0 && field[i][j]<7)
            {
                if (field[i][j]==1)
                {
                    totalGophers++;
                    missed++;
                    if ((current_level == 1 && (missed > 5 || totalGophers-score > 10)) ||
                         (current_level == 2  && (missed > 10 || totalGophers-score > 20)) ||
                         (current_level == 3  && (missed > 10 || totalGophers-score > 50)) ||
                         (current_level == 4  && (missed > 10 || totalGophers-score > 80)) ||
                         (current_level >= 5  && (missed > 10 || totalGophers-score > 100)))
                    {
                        inGame=OP_FALSE;
                        OPUS_Stop_Timer(OPUS_TIMER_GAME_TIMING);
                        ShowGameOver(score);
                        return;
                    }
                }
                if (!hasHit[i][j])
                {
                    /*
                     * If there is more than 1 gophers appearing at the same time, 
                     * the gopher will dispear when it reaches the top point.
                     */
                    if ((field[i][j] == 4 && current_level > 2) ||
                         field[i][j] == 6)
                    {
                        field[i][j] = 0;
                        concurrentGophers--;
                    }
                    else
                    {
                        field[i][j]++;
                    }
                }
                else
                {
                    field[i][j] = 7;
                    missed = 0; /* "missed" start from 0 again */
                }
            }
            else if (field[i][j]==7)
            {
                field[i][j]=8;
            }
            else if (field[i][j]>=8)
            {
                field[i][j]=0;
                hasHit[i][j]=OP_FALSE;
                concurrentGophers--;
            }

            if (needRedraw == OP_TRUE)
            {
                DrawSquare(j, i, field[i][j]);
                ds_refresh();
            }
        }


    if (concurrentGophers == 0 && levelPassed)
    {
        OPUS_Start_Timer(OPUS_TIMER_GAME_TIMING, 2500, 0,  PERIODIC);  /* interval between 2 levels */
        levelPassed = OP_FALSE;
    }
    else
    {
        if (concurrentGophers<MAX_CONCURRENT_GOPHERS &&  /* produce a new gopher */
                concurrentGophers<(current_level+1) /2 &&
                !levelPassed) 
        {
            do{
            MX=(OP_UINT8)rand()%colNum;
            MY=(OP_UINT8)rand()%rowNum;
            }
            while(field[MY][MX]>0);
            
            field[MY][MX]++;
            DrawSquare(MX, MY, field[MY][MX]);
            ds_refresh();
            concurrentGophers++;
                          
        }
        
            OPUS_Start_Timer(OPUS_TIMER_GAME_TIMING, interval, 0,  PERIODIC);
    }
} 

/*==================================================================================================
    FUNCTION: drawDigit

    DESCRIPTION:
        Description of this specific function.

    ARGUMENTS PASSED:

    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void drawDigit(OP_INT16 wInteger,OP_INT16 x, OP_INT16 y)
{
    OP_UINT8 buffer[8]; 
    OP_UINT8 strINT[16];
    
    op_sprintf((char *)buffer, "%d", wInteger);
    AtoU(strINT, buffer);
    draw_text(AREA_BITMAP, x, y, LCD_MAX_X-1, strINT, FONT_SIZE_SMALL, COLOR_WHITE, COLOR_CYAN_BLUE);
}


/*==================================================================================================
    FUNCTION: ShowGameOver

    DESCRIPTION:
        
    ARGUMENTS PASSED:

    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void ShowGameOver(OP_UINT16 wScore)
{
    char ss[4];
    OP_UINT8 ustr[MAX_STRING_LENGTH];
    OP_UINT8 tmpstr[MAX_STRING_LENGTH];

    inGame=OP_FALSE;
    if (gamesApp_data.audio_on == OP_TRUE)
    {
        SP_Audio_play_request(sound_list[3], gamesApp_data.volume, OP_FALSE); 
    }
    
    op_memset((void*)ustr, 0, MAX_STRING_LENGTH); 
    op_memset((void*)tmpstr, 0, MAX_STRING_LENGTH);

    OPUS_Stop_Timer(OPUS_TIMER_GAME_TIMING);

    if (wScore > 0 && is_new_highscore(APP_GAMES_GOPHER, wScore))
    {
        util_get_text_from_res_w_max_len(PMPT_TEXT_CONGRATULATION,ustr,MAX_STRING_LENGTH);
        //AtoU(tmpstr, (OP_UINT8 *)"A new highscore:");
        util_get_text_from_res_w_max_len(PMPT_TEXT_NEW_HIGHSCORE,tmpstr,MAX_STRING_LENGTH);
    }
    else
    {
        util_get_text_from_res_w_max_len(PMPT_TEXT_GAME_OVER,ustr,MAX_STRING_LENGTH);
        util_get_text_from_res_w_max_len(PMPT_TEXT_YOUR_SCORE,tmpstr,MAX_STRING_LENGTH);
    }
    
    Ustrcat(ustr,tmpstr);
    
    op_sprintf(ss,"%d",wScore);
    AtoU(tmpstr,(OP_UINT8 *)ss);
    Ustrcat(ustr,tmpstr);

    gamesApp_data.popupwin=ds_popup_message(OP_NULL, ustr, DS_POPUP_DEFAULT_MSG_TIME);
}


/*==================================================================================================
    FUNCTION: ShowScore

    DESCRIPTION:
        
    ARGUMENTS PASSED:

    RETURN VALUE:

    IMPORTANT NOTES:
        
==================================================================================================*/
static void ShowScore(void)
{
    OP_UINT8 text_str[MAX_STRING_LENGTH];   
    OP_UINT8 str_length;

    /*ds_draw_rect(2, 123, 123, 140, COLOR_BRIGHT_CYAN_BLUE);*/
    /*ds_fill_rect(3, 124, 122, 139, COLOR_CYAN_BLUE);*/
    
    util_cnvrt_res_into_text(PMPT_TEXT_TOTAL,text_str);
    if (text_str != OP_NULL)
    {
        draw_text(AREA_BITMAP, 5, 185, LCD_MAX_X-1, text_str, FONT_SIZE_SMALL, COLOR_WHITE, COLOR_CYAN_BLUE);
        str_length = (OP_INT8)ds_get_string_width(text_str, FONT_SIZE_SMALL);
        drawDigit(totalGophers, (OP_INT16)(5 + str_length), 185);
    }
    
    util_cnvrt_res_into_text(PMPT_TEXT_SCORE,text_str);
    if (text_str != OP_NULL)
    {
        draw_text(AREA_BITMAP, 85, 185, LCD_MAX_X-1, text_str, FONT_SIZE_SMALL, COLOR_WHITE, COLOR_CYAN_BLUE);
        str_length = (OP_INT8)ds_get_string_width(text_str, FONT_SIZE_SMALL);
        drawDigit(score, (OP_INT16)(85 + str_length), 185);
    }
    ds_refresh();
    
}

/*==================================================================================================
    GLOBAL FUNCTIONS
==================================================================================================*/

/*================================================================================================*/

#endif

#ifdef __cplusplus
}
#endif