Position: All -> C/C++ -> Linux平台下基于SDL的小游戏——Bubbleman炸弹人 | 09-01-19 17:29:01
雅虎新CEO卡萝尔·巴茨正式上任Mashup中文技术资讯分享站——Mashup中国Mashupcn.com上线
Font-Size:
Large | Middle | Small

这个小游戏是上学期和另外3个同学一起做的，今天把代码稍微完善了一下，去掉了废代码，虽然游戏画面很烂，可玩性也很低，但毕竟是第一次摸索着做了个游戏哈，发到博客上留个纪念

游戏的英文名叫Bubbleman，直译是泡泡人而不是炸弹人……这是由于历史原因造成的，就不改了……

此游戏只能在Linux下面运行，windows下面跑不了，并且需要安装SDL库的支持（比较新的Linux版本都会在装系统时附带安装），可执行程序已编译好，名为bm，若要自行编译，则需要在shell下输入命令：

gcc bubbleman.c -lSDL -lSDL_image -o xxx

今天博客新增了C/C++分类，也就顺便把这篇文章发到这个分类下

程序功能：

炸弹部分：
1 在屏幕没有炸弹时要定时随机播撒不同数量的炸弹。
2 炸弹未爆炸前，要阻止人通行。
3 出现炸弹后，在一定时间间隔后爆炸。
4 炸弹爆炸后要显示火焰，并判断是否炸到玩家
5为玩家提供相关的参数变化的信号。

时间部分和道具部分：
1 设置时间响应，近似产生1s的时钟滴答。
2 显示游戏时间
3 道具（鞋和药箱，有使人物速度和生命值增强的效果）的出现，消失，和人物接触检测和销毁。
4 生命值和速度值的同步显示

人物部分：
1 人可以朝上下左右四个方向行走，并在行走时动态显示相应方向的人物图片
2 炸弹炸到人物变灰数秒，表示人物受伤
3 人物不能走出指定区域，炸弹爆炸前人物不能越过炸弹
4 人物有生命值，生命值为0时游戏结束
   
游戏特效部分：
1 添加图片，以实现在游戏中的动画效果及游戏主题
2 游戏中的炸弹变脸
3 玩家在被炸弹炸到时的动画效果
4 炸弹的威力，设定两个炸弹等级。

游戏截图：

程序只有一个.c文件 ，一群人图快，变量名起得很烂……

C++代码
  1. #include<SDL/SDL.h>   
  2. #include<SDL/SDL_image.h>   
  3. #include<math.h>   
  4. #include<time.h>   
  5.   
  6. //图片路径定义   
  7. #define IMG_PLAYER1 "image/boy2.bmp"   
  8. #define IMG_INJURED "image/boy2_injured.bmp"   
  9. #define IMG_BUBBLE  "image/bomb.png"   
  10. #define IMG_BG          "image/bg4.bmp"   
  11. #define IMG_FLAME2  "image/flame2.png"   
  12. #define IMG_FLAME4  "image/flame4.png"   
  13. #define IMG_GAMEOVER "image/gameover.gif"   
  14. #define IMG_MEDICINE "pics/medicine.bmp"   
  15. #define IMG_SHOES "pics/shoe.bmp"   
  16. #define IMG_LIFE "./pics/time.gif"   
  17. #define IMG_SPEED "./pics/time.gif"   
  18. #define IMG_WORD "./pics/word.bmp"   
  19. #define IMG_TIME "./pics/time.gif"   
  20.   
  21. //方向定义   
  22. #define DIR_UP 3   
  23. #define DIR_LEFT 1   
  24. #define DIR_DOWN 0   
  25. #define DIR_RIGHT 2   
  26.   
  27. #define MAIN_ZONE_W 520   
  28. #define MAIN_ZONE_H 480   
  29.   
  30. #define ATTACK 2   
  31. #define INTERVAL 30   
  32.   
  33. #define BUBBLE_NUM 62   
  34. #define RAND_MAX 65536   
  35. #define WaitTime 10   
  36. #define ExistTime 5   
  37.   
  38. //游戏中的人物   
  39. typedef struct _Player {   
  40.     int w;   
  41.     int h;   
  42.     int x;   
  43.     int y;   
  44.     int ox;   
  45.     int oy;   
  46.     int dir;   
  47.     int subframe;   
  48.     int speed;   
  49.     int life;   
  50.     int timer;   
  51.     SDL_Surface *image;   
  52. }Player;   
  53.   
  54. typedef struct _Bubble {   
  55.     int w;   
  56.     int h;   
  57.     int x;   
  58.     int y;   
  59.     int subframe;   
  60.     int timer;   
  61.     int level;   
  62.     SDL_Surface *image;   
  63. }Bubble;   
  64.   
  65. //各种附加工具的添加 此处用1代表是药炉 可添加一条命   
  66. //此处用0代表是鞋 可使速度加1   
  67. typedef struct _Tool{   
  68.     int w;   
  69.     int h;   
  70.     int x;   
  71.     int y;   
  72.     int type;//0是鞋 1是药炉   
  73.     int already_exist_time;//代表已经出现的时间   
  74.     int WaitForNext;//代表下一个物品出现的时间还有多久   
  75.     int flag;//代表是否有效   
  76.     SDL_Surface *image[2];   
  77. }Tool;   
  78.   
  79. //游戏状态   
  80. typedef enum _GameState {   
  81.     GAME_RUNNING,   
  82.     GAME_OVER,   
  83. }GameState;   
  84.   
  85. //全局变量   
  86.   
  87. int second[2],minute[2];   
  88. SDL_Surface *screen;    //整个屏幕   
  89. SDL_Surface *back_image;   
  90. SDL_Surface *player_image;   
  91. SDL_Surface *injured_image;   
  92. SDL_Surface *medicine_image;   
  93. SDL_Surface *shoes_image;   
  94. SDL_Surface *life_image;   
  95. SDL_Surface *speed_image;   
  96. SDL_Surface *word_image;   
  97.   
  98. GameState game_state;   
  99. Player player1;   
  100. Bubble bubble[BUBBLE_NUM];   
  101. Tool MedOrShoes;   
  102.   
  103. int current_num;   
  104. int boom;               //当前屏幕上是否有泡泡   
  105. int erase;   
  106. int injured;   
  107. int g_timer=-1;   
  108. int away;   
  109. int interval=5;   
  110. int oldlife=3;   
  111. int oldspeed;   
  112.   
  113.   
  114. //加锁   
  115. void Slock(SDL_Surface *lock){   
  116.     if(SDL_MUSTLOCK(lock)){   
  117.         if(SDL_LockSurface(lock)<0){   
  118.             return;   
  119.         }   
  120.     }   
  121. }   
  122.   
  123. /*解锁*/  
  124. void Sulock(SDL_Surface *lock){   
  125.     if(SDL_MUSTLOCK(lock)){   
  126.         SDL_UnlockSurface(lock);   
  127.     }   
  128. }   
  129.   
  130. //初始化SDL   
  131. void Init_SDL() {   
  132.     if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {   
  133.         exit(1);   
  134.     }   
  135.     screen = SDL_SetVideoMode(640,480,16,SDL_SWSURFACE);   
  136.     if(screen == NULL) {   
  137.         exit(1);   
  138.     }   
  139. }   
  140.   
  141. //Tool函数初始化   
  142. void Init_Tools(){   
  143.     MedOrShoes.x=0;   
  144.     MedOrShoes.y=0;   
  145.     MedOrShoes.w=30;   
  146.     MedOrShoes.h=30;   
  147.     MedOrShoes.type=0;//最先初始化为鞋   
  148.     MedOrShoes.flag=0;//最初无效   
  149.     MedOrShoes.already_exist_time=0;//出险多于..s还没被吃掉则擦掉   
  150.     MedOrShoes.WaitForNext = WaitTime;//每..s出现一个物品     
  151.   
  152.   
  153.     medicine_image = IMG_Load(IMG_MEDICINE);   
  154.     medicine_image = SDL_DisplayFormat(medicine_image);   
  155.   
  156.     shoes_image = IMG_Load(IMG_SHOES);   
  157.     shoes_image = SDL_DisplayFormat(shoes_image);   
  158.   
  159.     MedOrShoes.image[0]=shoes_image;   
  160.     MedOrShoes.image[1]=medicine_image;   
  161.        
  162.     SDL_SetColorKey(MedOrShoes.image[0],SDL_SRCCOLORKEY,SDL_MapRGB(MedOrShoes.image[0]->format,255,255,255));   
  163.     SDL_SetColorKey(MedOrShoes.image[1],SDL_SRCCOLORKEY,SDL_MapRGB(MedOrShoes.image[1]->format,255,255,255));   
  164. }   
  165.   
  166. //随机产生工具位置   
  167. void RandToolPos() {   
  168.     srand((int)time(NULL));   
  169.     int i;   
  170.     MedOrShoes.x = ((int)rand() % (MAIN_ZONE_W - 90))/30*30;   
  171.     MedOrShoes.y = ((int)rand() % (MAIN_ZONE_H - 30))/30*30;   
  172. }   
  173. //画工具   
  174. void DrawTool(SDL_Surface *surface, Tool *tool) {   
  175.     SDL_Rect s_rect,d_rect;   
  176.     s_rect.w = d_rect.w = tool->w;   
  177.     s_rect.h = d_rect.h = tool->h;   
  178.     s_rect.x = 0;   
  179.     s_rect.y = 0;   
  180.     d_rect.x = tool->x;   
  181.     d_rect.y = tool->y;   
  182.     SDL_BlitSurface(tool->image[tool->type],&s_rect,surface,&d_rect);   
  183. }   
  184.   
  185. //清除工具   
  186. void ClearTool(SDL_Surface *surface, Tool *tool) {   
  187.     SDL_Rect mask;   
  188.     mask.w = tool->w;   
  189.     mask.h = tool->h;   
  190.     mask.x = tool->x;   
  191.     mask.y = tool->y;   
  192.     Slock(screen);   
  193.     SDL_BlitSurface(back_image,&mask,surface,&mask);   
  194.     Sulock(screen);   
  195. }   
  196. //检测是否吃到了工具   
  197. int Eat_detect()   
  198. {   
  199.     if(abs(MedOrShoes.x-player1.x)<30&&abs(MedOrShoes.y-player1.y)<30){   
  200.         //吃到了   
  201.         //printf("eat\n");   
  202.         return 1;   
  203.     }   
  204.     return 0;   
  205. }   
  206.   
  207. void Init_Player() {   
  208.     player1.dir = DIR_RIGHT;   
  209.     player1.w = 30;   
  210.     player1.h = 30;   
  211.     player1.x = 120;   
  212.     player1.y = 120;   
  213.     player1.ox = player1.x;   
  214.     player1.oy = player1.y;   
  215.     player1.speed = 3;   
  216.     player1.life = 3;   
  217.     player1.timer = 0;   
  218.     injured = 0;   
  219.     player_image = IMG_Load(IMG_PLAYER1);   
  220.     injured_image = IMG_Load(IMG_INJURED);   
  221.     player_image = SDL_DisplayFormat(player_image);   
  222.     injured_image = SDL_DisplayFormat(injured_image);   
  223.     //载入人物图片并设置白色为背景色   
  224.     player1.image = player_image;   
  225.     SDL_SetColorKey(player1.image,SDL_SRCCOLORKEY,SDL_MapRGB(player1.image->format,255,255,255));   
  226. }   
  227.   
  228. void Init_speed()   
  229. {   
  230.     life_image = IMG_Load(IMG_LIFE);   
  231.     life_image = SDL_DisplayFormat(life_image);   
  232.     //SDL_SetColorKey(life_image,SDL_SRCCOLORKEY,SDL_MapRGB(life_image->format,255,255,255));   
  233. }   
  234.   
  235. void Drawlife(SDL_Surface *surface) {   
  236.     SDL_Rect source,show_dest;     
  237.     source.y=240;   
  238.     source.x=550;   
  239.     source.w=show_dest.w=15;   
  240.     source.h=show_dest.h=30;   
  241.     show_dest.x=550;   
  242.     show_dest.y=240;   
  243.     SDL_BlitSurface(back_image,&source,screen,&show_dest);   
  244.     source.y=0;   
  245.     source.x=10+15*player1.life;   
  246.     //SDL_SetColorKey(life_image,SDL_SRCCOLORKEY,SDL_MapRGB(life_image->format,255,255,255));   
  247.     SDL_BlitSurface(life_image,&source,screen,&show_dest);   
  248. }   
  249.   
  250. void Init_life()   
  251. {   
  252.     speed_image = IMG_Load(IMG_SPEED);   
  253.     speed_image = SDL_DisplayFormat(speed_image);   
  254.     //SDL_SetColorKey(life_image,SDL_SRCCOLORKEY,SDL_MapRGB(life_image->format,255,255,255));   
  255.     word_image=IMG_Load(IMG_WORD);   
  256.     word_image = SDL_DisplayFormat(word_image);   
  257.     SDL_SetColorKey(word_image,SDL_SRCCOLORKEY,SDL_MapRGB(word_image->format,255,255,255));   
  258. }   
  259.   
  260. void Drawspeed(SDL_Surface *surface) {   
  261.     SDL_Rect source,show_dest;   
  262.     source.y=340;   
  263.     source.x=550;   
  264.     source.w=show_dest.w=15;   
  265.     source.h=show_dest.h=30;   
  266.     show_dest.x=550;   
  267.     show_dest.y=340;   
  268.     SDL_BlitSurface(back_image,&source,screen,&show_dest);   
  269.     source.y=0;   
  270.     source.x=10+15*player1.speed;   
  271.     //SDL_SetColorKey(speed_image,SDL_SRCCOLORKEY,SDL_MapRGB(speed_image->format,255,255,255));   
  272.     SDL_BlitSurface(speed_image,&source,screen,&show_dest);   
  273. }      
  274. void Draw_words(SDL_Surface *surface){   
  275.     SDL_Rect source,show_dest;   
  276.     source.y=200;   
  277.     source.x=530;   
  278.     source.w=show_dest.w=90;   
  279.     source.h=show_dest.h=30;   
  280.     show_dest.x=530;   
  281.     show_dest.y=200;   
  282.     SDL_BlitSurface(back_image,&source,screen,&show_dest);   
  283.     source.y=0;   
  284.     source.x=0;   
  285.     show_dest.x=530;   
  286.     show_dest.y=200;   
  287.     SDL_BlitSurface(word_image,&source,screen,&show_dest);   
  288.   
  289.     source.y=300;   
  290.     source.x=530;   
  291.     source.w=show_dest.w=90;   
  292.     source.h=show_dest.h=30;   
  293.     show_dest.x=530;   
  294.     show_dest.y=300;   
  295.     SDL_BlitSurface(back_image,&source,screen,&show_dest);   
  296.     source.y=30;   
  297.     source.x=0;   
  298.     show_dest.x=530;   
  299.     show_dest.y=300;   
  300.     SDL_BlitSurface(word_image,&source,screen,&show_dest);   
  301.   
  302.     source.y=100;   
  303.     source.x=530;   
  304.     source.w=show_dest.w=90;   
  305.     source.h=show_dest.h=30;   
  306.     show_dest.x=530;   
  307.     show_dest.y=100;   
  308.     SDL_BlitSurface(back_image,&source,screen,&show_dest);   
  309.     source.y=60;   
  310.     source.x=0;   
  311.     show_dest.x=530;   
  312.     show_dest.y=100;   
  313.     SDL_BlitSurface(word_image,&source,screen,&show_dest);   
  314.   
  315.        
  316. }   
  317.   
  318. void Init_Bubble() {   
  319.     int i;   
  320.     for(i = 0;i < BUBBLE_NUM;i++) {   
  321.         bubble[i].w = 30;   
  322.         bubble[i].h = 30;   
  323.         bubble[i].level = ATTACK;   
  324.         if(i%5==0) bubble[i].level = 2*ATTACK;   
  325.         bubble[i].timer = 0;   
  326.         bubble[i].image = IMG_Load(IMG_BUBBLE);   
  327.         SDL_SetColorKey(bubble[i].image,SDL_SRCCOLORKEY,SDL_MapRGB(bubble[i].image->format,255,255,255));   
  328.         bubble[i].image = SDL_DisplayFormat(bubble[i].image);   
  329.     }   
  330.     current_num = 0;   
  331. }   
  332.   
  333. void DrawFlame(SDL_Surface *surface, Bubble *bubble) {   
  334.     //这个函数想画出炸弹爆炸后四周的火焰,目前还不对   
  335.     int i;   
  336.     int level = bubble->level;   
  337.     SDL_Rect s_rect,d_rect;   
  338.     SDL_Surface *flame_image;   
  339.     if(bubble->level == ATTACK)   
  340.         flame_image = IMG_Load(IMG_FLAME2);   
  341.     else if(bubble->level == 2*ATTACK)   
  342.         flame_image = IMG_Load(IMG_FLAME4);   
  343.     SDL_SetColorKey(flame_image,SDL_SRCCOLORKEY,SDL_MapRGB(flame_image->format,255,255,255));   
  344.     flame_image = SDL_DisplayFormat(flame_image);      
  345.     s_rect.w = d_rect.w = bubble->w+bubble->w*2*level;   
  346.     s_rect.h = d_rect.h = bubble->h+bubble->h*2*level;   
  347.     s_rect.x = 0;   
  348.     s_rect.y = 0;       
  349.     d_rect.x = bubble->x-bubble->w*level;   
  350.     d_rect.y = bubble->y-bubble->h*level;   
  351.     SDL_BlitSurface(flame_image,&s_rect,surface,&d_rect);   
  352. }   
  353.   
  354. void DrawFlames(SDL_Surface *surface) {   
  355.     int i;   
  356.     for(i = 0;i < current_num;i++) {   
  357.         DrawFlame(surface,&bubble[i]);   
  358.     }   
  359. }   
  360.   
  361. //画出人物   
  362. void DrawPlayer(SDL_Surface *surface, Player *player) {   
  363.     SDL_Rect s_rect,d_rect;   
  364.     player->subframe = player->timer/4;   
  365.     s_rect.w = d_rect.w = player->w;   
  366.     s_rect.h = d_rect.h = player->h;   
  367.     s_rect.x = player->subframe * player->w;   
  368.     s_rect.y = player->dir * player->h;   
  369.     d_rect.x = player->x;   
  370.     d_rect.y = player->y;   
  371.     player->image = injured ? injured_image : player_image;   
  372.     SDL_SetColorKey(player->image,SDL_SRCCOLORKEY,SDL_MapRGB(player->image->format,255,255,255));   
  373.     SDL_BlitSurface(player->image,&s_rect,surface,&d_rect);   
  374. }   
  375.   
  376. void DrawBubble(SDL_Surface *surface, Bubble *bubble) {   
  377.     SDL_Rect s_rect,d_rect;   
  378.     bubble->subframe = bubble->timer;   
  379.     s_rect.w = d_rect.w = bubble->w;   
  380.     s_rect.h = d_rect.h = bubble->h;   
  381.     s_rect.x = bubble->subframe * bubble->w;   
  382.     s_rect.y = 0;   
  383.     d_rect.x = bubble->x;   
  384.     d_rect.y = bubble->y;   
  385.     SDL_BlitSurface(bubble->image,&s_rect,surface,&d_rect);   
  386. }   
  387.   
  388. void DrawBubbles(SDL_Surface *surface) {   
  389.     int i;   
  390.     for(i = 0;i < current_num;i++) {   
  391.         DrawBubble(surface,&bubble[i]);   
  392.     }   
  393. }   
  394.   
  395. //清除人物   
  396. void ClearPlayer(SDL_Surface *surface, Player *player) {   
  397.     SDL_Rect mask;   
  398.     mask.w = player->w;   
  399.     mask.h = player->h;   
  400.     mask.x = player->ox;   
  401.     mask.y = player->oy;   
  402.     //SDL_FillRect(surface,&mask,SDL_MapRGB(surface->format,255,255,255));   
  403.     Slock(screen);SDL_BlitSurface(back_image,&mask,surface,&mask);Sulock(screen);   
  404. }   
  405.   
  406. void ClearBubble(SDL_Surface *surface, Bubble *bubble) {   
  407.     SDL_Rect mask;   
  408.     mask.w = bubble->w;   
  409.     mask.h = bubble->h;   
  410.     mask.x = bubble->x;   
  411.     mask.y = bubble->y;   
  412.     SDL_FillRect(surface,&mask,SDL_MapRGB(surface->format,255,255,255));   
  413. }   
  414.   
  415. void ClearBubbles(SDL_Surface *surface) {   
  416.     int i;   
  417.     for(i = 0;i < current_num;i++) {   
  418.         ClearBubble(surface,&bubble[i]);    
  419.     }   
  420. }   
  421.   
  422. void ClearFlame(SDL_Surface *surface, Bubble *bubble) {   
  423.     int level=bubble->level;   
  424.     int i;   
  425.     SDL_Rect mask;   
  426.     /*  
  427.     mask.w = bubble->w + bubble->w * level * 2;  
  428.     mask.h = bubble->h;  
  429.     mask.x = bubble->x - bubble->w * level;  
  430.     mask.y = bubble->y;  
  431.     SDL_FillRect(surface,&mask,SDL_MapRGB(surface->format,255,255,255));  
  432.     mask.w = bubble->w;  
  433.     mask.h = bubble->h + bubble->h * level*2;  
  434.     mask.x = bubble->x;  
  435.     mask.y = bubble->y - bubble->h * level;  
  436.     */  
  437.     SDL_Rect s_rect,d_rect;   
  438.     mask.w = bubble->w+bubble->w*2*level;   
  439.     mask.h = bubble->h+bubble->h*2*level;    
  440.     mask.x = bubble->x-bubble->w*level;   
  441.     mask.y = bubble->y-bubble->h*level;   
  442.     //SDL_FillRect(surface,&d_rect,SDL_MapRGB(surface->format,255,255,255));   
  443.     Slock(screen);SDL_BlitSurface(back_image,&mask,surface,&mask);Sulock(screen);   
  444. }   
  445.   
  446. void ClearFlames(SDL_Surface *surface) {   
  447.     int i;   
  448.     for(i = 0;i < current_num;i++) {   
  449.         ClearFlame(surface,&bubble[i]);    
  450.     }   
  451. }   
  452.   
  453. void RandBubblePos() {   
  454.     srand((int)time(NULL));   
  455.     int i;   
  456.     for(i = 0;i < current_num;i++) {   
  457.         bubble[i].x = ((int)rand() % (MAIN_ZONE_W-15))/30*30;   
  458.         bubble[i].y = ((int)rand() % (MAIN_ZONE_H ))/30*30;   
  459.     }   
  460. }   
  461.   
  462. void MoveBack(int dir)   
  463. {   
  464.  Slock(screen);   
  465.  switch(dir)   
  466.  {   
  467.   case DIR_LEFT:   
  468.     if(player1.x+30<=MAIN_ZONE_W)player1.x+=30;   
  469.     else player1.x=MAIN_ZONE_W;   
  470.         break;   
  471.   case DIR_RIGHT:   
  472.     if(player1.x-30>=0)player1.x-=30;   
  473.     else player1.x=0;   
  474.         break;   
  475.   case DIR_UP:   
  476.     if(player1.y+30<=MAIN_ZONE_H)player1.y+=30;   
  477.     else player1.y=MAIN_ZONE_H;   
  478.        break;   
  479.   case DIR_DOWN:   
  480.        if(player1.y-30>=0)player1.y-=30;   
  481.     else player1.y=0;   
  482.        break;   
  483.   
  484.  }   
  485.   
  486.  Sulock(screen);   
  487. }   
  488.   
  489. void Explode()   
  490. {   
  491.     if(away==1)return;   
  492.   
  493.     if(g_timer==interval){   
  494.         void GameOver();   
  495.         g_timer=0;   
  496.         static int t=0;   
  497.   
  498.         if(boom == 0 && erase==0) {//no bubbles and flames are cleared   
  499.             t=0;injured = 0;   
  500.             boom = 1 - boom; //switch on and show the bubbles   
  501.                
  502.             current_num += 3;   
  503.             if(current_num > 60) current_num = 60;   
  504.   
  505.             interval-=1;   
  506.             if(interval<2){interval=2;}   
  507.             RandBubblePos();   
  508.             Slock(screen);   
  509.             DrawBubbles(screen);   
  510.                         Sulock(screen);   
  511.             }    
  512.         else if(boom==1&&erase == 0) {   
  513.         //bubbles now explode and no flames need to clear   
  514.             boom = 1 - boom;   
  515.             Slock(screen);   
  516.             ClearBubbles(screen);   
  517.             if(HitDetect(&player1)==1) {   
  518.                 if(boom==0)MoveBack(player1.dir);   
  519.                 injured = 1;   
  520.                 player1.life--;   
  521.                 printf("%d\n",player1.dir);   
  522.             }   
  523.             DrawFlames(screen);   
  524.             erase = 1;//switch on to clear flames signal   
  525.             Sulock(screen);    
  526.             }   
  527.     }   
  528.     if(erase==1){   
  529.         if(g_timer==1){   
  530.             ClearFlames(screen);   
  531.             //ClearFlamesPos();   
  532.                 erase = 0;   
  533.         }          
  534.     }   
  535.   
  536.   
  537. }   
  538.   
  539. int HitDetect(Player *player)   
  540. {   
  541.     int x = player->x;   
  542.     int y = player->y;   
  543.     int ex,ey,level;   
  544.     int i,r;   
  545.     for(i = 0;i < current_num;i++) {   
  546.         ex = bubble[i].x;   
  547.         ey = bubble[i].y;   
  548.         level = bubble[i].level * INTERVAL;   
  549.         if(y - ey < 30 && ey - y < 30) {   
  550.             if(x - ex < 30 + level && ex - x < level)   
  551.                 return 1;   
  552.         }   
  553.         if(x - ex < 30 && ex - x < 30)  {   
  554.             if(y - ey < 30 + level && ey - y < level)   
  555.                 return 1;   
  556.         }   
  557.     }   
  558.     return 0;   
  559. }   
  560.   
  561. //碰撞检测,返回1表示移动受阻碍   
  562. int BumpDetect(int dir) {   
  563.     Slock(screen);   
  564.     int i;   
  565.     if(boom == 0) return 0;   
  566.   
  567.     int nx,ny;   
  568.   
  569.     switch(dir) {   
  570.     case DIR_LEFT:   
  571.         for(i = 0;i < current_num;i++) {   
  572.             if(player1.x-bubble[i].x<=33&&player1.x-bubble[i].x>=1)   
  573.             if(bubble[i].y-player1.y<29&&bubble[i].y-player1.y>-29)   
  574.                 {//player1.x++;   
  575.                 if(bubble[i].y-player1.y>20)player1.y--;   
  576.                 else if(bubble[i].y-player1.y<-20)player1.y++;   
  577.                 return 1;}   
  578.         }   
  579.         break;   
  580.   
  581.     case DIR_RIGHT:   
  582.         for(i = 0;i < current_num;i++) {   
  583.             if(bubble[i].x-player1.x<=33&&bubble[i].x-player1.x>=1)   
  584.             if(bubble[i].y-player1.y<29&&bubble[i].y-player1.y>-29)   
  585.                 {//player1.x--;   
  586.                 if(bubble[i].y-player1.y>20)player1.y--;   
  587.                 else if(bubble[i].y-player1.y<-20)player1.y++;   
  588.                 return 1;}   
  589.         }   
  590.         break;   
  591.   
  592.     case DIR_UP:   
  593.         for(i = 0;i < current_num;i++) {   
  594.             if(player1.y-bubble[i].y<=33&&player1.y-bubble[i].y>=1)   
  595.             if(bubble[i].x-player1.x>-29&&bubble[i].x-player1.x<29)   
  596.                 {player1.y+=player1.speed;   
  597.                 if(bubble[i].x-player1.x>20)player1.x--;   
  598.                 else if(bubble[i].x-player1.x<-20)player1.x++;   
  599.                 return 1;}   
  600.         }   
  601.         break;   
  602.   
  603.     case DIR_DOWN:   
  604.         for(i = 0;i < current_num;i++) {   
  605.             if(bubble[i].y-player1.y<=33&&bubble[i].y-player1.y>=1)   
  606.             if(bubble[i].x-player1.x>-29&&bubble[i].x-player1.x<29)   
  607.                 {player1.y-=player1.speed;   
  608.                 if(bubble[i].x-player1.x>20)player1.x--;   
  609.                 else if(bubble[i].x-player1.x<-20)player1.x++;   
  610.                 return 1;}   
  611.         }   
  612.         break;   
  613.     }   
  614.     Sulock(screen);   
  615.     return 0;   
  616. }   
  617.   
  618. //人是否走出了屏幕,若走出返回1   
  619. int RangeDetect(Player *player) {   
  620.     int x = player->x;   
  621.     int y = player->y;   
  622.     if(x > MAIN_ZONE_W - player->w - 1) {   
  623.         player->x = MAIN_ZONE_W - player->w - 1;   
  624.         return 1;   
  625.     }   
  626.     if(x < 0) {   
  627.         player->x = 0;   
  628.         return 1;   
  629.     }   
  630.     if(y > MAIN_ZONE_H - player->h) {   
  631.         player->y = MAIN_ZONE_H - player->h;   
  632.         return 1;   
  633.     }   
  634.     if(y < 0)   {      
  635.         player->y = 0;   
  636.         return 1;   
  637.     }   
  638.     return 0;   
  639. }   
  640.   
  641.   
  642. Uint32 time_show(){    
  643.     SDL_Surface *time_image;   
  644.     time_image=IMG_Load(IMG_TIME);   
  645.     SDL_Rect time_dest,show_dest;   
  646.   
  647.     /*显示初始化*/          
  648.     int x=550,y=125;   
  649.     show_dest.x=x; show_dest.y=y;   
  650.     show_dest.h=30;   
  651.   
  652.     time_dest.y=0;   
  653.     time_dest.h=30;   
  654.     //:显示   
  655.     time_dest.x=0; show_dest.x=x+30;   
  656.     time_dest.w=show_dest.w=10;   
  657.     //Slock(screen);       
  658.     SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  659.     //秒显示      
  660.     //SDL_Flip(screen);   
  661.     //Sulock(screen);   
  662.   
  663.     show_dest.w=time_dest.w=15;   
  664.     int i;   
  665.     for(i=0;i<2;i++)   
  666.         second[i]=minute[i]=0;   
  667.   
  668.     //Slock(screen);   
  669.             time_dest.x=10+15*second[0];show_dest.x=x+55;   
  670.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  671.             time_dest.x=10+15*second[1]; show_dest.x=x+40;   
  672.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  673.             time_dest.x=10+15*minute[0];show_dest.x=x+15;   
  674.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  675.             time_dest.x=10+15*minute[1];show_dest.x=x;   
  676.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  677.             //SDL_Flip(screen);   
  678.     //Sulock(screen);   
  679.     while(game_state == GAME_RUNNING){   
  680.         //首先做工具部分处理   
  681.         MedOrShoes.WaitForNext--;   
  682.         MedOrShoes.already_exist_time++;   
  683.         if(MedOrShoes.already_exist_time==ExistTime&&MedOrShoes.flag==1){   
  684.             MedOrShoes.flag=0;   
  685.             ClearTool(screen,&MedOrShoes);   
  686.         }   
  687.         if(MedOrShoes.WaitForNext==0){   
  688.             MedOrShoes.type=1-MedOrShoes.type;   
  689.             MedOrShoes.already_exist_time=0;   
  690.             MedOrShoes.WaitForNext=WaitTime;   
  691.             MedOrShoes.flag=1;   
  692.             RandToolPos();   
  693.             DrawTool(screen,&MedOrShoes);   
  694.         }   
  695.   
  696.         //考虑一下生命值 避免刷屏遮盖生命   
  697.         Drawlife(screen);   
  698.         //考虑一下速度值 避免刷屏遮盖速度   
  699.         Drawspeed(screen);   
  700.         Draw_words(screen);   
  701.   
  702.         g_timer++;/*全局数据*/  
  703.            
  704.         //作时间部分处理   
  705.         SDL_Delay(950);   
  706.         bubble[0].timer=1-bubble[0].timer;   
  707.         for(i=1;i<current_num;i++)bubble[i].timer=1-bubble[i-1].timer;   
  708.         if(boom==1)DrawBubbles(screen);   
  709.   
  710.         time_dest.x=0; show_dest.x=x+30;   
  711.         time_dest.w=show_dest.w=10;   
  712.         SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  713.   
  714.             time_dest.w=15;   
  715.             show_dest.w=30;show_dest.x=x;   
  716.             SDL_BlitSurface(back_image,&show_dest,screen,&show_dest);   
  717.             show_dest.w=30;show_dest.x=x+40;   
  718.         SDL_BlitSurface(back_image,&show_dest,screen,&show_dest);   
  719.             show_dest.w=15;   
  720.     //Slock(screen);   
  721.             time_dest.x=10+15*second[0];show_dest.x=x+55;   
  722.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  723.             time_dest.x=10+15*second[1]; show_dest.x=x+40;   
  724.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  725.             time_dest.x=10+15*minute[0];show_dest.x=x+15;   
  726.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  727.             time_dest.x=10+15*minute[1];show_dest.x=x;   
  728.             SDL_BlitSurface(time_image,&time_dest,screen,&show_dest);   
  729.   
  730.             //SDL_Flip(screen);   
  731.     //Sulock(screen);   
  732.                
  733.             second[0]++;   
  734.             if(second[0]==10){   
  735.                 second[1]++;   
  736.                 second[0]=0;}   
  737.             if(second[1]==6){   
  738.                 second[1]=0;   
  739.                 minute[0]++;}   
  740.             if(minute[0]==10){   
  741.                 minute[1]++;   
  742.                 minute[0]=0;}   
  743.             if(minute[1]==6){   
  744.                 minute[0]=minute[1]=second[1]=second[0]=0;   
  745.   
  746.            
  747.         }   
  748.        
  749.     Explode();   
  750.     }   
  751.     return 0;   
  752. }   
  753.   
  754. void GamePlay() {   
  755.     void GameOver();   
  756.     second[0] = second[1] = minute[0] = minute[1] = 0;   
  757.     back_image = IMG_Load(IMG_BG);   
  758.     SDL_BlitSurface(back_image,0,screen,0);   
  759.     Init_Player();   
  760.     Init_Bubble();   
  761.     Init_Tools();   
  762.     Init_life();   
  763.     Init_speed();   
  764.     SDL_UpdateRect(screen,0,0,0,0);   
  765.   
  766.     SDL_SetTimer(10,time_show);   
  767.   
  768.     Uint32 start_time,end_time;   
  769.     int i;   
  770.     start_time = SDL_GetTicks();   
  771.     boom = 0;   
  772.     erase=0;   
  773.     away=0;   
  774.     game_state = GAME_RUNNING;   
  775.     RandToolPos();   
  776.     DrawTool(screen,&MedOrShoes);   
  777.     Drawlife(screen);   
  778.     MedOrShoes.flag=1;   
  779.     while(game_state == GAME_RUNNING) {   
  780.         SDL_Event event1;   
  781.         ClearPlayer(screen,&player1);      
  782.         SDL_PollEvent(&event1);   
  783.         switch(event1.type) {   
  784.         case SDL_KEYDOWN:   
  785.             if(RangeDetect(&player1)) break;   
  786.             switch(event1.key.keysym.sym) {   
  787.             case SDLK_UP:    
  788.                 if(BumpDetect(DIR_UP)) break;   
  789.                 player1.dir = DIR_UP;   
  790.                 player1.y -= player1.speed;   
  791.                 break;   
  792.             case SDLK_DOWN:    
  793.                 if(BumpDetect(DIR_DOWN)) break;    
  794.                 player1.dir = DIR_DOWN;   
  795.                 player1.y += player1.speed;   
  796.                 break;   
  797.             case SDLK_LEFT:   
  798.                 if(BumpDetect(DIR_LEFT)) break;   
  799.                 player1.dir = DIR_LEFT;   
  800.                 player1.x -= player1.speed;   
  801.                 break;   
  802.             case SDLK_RIGHT:    
  803.                 if(BumpDetect(DIR_RIGHT)) break;   
  804.                 player1.dir = DIR_RIGHT;   
  805.                 player1.x += player1.speed;   
  806.                 break;   
  807.             case SDLK_ESCAPE:   
  808.                 game_state = GAME_OVER;   
  809.                 away=1;   
  810.                 GameOver();   
  811.                 break;   
  812.             }   
  813.         }   
  814.   
  815.         DrawPlayer(screen, &player1);   
  816.         player1.ox = player1.x;   
  817.         player1.oy = player1.y;   
  818.   
  819.         SDL_UpdateRect(screen,0,0,0,0);   
  820.   
  821.         if(MedOrShoes.flag==1)   
  822.             if(Eat_detect()){   
  823.             MedOrShoes.flag=0;   
  824.             ClearTool(screen,&MedOrShoes);   
  825.             if(MedOrShoes.type==1)   
  826.                 {   
  827.                   if(player1.life<9)   
  828.                     player1.life++;}   
  829.             else    {   
  830.                   if(player1.speed<9)   
  831.                     player1.speed++;}   
  832.             //printf("life %d\n",player1.life);   
  833.             //printf("speed %d\n",player1.speed);   
  834.             }   
  835.             else{   
  836.                 DrawTool(screen,&MedOrShoes);              
  837.                 }   
  838.   
  839.         //考虑一下生命值   
  840.         if(player1.life!=oldlife){   
  841.             oldlife=player1.life;   
  842.             Drawlife(screen);   
  843.         }   
  844.   
  845.         //考虑一下速度值   
  846.         if(player1.speed!=oldspeed){   
  847.             oldspeed=player1.speed;   
  848.             Drawspeed(screen);   
  849.         }   
  850.                
  851.   
  852.         if(player1.life == 0) {   
  853.                 SDL_Delay(2000);   
  854.                 game_state = GAME_OVER;   
  855.                 GameOver();   
  856.             }   
  857.   
  858.         if(++player1.timer >= 8)    
  859.             player1.timer = 0;   
  860.   
  861.     }   
  862. }   
  863.   
  864. void GameOver() {   
  865.     SDL_Surface *gameover_image = IMG_Load(IMG_GAMEOVER);   
  866.   
  867.     SDL_BlitSurface(gameover_image,0,screen,0);   
  868.   
  869.     SDL_Flip(screen);   
  870.   
  871.     while(1) {   
  872.   
  873.         SDL_Event event;   
  874.   
  875.         while(SDL_PollEvent(&event)) {   
  876.   
  877.             if(event.type == SDL_KEYDOWN)   
  878.   
  879.             if((event.key.keysym.sym == SDLK_ESCAPE)) {   
  880.   
  881.                 SDL_FreeSurface(gameover_image);    
  882.                 SDL_FreeSurface(player1.image);   
  883.                 SDL_FreeSurface(back_image);   
  884.                 int i;   
  885.                 for(i = 0;i < BUBBLE_NUM;i++)   
  886.                     SDL_FreeSurface(bubble[i].image);      
  887.   
  888.                 SDL_Quit();   
  889.   
  890.                 exit(1);   
  891.   
  892.             }   
  893.   
  894.             if(event.type == SDL_KEYDOWN)   
  895.   
  896.                 if((event.key.keysym.sym == SDLK_RETURN)) {   
  897.   
  898.                     SDL_FreeSurface(gameover_image);   
  899.   
  900.                     GamePlay();   
  901.   
  902.                 }   
  903.   
  904.         }   
  905.   
  906.     }   
  907.   
  908. }   
  909.   
  910. int main() {   
  911.     Init_SDL();   
  912.     GamePlay();   
  913. }  
Attachment: bubbleman.rar
File Info:RAR file, 1406.86 k bytes
Download Times:173
Tags:
SDL,linux,炸弹人
查看文章views(1438) | 查看评论view comments(2) | 添加评论add comment
雅虎新CEO卡萝尔·巴茨正式上任Mashup中文技术资讯分享站——Mashup中国Mashupcn.com上线

Comments:

祛痘印Jul 27th, 2010 at 2:00 am
#2
不是一般的强。简直是我的偶像。。
支持。。
huoJan 21st, 2009 at 2:04 am
#1
海强！！！

Add Comments: