games_starwar.c

来自「几个嵌入式手机平台小游戏c源代码」· C语言 代码 · 共 2,173 行 · 第 1/5 页

    util_get_text_from_res_w_max_len(PMPT_LIST_STARWAR, ustr, MAX_STRING_LENGTH);
    
    x = (OP_INT16)get_align_center_x_string((OP_UINT8 *)ustr);
    y = 12;
    
     /* shadow */
    ds_draw_text_line((OP_INT16)(x+1), 
                   (OP_INT16)(y+1), 
                   LCD_MAX_X_COOR,
                   (OP_UINT8 *)ustr, 
                   FONT_SIZE_LARGE|FONT_BOLD|FONT_OVERLAP, 
                   COLOR_DARK_BLUE, 
                   COLOR_TRANS );
  
    ds_draw_text_line(x, 
                  y, 
                   LCD_MAX_X_COOR,
                  (OP_UINT8 *)ustr, 
                  FONT_SIZE_LARGE|FONT_BOLD|FONT_OVERLAP, 
                  COLOR_BLUE_VIOLET, 
                  COLOR_TRANS );

    util_get_text_from_res_w_max_len(PMPT_TEXT_STARWAR_INTRO, ustr, MAX_STRING_LENGTH);
    //AtoU(ustr, (OP_UINT8 *)"Press soft left\nkey to start.");
    ds_draw_text ( 16, 
                  36, 
                  ustr, 
                  FONT_SIZE_SMALL|FONT_OVERLAP, 
                  COLOR_SAP_BLUE, 
                  COLOR_TRANS);

    
}

static void ShowScore(void)
{
    OP_UINT8 text_str[MAX_STRING_LENGTH];   
    OP_UINT8 str_length;

    ds_fill_rect(0, LCD_MAX_Y - 20, LCD_MAX_X-1, LCD_MAX_Y -1, STARWAR_BG_COLOR);

    util_cnvrt_res_into_text(PMPT_TEXT_SCORE,text_str);
    if (text_str != OP_NULL)
    {
        draw_text(AREA_BITMAP, 2, LCD_MAX_Y - 17, LCD_MAX_X-1, text_str, FONT_SIZE_SMALL|FONT_OVERLAP, COLOR_BLUE_VIOLET, COLOR_TRANS);
        str_length = (OP_INT8)ds_get_string_width(text_str, FONT_SIZE_SMALL);
        drawDigit(score, (OP_INT16)(2 + str_length), LCD_MAX_Y - 17);
    }

    util_cnvrt_res_into_text(PMPT_TEXT_LIVES,text_str);
    //AtoU(text_str, (OP_UINT8 *)"Lives:");
    if (text_str != OP_NULL)
    {
        draw_text(AREA_BITMAP, 70, LCD_MAX_Y - 17, LCD_MAX_X-1, text_str, FONT_SIZE_SMALL|FONT_OVERLAP, COLOR_BLUE_VIOLET, COLOR_TRANS);
        str_length = (OP_INT8)ds_get_string_width(text_str, FONT_SIZE_SMALL);
        drawDigit(scur, (OP_INT16)(70 + str_length), LCD_MAX_Y - 17);
    }

}

static void MoveShip(void)
{
    OP_INT16 oldx, oldy;
    oldx = shipX;
    oldy = shipY;

    shipX+=dx*movex;
    shipY+=dy*movey;

    if (atLevelEnd == OP_FALSE)
    {
        if (shipY<=borderwidth || shipY>=(LCD_MAX_Y-shipHeight-scoreheight))
        {
            dy=0;
            shipY=oldy;
        }
        if (shipX>=(LCD_MAX_X-borderwidth-shipWidth) || shipX<=borderwidth)
        {
            dx=0;
            shipX=oldx;
        }
    }
    else
    {
        if (shipY<=borderwidth)
        {
            dy=0;
            shipX = (xSize - shipWidth) / 2;  // the original position of the ship
            shipY = ySize - scoreheight - borderwidth - shipHeight;
            atLevelEnd = OP_FALSE;
        }
    }
}

static void NewPlayerFire(void)
{
    OP_INT16 i=0;
    while(i< maxBullet)  
    {
        if(!playerFires[i].active && playerFires[i].frame <= 0)
        {
            playerFires[i].x = shipX +  (OP_INT16)((shipWidth-bulWidth)/2);
            playerFires[i].y = shipY - 10;
            playerFires[i].speed = 8;
            playerFires[i].active = OP_TRUE;
           break;
        }
        i++;
    }
    canFire=OP_FALSE;
}

static void NewMissile(void)
{
    OP_UINT8 i=0;
    while(i< maxMissile)  
    {
        if(missiles[i].enemy_id < 0 && missiles[i].frame <= 0)
        {
            setMissileTarget(i);
           break;
        }
        i++;
    }
}

static void setMissileTarget(OP_UINT8 missile_id)
{
    OP_UINT8 i, j;

    missiles[missile_id].enemy_id = -1;

    if (boss.lives > 0)
    {
        missiles[missile_id].enemy_id = maxEnemies;
        missiles[missile_id].x = shipX +  (OP_INT16)((shipWidth-missileWidth)/2);
        missiles[missile_id].y = shipY - 10;
        return;
    }
    
    for(i = 0; i < maxEnemies; i++)
   {
        if (enemies[i].id >= 0 &&  enemies[i].y > 0 && enemies[i].y < shipY - 30)
        {
            for (j=0; j< maxMissile; j++)
            {
                if (missiles[j].enemy_id == i)
                {
                    break;
                }
            }
            if (j==maxMissile)
            {
                missiles[missile_id].enemy_id = i;
                missiles[missile_id].x = shipX +  (OP_INT16)((shipWidth-missileWidth)/2);
                missiles[missile_id].y = shipY - 10;
                missile_count--;    /* minus 1 from missile_count only when a new missile is produced */
                break;
            }
        }
   }

}

static void NewEnemyFire(void)
{
    OP_INT16 i, j;
    j=0;
    for(i = 0; i < maxEnemies; i++)
    {
        if(enemies[i].id >= 0 &&  
            enemies[i].id != 3 &&
            enemies[i].y > 0 &&
            (shipY > enemies[i].y + enemiesHeight[enemies[i].id]) && 
            (shipX+shipWidth+5 > enemies[i].x) && 
            (shipX < enemies[i].x + enemiesWidth[enemies[i].id]+5)&&
            enemies[i].fire==0)
        {
            while(j< maxBullet)
            {
                if(!enemyFires[j].active && enemyFires[j].frame <= 0)
                {
                    enemyFires[j].x = enemies[i].x + (enemiesWidth[enemies[i].id]-bulWidth)/2; 
                    enemyFires[j].y = enemies[i].y + enemiesHeight[enemies[i].id];
                    enemyFires[j].speed = -8;
                    enemyFires[j].active = OP_TRUE;
                    break;
                }
                j++;
            }
        }
    }
    if (boss.lives > 0)
    {
        boss.fire++;
        boss.fire %= 9;
        if (boss.fire < 3)
        {
            while(j< maxBullet)
            {
                if(!enemyFires[j].active && enemyFires[j].frame <= 0)
                {
                    enemyFires[j].x = boss.x + (bossWidth[boss.id]-bulWidth)/2; 
                    enemyFires[j].y = boss.y + bossHeight[boss.id];
                    enemyFires[j].speed = -8;
                    enemyFires[j].active = OP_TRUE;
                    break;
                }
                j++;
            }
        }
    }
}

static void moveBullet(void)
{
    OP_UINT8 i;
    for(i = 0; i < maxBullet; i++)
    {
        if(playerFires[i].active)
        {
            playerFires[i].y -= playerFires[i].speed;
            if(playerFires[i].y < 0 || playerFires[i].y > ySize - scoreheight)
            {
                DelPlayerFire(i);
            } 
        }
            
        if(enemyFires[i].active)
        {
            enemyFires[i].y -= enemyFires[i].speed;
            if(enemyFires[i].y < 0 || enemyFires[i].y > ySize - scoreheight)
            {
                DelEnemyFire(i);
            } 
           
        }
    }

    for(i=0; i< maxMissile; i++)
    {
        if(missiles[i].enemy_id < 0)
        {
            continue;
        }
        
        if(missiles[i].enemy_id==maxEnemies) /* when its target is the boss */
        {
            if(missiles[i].x < boss.x)
                missiles[i].x += 6;
            else if(missiles[i].x + missileWidth> boss.x+ bossWidth[boss.id])
                missiles[i].x -= 6;

            missiles[i].y -= 6;
            continue;
        }
        else if (enemies[missiles[i].enemy_id].id < 0)
        {
            setMissileTarget(i);
            if(missiles[i].enemy_id < 0)
            {
                missiles[i].frame = bframes;
                continue;
            }
        }
            
        if(enemies[missiles[i].enemy_id].x- missiles[i].x  + enemiesWidth[enemies[missiles[i].enemy_id].id] - missileWidth/2> 6)
        {
            missiles[i].x += 6;
        }
        else if(enemies[missiles[i].enemy_id].x - missiles[i].x  + enemiesWidth[enemies[missiles[i].enemy_id].id] - missileWidth/2 < -6)
        {
            missiles[i].x -= 6;
        }
        else
        {
            missiles[i].x = enemies[missiles[i].enemy_id].x + enemiesWidth[enemies[missiles[i].enemy_id].id] - missileWidth/2;
        }

        if(enemies[missiles[i].enemy_id].y - missiles[i].y + enemiesHeight[enemies[missiles[i].enemy_id].id] - missileHeight/2> 6)
        {
            missiles[i].y += 6;
        }
        else if(enemies[missiles[i].enemy_id].y - missiles[i].y + enemiesHeight[enemies[missiles[i].enemy_id].id] - missileHeight/2 < -6)
        {
            missiles[i].y -= 6;
        }
        else
        {
            missiles[i].y = enemies[missiles[i].enemy_id].y + enemiesHeight[enemies[missiles[i].enemy_id].id] - missileHeight/2;
        }

    }
}

static void ShowBullet(void)
{
    OP_INT16 k;

    for(k = 0; k < maxBullet; k++)
    {
        if(playerFires[k].active)
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(playerFires[k].x, playerFires[k].y, playerfire);
#else
            Games_direct_draw_icon_rm(playerFires[k].x, playerFires[k].y, playerfire);
#endif
        }
        else if (playerFires[k].frame>0)
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(playerFires[k].x, playerFires[k].y, boom[playerFires[k].frame-1]);
#else
            Games_direct_draw_icon_rm(playerFires[k].x, playerFires[k].y, boom[playerFires[k].frame-1]);
#endif
            playerFires[k].frame--;
        }
        
        if(enemyFires[k].active)
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(enemyFires[k].x, enemyFires[k].y,  enemyfire);
#else
            Games_direct_draw_icon_rm(enemyFires[k].x, enemyFires[k].y,  enemyfire);
#endif
        }
        else if (enemyFires[k].frame>0)
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(enemyFires[k].x, enemyFires[k].y, boom[enemyFires[k].frame-1]);
#else
            Games_direct_draw_icon_rm(enemyFires[k].x, enemyFires[k].y, boom[enemyFires[k].frame-1]);
#endif
            enemyFires[k].frame--;
        }
    }

    for(k=0; k< maxMissile; k++)
    {
        if(missiles[k].enemy_id >= 0)
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(missiles[k].x, missiles[k].y,  missile);
#else
            Games_direct_draw_icon_rm(missiles[k].x, missiles[k].y,  missile);
#endif
        }
        else if (missiles[k].frame>0)
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(missiles[k].x, missiles[k].y, boom[missiles[k].frame-1]);
#else
            Games_direct_draw_icon_rm(missiles[k].x, missiles[k].y, boom[missiles[k].frame-1]);
#endif
            missiles[k].frame--;
        }
    }


}

static void ShowEnemies(void)
{
    OP_INT16 i;

    for(i = 0; i < maxEnemies; i++)
    {
        if(enemies[i].id >= 0 && enemies[i].y >= (-1) * enemiesHeight[enemies[i].id] )
        {
#ifdef PACIFIC_VERSION
            ds_draw_icon_rm(enemies[i].x , enemies[i].y,  enemyID[enemies[i].id]);
#else
            Games_direct_draw_icon_rm(enemies[i].x , enemies[i].y,  enemyID[enemies[i].id]);
#endif
        }
        else  if(enemies[i].id < 0)
        {
            if (enemies[i].frame>0) 
            {
                // paint boom 
#ifdef PACIFIC_VERSION
                ds_draw_icon_rm(enemies[i].x , enemies[i].y,  boom[enemies[i].frame-1]);
#else
                Games_direct_draw_icon_rm(enemies[i].x , enemies[i].y,  boom[enemies[i].frame-1]);
#endif
                enemies[i].frame--;
            }
        }
    }
}

static void NewEnemies(void)
{
    OP_INT16 i, j;
    OP_INT16 x, y;
    OP_INT8 flag;

    if (boss.lives >  0)
        return;
    else
    {
        if ((current_level == 0 && total_enemies >= 30) ||
            (current_level == 1 && total_enemies >= 60) ||
            (current_level == 2 && total_enemies >= 100) ||
            (current_level == 3 && total_enemies >= 140) ||
            (current_level == 4 && total_enemies >= 180))
        {
            if (enemyCount == 0)
                newBoss();
            return;
        }
    }

    /*
     * if enemyMode >= 0, just use this enemyMode to produce new enemies
     */
    if (enemyMode<0) 
    {
        enemyMode=rand() % (2 + current_level);
    }

    switch (enemyMode)
    {
    case 0:
        if (cantEnemies-enemyCount>= 3)
        {
            i=0;
            j=0;
            x=10+(OP_INT16) (rand() % (xSize-20));
            y = 0;
            while(i<cantEnemies && j<3)
            {
                if(enemies[i].id < 0 && enemies[i].frame <= 0) /* if frame >0, showing the boom image */
                {