devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

#C语言实现小游戏——“飞机大战”（含源代码）_飞机大作战代码c语言

作者：笔触狂放9 | 2024-04-04 13:30:51

赞

踩

飞机大作战代码c语言

如果这篇文章对你有所帮助的话，麻烦点个赞叭(◍•͈⌔•͈◍) 

目录

一、问题描述

二、系统设计

2.1、功能模块设计

1、最基础变量声明

2、有关飞机的结构体变量定义

3、初始化敌机信息

4、初始化玩家飞机信息

5、加载图片资源

6、游戏画面加载

7、计时器编写

8、子弹创建模块

9、敌机创建模块

10、子弹移动模块

11、敌机移动模块

12、玩家移动模块

13、撞击模块（与子弹或玩家）

14、主程序

2.2模块流程图

三、程序源代码

一、问题描述

        为了实现飞机和敌机出现在设置的范围内，并且飞机能够发射子弹攻打敌机，敌机的出现位置不确定，玩家自己需要控制飞机来发射子弹攻打敌机。当敌机与飞机碰撞时，游戏结束，程序自动退出。

二、系统设计

2.1、功能模块设计

1、最基础变量声明

  1. enum wh           //enum枚举类型，程序简洁，方便后续对数据进行修改
  2. {
  3.     bgwidth = 480,
  4.     bgheight = 700,
  5.     bullet_num = 15,
  6.     enemy_num = 10,
  7.     BIG,
  8.     SMALL
  9. };

        enum枚举类型，程序简洁，方便后续对数据进行修改

2、有关飞机的结构体变量定义

  1. struct plane
  2. {
  3.     int x;        //玩家飞机的横坐标
  4.     int y;        //玩家飞机的纵坐标
  5.     int width;    //飞机的宽度
  6.     int height;   //飞机的高度
  7.     int hp;       //敌机血量
  8.     int type;     //敌机类型
  9.     bool live;    //布尔类型变量非0即1，用于判断飞机是否仍然存活     
  10. }player, bullet[bullet_num], enemy[enemy_num];      
  11.         //每个子弹都有自己的状态，所以这里要以数组的形式定义

        这里定义一个结构体，用于存储游戏中的飞机、子弹、敌机等元素的属性信息。其中结构体包括了位置（横、纵坐标）、大小（宽度、高度）、血量、类型、是否存活等。

3、初始化敌机信息

  1. void enemyHP(int i)
  2. {
  3.     int flag = rand() % 10;
  4.     if (flag >= 0 && flag <= 1)
  5.     {
  6.         enemy[i].type = BIG;
  7.         enemy[i].hp = 3;
  8.         enemy[i].width = 169;
  9.         enemy[i].height = 230;
  10.     }
  11.     else
  12.     {
  13.         enemy[i].type = SMALL;
  14.         enemy[i].hp = 1;
  15.         enemy[i].width = 57;
  16.         enemy[i].height = 43;
  17.     }
  18. }

        enemyHP函数用于初始化敌机的属性信息。在游戏中，每一个敌机都需要具备不同的属性，例如血量、大小、类型等，通过调用该函数可以随机生成不同类型的敌机。

        函数中首先调用 rand 函数生成一个[0, 9]的随机整数，根据这个数决定生成大型敌机还是小型敌机。如果随机数在 0-1 区间，则把敌机类型设置为 BIG，否则将敌机类型设置为 SMALL

4、初始化玩家飞机信息

  1. void game_csh()
  2. {
  3.     //初始化飞机起始位置和存活状态
  4.     player.x = bgwidth / 2 - 50;
  5.     player.y = bgheight - 120;
  6.     player.live = true;
  7.     player.width = 114;
  8.     player.height = 85;
  9.     //当然子弹也要初始化（数组以数组的方式初始化）
  10.     for (int i = 0; i < bullet_num; i++)
  11.     {
  12.         bullet[i].x = 0;
  13.         bullet[i].y = 0;
  14.         bullet[i].live = false;
  15.     }
  16.     //初始化敌机（数组）
  17.     for (int i = 0; i < enemy_num; i++)
  18.     {
  19.         enemy[i].live = false;
  20.         enemyHP(i);
  21.     }
  22. }

        game_csh函数用于在游戏开始时初始化游戏的各个元素。首先设置玩家飞机的起始位置和存活状态以及玩家飞机的高度宽度。接着，使用循环语句初始化子弹数组里的每一个子弹，将其坐标设置为 (0, 0)，并将其 live 属性设置为 false，表示当前该子弹并不存在于游戏中。

        然后，同样使用循环语句对敌机数组进行初始化。将每一个敌机的 live 属性设置为 false，表示当前该敌机并不存在于游戏中，并调用前面提到的 enemyHP 函数随机生成该敌机的类型和属性信息。该函数会根据一定的概率随机生成大型敌机或小型敌机。

5、加载图片资源

  1. /* IMAGE是easyX 的图像加载函数，这里定义了一个图像指针变量bg */
  2. IMAGE bg;         //背景图8
  3. IMAGE t_player;   //玩家图
  4. IMAGE t_bullet;   //子弹图
  5. IMAGE t_enemy1;   //敌机图1
  6. IMAGE t_enemy2;   //敌机图2
  7. void loadIMAGE()
  8. {
  9.     /*
  10.        loadimage(图片指针变量，图片名称地址)
  11.        将图片的地址赋值给指针，通过指针就可以直接调用图片了
  12.      */
  13.      //ps:曾经想使用绝对地址
  14.     loadimage(&bg, _T("./images/background.png"));         //加载背景图
  15.     loadimage(&t_player, _T("./images/me.png"));           //加载玩家飞机图
  16.     loadimage(&t_bullet, _T("./images/bullet.png"));       //加载子弹图
  17.     loadimage(&t_enemy1, _T("./images/enemy1.png"));       //加载敌方飞机图1
  18.     loadimage(&t_enemy2, _T("./images/enemy2.png"));       //加载敌方飞机图2
  19. }

        loadimage用于加载图片资源，将图片地址赋值给指针，通过指针就可以直接调用图片了。

6、游戏画面加载

  1. void gamedraw()     //游戏画布处理模块化
  2. {
  3.     loadIMAGE();    //要先调用图像加载函数，不然只定义不在函数中调用也发挥不了任何作用
  4.  
  5.     putimage(0, 0, &bg);
  6.     putimage(player.x, player.y, &t_player, SRCINVERT);
  7.     for (int i = 0; i < bullet_num; i++)
  8.     {
  9.         if (bullet[i].live)
  10.         {
  11.             putimage(bullet[i].x, bullet[i].y, &t_bullet, SRCINVERT);
  12.         }
  13.     }
  14.     for (int i = 0; i < enemy_num; i++)
  15.     {
  16.         if (enemy[i].type == BIG)
  17.         {
  18.             putimage(enemy[i].x, enemy[i].y, &t_enemy2, SRCINVERT);
  19.         }
  20.         else putimage(enemy[i].x, enemy[i].y, &t_enemy1, SRCINVERT);
  21.     }
  22.  
  23.     /*
  24.          putimage(int x, int y, 图片地址指针)为图像输出函数格式
  25.          putimage()函数的作用是打印输出图片的函数
  26.          参数1→x为图片起始的横坐标
  27.          参数2→y为图片起始的纵坐标
  28.          参数3→指针地址对应所需的特定图片
  29.     */
  30. }

        gamedraw函数用于游戏画布处理模块化。负责将图像贴到游戏窗口上。

        首先调用 loadIMAGE 函数加载游戏所需的各种资源。然后使用 putimage 函数将图像贴到游戏窗口上第一个参数和第二个参数分别代表图像的左上角在窗口中的位置坐标，第三个参数则是对应要贴的图像的指针变量。

7、计时器编写

  1. bool timer(int ms, int id)
  2. {
  3.     static DWORD t[20];
  4.     if (clock() - t[id] > ms)
  5.     {
  6.         t[id] = clock();    //#include<time.h>
  7.         return true;
  8.     }
  9.     return false;
  10. }       //计时器

        timer函数用于控制游戏的帧率和动画效果。该函数接受两个参数，分别为计时器时间间隔和计时器 ID。

        计时器使用了数组 t 来存储每个计时器的最近触发时间，其中数组下标为计时器 ID。在函数中，先计算当前时间与上次触发时间的时间差，如果大于指定的时间间隔，则将该计时器的最近触发时间更新为当前时间，并返回 true；否则返回 false。

8、子弹创建模块

  1. void bullet_creat()          //子弹创建模块
  2. {
  3.     for (int i = 0; i < bullet_num; i++)
  4.     {
  5.         if (bullet[i].live == false)
  6.         {
  7.             bullet[i].x = player.x + 50;
  8.             bullet[i].y = player.y;
  9.             bullet[i].live = true;
  10.             break;
  11.         }
  12.     }
  13. }

        bullet_creat函数主要用于在游戏中创建新的子弹。该函数使用了一个循环遍历子弹数组中的所有元素，检查是否存在空闲的子弹。如果存在，将新的子弹对象的位置设置为玩家角色的位置加上50，子弹对象的状态设置为“存活”，并退出循环。

9、敌机创建模块

  1. void enemy_creat()
  2. {
  3.     for (int i = 0; i < enemy_num; i++)
  4.     {
  5.         if (!enemy[i].live)
  6.         {
  7.             enemy[i].live = true;
  8.             enemy[i].x = rand() % (bgwidth - 60);
  9.             enemy[i].y = -600;
  10.             enemyHP(i);
  11.             break;
  12.         }
  13.     }
  14. }

        enemy_creat函数主要用于在游戏中创建敌人，前面和子弹创建函数一样都是用循环遍历数组中的每个元素，检查是否存在没有生成的敌机。如果存在，则将新的敌机对象的位置设置为随机生成的水平位置和初始纵向位置，敌机对象的状态设置为“true”，并调用 enemyHP函数来初始化敌机对象的生命值。最后输出敌机对象的位置信息和状态信息，并退出循环。

10、子弹移动模块

  1. void move_b(int speed)
  2. {
  3.     if (GetAsyncKeyState(VK_SPACE) && timer(300, 1))
  4.     {
  5.         bullet_creat();
  6.     }
  7.     for (int i = 0; i < bullet_num; i++)
  8.     {
  9.         if (bullet[i].live)
  10.         {
  11.             bullet[i].y -= speed;
  12.             if (bullet[i].y < 0)
  13.             {
  14.                 bullet[i].live = false;
  15.             }
  16.         }
  17.     }
  18. }

        move_b函数主要作用是子弹的移动。在函数中，首先检查玩家是否按下了空格键，并判断距离上一次发射子弹的时间是否超过 300 毫秒，如果满足条件，则调用 bullet_creat 函数创建新的子弹对象，使用一个循环遍历子弹数组中的所有存活子弹对象。对于每个存活的子弹对象，将其纵向坐标向上移动一定的距离并检查其是否超出了屏幕顶部。如果超出，则将其状态设置为“死亡”。

11、敌机移动模块

  1. void move_e(int speed)
  2. {
  3.     for (int i = 0; i < enemy_num; i++)
  4.     {
  5.         if (enemy[i].live)
  6.         {
  7.             enemy[i].y += speed;
  8.             if (enemy[i].y > bgheight)
  9.             {
  10.                 enemy[i].live = false;
  11.             }
  12.         }
  13.     }
  14. }

        move_e函数的作用是敌机移动，与子弹移动基本函数基本一致，没有子弹移动函数中的空格键和时间检查，而且是超出屏幕底部敌机设置。

12、玩家移动模块

  1. void move_p(int speed)    /*   控制玩家移动——ps：speed为控制移动速度的变量   */
  2. {                         /*
  3.                                    _kbhit()函数的作用作用是判断是否有敲击键盘按键的行为
  4.                                    若有此行为则返回值“真”
  5.                                    若无此行为则返回值“假”
  6.                           */
  7. #if 0    if(_kbhit())
  8.     {
  9.         char key = _getch();
  10.         switch (key)
  11.         {
  12.         case 'w':
  13.         case 'W':
  14.             player.y -= speed;
  15.             break;
  16.         case 's':
  17.         case 'S':
  18.             player.y += speed;
  19.             break;
  20.         case 'a':
  21.         case 'A':
  22.             player.x -= speed;
  23.             break;
  24.         case 'd':
  25.         case 'D':
  26.             player.x += speed;
  27.             break;
  28.         }
  29.     }
  30. #elif 1  
  31.     if (GetAsyncKeyState(VK_UP) || GetAsyncKeyState('W'))
  32.     {
  33.         if (player.y > 0) player.y -= speed;
  34.     }
  35.     if (GetAsyncKeyState(VK_DOWN) || GetAsyncKeyState('S'))
  36.     {
  37.         if (player.y < bgheight - 100) player.y += speed;
  38.     }
  39.     if (GetAsyncKeyState(VK_LEFT) || GetAsyncKeyState('A'))
  40.     {
  41.         if (player.x > -50) player.x -= speed;
  42.     }
  43.     if (GetAsyncKeyState(VK_RIGHT) || GetAsyncKeyState('D'))
  44.     {
  45.         if (player.x < bgwidth - 50) player.x += speed;
  46.     }
  47. #endif 
  48. }

        前半部分和后半部分都是运动函数，但是后半部分的移动效果更佳丝滑，所以我们注释掉了前半部分，只保留了第二版的移动函数，同时只对第二版的函数进行讲解：

        使用 GetAsyncKeyState函数来检测特定的键盘按键，包括上下左右箭头和 W/A/S/D 键，并执行相应的移动操作。该部分代码使用了条件语句和逻辑运算符来限制玩家在屏幕边缘或其他限制区域内移动，防止玩家角色越过游戏界面的范围。

13、撞击模块（与子弹或玩家）

  1. void hit()
  2. {
  3.     for (int i = 0; i < enemy_num; i++)
  4.     {
  5.         if (!enemy[i].live)
  6.             continue;
  7.         for (int j = 0; j < bullet_num; j++)
  8.         {
  9.             if (!bullet[j].live)
  10.                 continue;
  11.             if (bullet[j].x > enemy[i].x && 
  12.                 bullet[j].x < enemy[i].x + enemy[i].width &&
  13.                 bullet[j].y > enemy[i].y &&
  14.                 bullet[j].y < enemy[i].y + enemy[i].height)
  15.             {
  16.                 bullet[j].live = false;
  17.                 enemy[i].hp--;
  18.  
  19.             }
  20.         }
  21.         if (enemy[i].hp <= 0) enemy[i].live = false;
  22.     }
  23.     for (int i = 0; i < enemy_num; i++)
  24.     {
  25.         if (player.x + player.width >= enemy[i].x &&
  26.             player.x <= enemy[i].x + enemy[i].width &&
  27.             player.y <= enemy[i].y + enemy[i].height &&
  28.             player.y + player.height >= enemy[i].y)
  29.         {
  30.             player.live = false;
  31.         }
  32.     }
  33.     if (player.live == false)
  34.     {
  35.         exit(1);
  36.     }
  37. }

        hit函数是判断子弹与敌机，敌机与玩家角色之间的撞击，第一部分通过两个嵌套循环遍历所有敌人和子弹，对于每一个还存活的敌人，判断每个子弹是否与该敌人发生碰撞，即子弹的位置是否在敌人的位置范围内。如果某个子弹击中了敌人，则将该子弹从屏幕上删除，并减少敌人的血量。如果某个敌人的血量被减少到 0 或以下，则将其从屏幕上删除。

        第二部分首先遍历所有敌人，判断玩家是否与每个敌人发生了碰撞。如果玩家碰到了敌人，则将玩家的生命值设为 false，表示玩家已死亡，则通过 exit函数退出程序，游戏结束。

14、主程序

  1. int main()
  2. {
  3.     /*控制台会自动创建，但是游戏的画面窗口范围不会自动产生，需要我们手动创建*/
  4.     initgraph(bgwidth, bgheight);
  5.     /*   initgraph(int width,int height,int flag=0)为函数的具体格式
  6.          initgraph()函数的具体作用是初始化绘图窗口
  7.          参数1→width为窗口宽度
  8.          参数2→height为窗口高度
  9.          参数3→flag为窗口样式，一般为默认值不去更改
  10.     */
  11.     game_csh();
  12.     while (1)
  13.     {
  14.         gamedraw();
  15.         move_p(2);
  16.         move_b(2);
  17.         if (timer(500, 0))  enemy_creat();
  18.         if (timer(5, 2))  move_e(1);
  19.         hit();
  20.     }
  21.     return 0;
  22. }

        这是主程序，用于整合函数，实现游戏的运行。

        首先通过 initgraph函数初始化绘图窗口，并调用 game_csh 函数进行游戏初始化。之后，通过while（1）函数无限循环，不断调用 gamedraw、move_p、move_b、enemy_creat、move_e、hit 等函数，实现游戏的运行。最后，通过 EndBatchDraw函数结束绘图，退出游戏循环并返回值 0，完成游戏的运行。

2.2模块流程图

三、程序源代码

如果这篇文章对你有所帮助的话，麻烦点个赞叭(◍•͈⌔•͈◍)

  1. #include<stdio.h>
  2. #include<conio.h>
  3. #include<stdlib.h>
  4. #include<time.h>
  5. #include<graphics.h>
  6. //先安装图形库easyX，就可以使用该头文件了
  7. //该头文件可以对图形进行直接引用快速处理
  8.  
  9. enum wh           //enum枚举类型，程序简洁，方便后续对数据进行修改
  10. {
  11.     bgwidth = 480,
  12.     bgheight = 700,
  13.     bullet_num = 15,
  14.     enemy_num = 10,
  15.     BIG,
  16.     SMALL
  17. };
  18.  
  19. struct plane
  20. {
  21.     int x;        //玩家飞机的横坐标
  22.     int y;        //玩家飞机的纵坐标
  23.     int width;    //飞机的宽度
  24.     int height;   //飞机的高度
  25.     int hp;       //敌机血量
  26.     int type;     //敌机类型
  27.     bool live;    //布尔类型变量非0即1，用于判断飞机是否仍然存活     
  28. }player, bullet[bullet_num], enemy[enemy_num];      
  29.         //每个子弹都有自己的状态，所以这里要以数组的形式定义
  30.  
  31. void enemyHP(int i)
  32. {
  33.     int flag = rand() % 10;
  34.     if (flag >= 0 && flag <= 1)
  35.     {
  36.         enemy[i].type = BIG;
  37.         enemy[i].hp = 3;
  38.         enemy[i].width = 169;
  39.         enemy[i].height = 230;
  40.     }
  41.     else
  42.     {
  43.         enemy[i].type = SMALL;
  44.         enemy[i].hp = 1;
  45.         enemy[i].width = 57;
  46.         enemy[i].height = 43;
  47.     }
  48. }
  49.  
  50. void game_csh()
  51. {
  52.     //初始化飞机起始位置和存活状态
  53.     player.x = bgwidth / 2 - 50;
  54.     player.y = bgheight - 120;
  55.     player.live = true;
  56.     player.width = 114;
  57.     player.height = 85;
  58.     //当然子弹也要初始化（数组以数组的方式初始化）
  59.     for (int i = 0; i < bullet_num; i++)
  60.     {
  61.         bullet[i].x = 0;
  62.         bullet[i].y = 0;
  63.         bullet[i].live = false;
  64.     }
  65.     //初始化敌机（数组）
  66.     for (int i = 0; i < enemy_num; i++)
  67.     {
  68.         enemy[i].live = false;
  69.         enemyHP(i);
  70.     }
  71. }
  72.  
  73. /* IMAGE是easyX 的图像加载函数，这里定义了一个图像指针变量bg */
  74. IMAGE bg;         //背景图8
  75. IMAGE t_player;   //玩家图
  76. IMAGE t_bullet;   //子弹图
  77. IMAGE t_enemy1;   //敌机图1
  78. IMAGE t_enemy2;   //敌机图2
  79. void loadIMAGE()
  80. {
  81.     /*
  82.        loadimage(图片指针变量，图片名称地址)
  83.        将图片的地址赋值给指针，通过指针就可以直接调用图片了
  84.      */
  85.      //ps:曾经想使用绝对地址
  86.     loadimage(&bg, _T("./images/background.png"));         //加载背景图
  87.     loadimage(&t_player, _T("./images/me.png"));           //加载玩家飞机图
  88.     loadimage(&t_bullet, _T("./images/bullet.png"));       //加载子弹图
  89.     loadimage(&t_enemy1, _T("./images/enemy1.png"));       //加载敌方飞机图1
  90.     loadimage(&t_enemy2, _T("./images/enemy2.png"));       //加载敌方飞机图2
  91. }
  92.  
  93. void gamedraw()     //游戏画布处理模块化
  94. {
  95.     loadIMAGE();    //要先调用图像加载函数，不然只定义不在函数中调用也发挥不了任何作用
  96.  
  97.     putimage(0, 0, &bg);
  98.     putimage(player.x, player.y, &t_player, SRCINVERT);
  99.     for (int i = 0; i < bullet_num; i++)
  100.     {
  101.         if (bullet[i].live)
  102.         {
  103.             putimage(bullet[i].x, bullet[i].y, &t_bullet, SRCINVERT);
  104.         }
  105.     }
  106.     for (int i = 0; i < enemy_num; i++)
  107.     {
  108.         if (enemy[i].type == BIG)
  109.         {
  110.             putimage(enemy[i].x, enemy[i].y, &t_enemy2, SRCINVERT);
  111.         }
  112.         else putimage(enemy[i].x, enemy[i].y, &t_enemy1, SRCINVERT);
  113.     }
  114.  
  115.     /*
  116.          putimage(int x, int y, 图片地址指针)为图像输出函数格式
  117.          putimage()函数的作用是打印输出图片的函数
  118.          参数1→x为图片起始的横坐标
  119.          参数2→y为图片起始的纵坐标
  120.          参数3→指针地址对应所需的特定图片
  121.     */
  122. }
  123.  
  124. bool timer(int ms, int id)
  125. {
  126.     static DWORD t[20];
  127.     if (clock() - t[id] > ms)
  128.     {
  129.         t[id] = clock();    //#include<time.h>
  130.         return true;
  131.     }
  132.     return false;
  133. }       //计时器
  134.  
  135. void bullet_creat()          //子弹创建模块
  136. {
  137.     for (int i = 0; i < bullet_num; i++)
  138.     {
  139.         if (bullet[i].live == false)
  140.         {
  141.             bullet[i].x = player.x + 50;
  142.             bullet[i].y = player.y;
  143.             bullet[i].live = true;
  144.             break;
  145.         }
  146.     }
  147. }
  148.  
  149. void enemy_creat()
  150. {
  151.     for (int i = 0; i < enemy_num; i++)
  152.     {
  153.         if (!enemy[i].live)
  154.         {
  155.             enemy[i].live = true;
  156.             enemy[i].x = rand() % (bgwidth - 60);
  157.             enemy[i].y = -600;
  158.             enemyHP(i);
  159.             break;
  160.         }
  161.     }
  162. }
  163.  
  164. void move_b(int speed)
  165. {
  166.     if (GetAsyncKeyState(VK_SPACE) && timer(300, 1))
  167.     {
  168.         bullet_creat();
  169.     }
  170.     for (int i = 0; i < bullet_num; i++)
  171.     {
  172.         if (bullet[i].live)
  173.         {
  174.             bullet[i].y -= speed;
  175.             if (bullet[i].y < 0)
  176.             {
  177.                 bullet[i].live = false;
  178.             }
  179.         }
  180.     }
  181. }
  182.  
  183. void move_e(int speed)
  184. {
  185.     for (int i = 0; i < enemy_num; i++)
  186.     {
  187.         if (enemy[i].live)
  188.         {
  189.             enemy[i].y += speed;
  190.             if (enemy[i].y > bgheight)
  191.             {
  192.                 enemy[i].live = false;
  193.             }
  194.         }
  195.     }
  196. }
  197.  
  198. void move_p(int speed)    /*   控制玩家移动——ps：speed为控制移动速度的变量   */
  199. {                         /*
  200.                                    _kbhit()函数的作用作用是判断是否有敲击键盘按键的行为
  201.                                    若有此行为则返回值“真”
  202.                                    若无此行为则返回值“假”
  203.                           */
  204. #if 0    if(_kbhit())
  205.     {
  206.         char key = _getch();
  207.         switch (key)
  208.         {
  209.         case 'w':
  210.         case 'W':
  211.             player.y -= speed;
  212.             break;
  213.         case 's':
  214.         case 'S':
  215.             player.y += speed;
  216.             break;
  217.         case 'a':
  218.         case 'A':
  219.             player.x -= speed;
  220.             break;
  221.         case 'd':
  222.         case 'D':
  223.             player.x += speed;
  224.             break;
  225.         }
  226.     }
  227. #elif 1  
  228.     if (GetAsyncKeyState(VK_UP) || GetAsyncKeyState('W'))
  229.     {
  230.         if (player.y > 0) player.y -= speed;
  231.     }
  232.     if (GetAsyncKeyState(VK_DOWN) || GetAsyncKeyState('S'))
  233.     {
  234.         if (player.y < bgheight - 100) player.y += speed;
  235.     }
  236.     if (GetAsyncKeyState(VK_LEFT) || GetAsyncKeyState('A'))
  237.     {
  238.         if (player.x > -50) player.x -= speed;
  239.     }
  240.     if (GetAsyncKeyState(VK_RIGHT) || GetAsyncKeyState('D'))
  241.     {
  242.         if (player.x < bgwidth - 50) player.x += speed;
  243.     }
  244. #endif 
  245. }
  246.  
  247. void hit()
  248. {
  249.     for (int i = 0; i < enemy_num; i++)
  250.     {
  251.         if (!enemy[i].live)
  252.             continue;
  253.         for (int j = 0; j < bullet_num; j++)
  254.         {
  255.             if (!bullet[j].live)
  256.                 continue;
  257.             if (bullet[j].x > enemy[i].x && 
  258.                 bullet[j].x < enemy[i].x + enemy[i].width &&
  259.                 bullet[j].y > enemy[i].y &&
  260.                 bullet[j].y < enemy[i].y + enemy[i].height)
  261.             {
  262.                 bullet[j].live = false;
  263.                 enemy[i].hp--;
  264.  
  265.             }
  266.         }
  267.         if (enemy[i].hp <= 0) enemy[i].live = false;
  268.     }
  269.     for (int i = 0; i < enemy_num; i++)
  270.     {
  271.         if (player.x + player.width >= enemy[i].x &&
  272.             player.x <= enemy[i].x + enemy[i].width &&
  273.             player.y <= enemy[i].y + enemy[i].height &&
  274.             player.y + player.height >= enemy[i].y)
  275.         {
  276.             player.live = false;
  277.         }
  278.     }
  279.     if (player.live == false)
  280.     {
  281.         exit(1);
  282.     }
  283. }
  284.  
  285. int main()
  286. {
  287.     /*控制台会自动创建，但是游戏的画面窗口范围不会自动产生，需要我们手动创建*/
  288.     initgraph(bgwidth, bgheight);
  289.     /*   initgraph(int width,int height,int flag=0)为函数的具体格式
  290.          initgraph()函数的具体作用是初始化绘图窗口
  291.          参数1→width为窗口宽度
  292.          参数2→height为窗口高度
  293.          参数3→flag为窗口样式，一般为默认值不去更改
  294.     */
  295.     game_csh();
  296.     while (1)
  297.     {
  298.         gamedraw();
  299.         move_p(2);
  300.         move_b(2);
  301.         if (timer(500, 0))  enemy_creat();
  302.         if (timer(5, 2))  move_e(1);
  303.         hit();
  304.     }
  305.     return 0;
  306. }

如果这篇文章对你有所帮助的话，麻烦点个赞叭(◍•͈⌔•͈◍) 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/358917?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号