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

C语言实现飞机大战小游戏_c语言大作业飞机大战

作者：花生_TL007 | 2024-04-04 13:39:07

赞

踩

c语言大作业飞机大战

先看一下效果：

初始游戏界面具有多个选项：

且具有多个可变设置项，方便个性化调整：

多个模式进行选择:

正式游戏界面,操作流畅，界面简单，且有操作提示：

使用函数封装代码和逻辑控制衔接每个界面，实现连贯性操作，使用逐帧动画的效果展示。

此时博主较忙，所以没有进行代码的讲解，不过原理较为简单，使用全部展示在下面了。

下面是代码：

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <conio.h>
  5. #include <time.h>
  6. #include <windows.h>
  7. #include <stdio.h>
  8. #include <iostream>
  9. #include <iomanip>
  10. #include <string.h>
  11. #include<algorithm>
  12. #include<stdio.h>
  13. #include<string.h>
  14. #include<conio.h>
  15. #include<windows.h>
  16. #include<stdlib.h>
  17. #include <windows.h>
  18. #include<stdbool.h>
  19. using namespace std;
  20. #pragma warning(disable:4996) 
  21. #define  high 25   //数组高
  22. #define width 60   //数组宽
  23. #define  border -1    //边界
  24. #define   blank  0    //空白
  25. #define   plane  1    //飞机
  26. #define  bullet  2    //子弹
  27. #define   enemy  3    //敌机
  28. #define destroy  4    //摧毁标记
  29.  
  30. int canvas[high + 2][width + 2];  //游戏地图的高和宽
  31. int pos_h, pos_w;   //战机位置
  32. int enemynum = 3;    //敌机一次的刷新数量
  33. int record; //计时器，用次数计时
  34. int rec_move = 5; //敌机移动的次数频率
  35. int rec_new = 40; //敌机刷新的次数频率
  36. int score;  //分数
  37. int num;//发射的子弹数目
  38. int Over？;  //游戏判断监视
  39. int life = 3;//生命值
  40.  
  41. void Startup();   //游戏数值初始化
  42. void Show();    //游戏界面输出
  43.  
  44. //因输入导致的游戏状态更新
  45. void Update();//生存模式
  46. void Update1();//无敌模式
  47. void Update2();//多命模式
  48.  
  49. //与输入无关的游戏状态更新
  50. void NoUpdate(); //生存模式
  51. void NoUpdate1();//无敌模式
  52. void NoUpdate2();//多命模式
  53. void HideCursor();        //隐藏光标
  54. void gotoxy(int x, int y);        //回调光标    
  55. int  menu();//菜单面
  56. int introduce();//介绍面
  57. int control_introduce();//控制介绍
  58. int background_introduce();//背景介绍
  59.  
  60. int setting();//设置面
  61. int speed_setting();//敌机移动速度设置
  62. int rec_new_setting();//刷新速度设置
  63. int enemynum_setting();//敌机一次刷新数目设置
  64. int life_setting();//生命数设置
  65. int mode();//模式选择面
  66. void mode1();//生存模式
  67. void mode2();//无敌模式
  68. void mode3();//多命模式
  69. void result();//结束界面
  70. void assist(double shoot);//射击评估
  71. void SetSize(unsigned uCol, unsigned uLine);//窗口大小设置
  72.  
  73.  
  74. int main() {
  75. OK:
  76.     if (menu()) {
  77.         int a = mode();
  78.         //根据mode返回的数字判断选择模式
  79.         //返回几就对应进入什么模式
  80.         if (a == 1) {
  81.             mode1();
  82.             if (!Over？) {
  83.                 goto over;
  84.             }
  85.         }
  86.         else if (a == 2) {
  87.             mode2();
  88.             if (!Over？) {
  89.                 goto over;
  90.             }
  91.         }
  92.         else if (a == 3) {
  93.             mode3();
  94.             if (!Over？) {
  95.                 goto over;
  96.             }
  97.         }
  98.         else if (a == 4) {
  99.             goto OK;
  100.         }
  101.     }
  102. over:
  103.     result();
  104.     cout << "是否重新开始游戏？" << endl;
  105.     cout << "1为是，0为退出游戏" << endl;
  106.     int i = 0;
  107.     cin >> i;
  108.     switch (i) {
  109.     case 1: system("cls"); goto OK; break;
  110.     case 0: break;
  111.     }
  112.     return 0;
  113. }
  114. void Startup() {  //游戏数值初始化
  115.     Over？ = 1;//Over?为1代表没死，为0代表死亡
  116.     num = 0;//初始发射子弹为0
  117.     score = 0;  //初始化分数
  118.     for (int i = 0; i < high + 2; i++) {      //初始化矩阵元素
  119.         for (int j = 0; j < width + 2; j++) {
  120.             if (i == 0 || i == high + 1 ||
  121.                 j == 0 || j == width + 1) {
  122.                 canvas[i][j] = border;
  123.             }
  124.             else canvas[i][j] = blank;
  125.         }
  126.     }
  127.     pos_h = high / 2;    //初始化飞机竖直坐标
  128.     pos_w = width / 2;     //初始化飞机水平坐标
  129.     canvas[pos_h][pos_w] = plane;  //初始化飞机位置
  130.     srand(time(NULL));
  131.     record = 4;      //初始化计数器
  132.  
  133. }
  134. void Show() {  //游戏界面输出
  135.     HideCursor();   //隐藏光标
  136.     gotoxy(1, 1);    //回调光标、刷新画面
  137.     for (int i = 0; i < high + 2; i++) {
  138.         for (int j = 0; j < width + 2; j++) {
  139.             if (canvas[i][j] == plane) { //当前位置为飞机位置
  140.                 printf("W");
  141.             }
  142.             else if (canvas[i][j] == bullet) {  //当前位置为子弹位置
  143.                 printf("|");
  144.             }
  145.             else if (canvas[i][j] == enemy) {  //当前位置为敌机位置
  146.                 printf("#");
  147.             }
  148.             else if (canvas[i][j] == border) {  //当前位置为边界
  149.                 printf("$");
  150.             }
  151.             else if (canvas[i][j] == blank) {  //当前位置无物，且在边界内
  152.                 printf(" ");
  153.             }
  154.             else if (canvas[i][j] == destroy) {  //当前位置无物，且在边界内
  155.                 printf("x");
  156.             }
  157.         }
  158.         printf("\n");
  159.     }
  160.     printf("\n你的得分为：%d", score);
  161.     printf("\n已发射子弹数目：%d", num);
  162.     printf("\n精准度为：%f", double(score) / double(num));
  163.     printf("操作说明: ASDW分别操作 左下右上四个的移动\n");
  164.     printf("**空格是发出子弹**\n");
  165.     printf("**T退出游戏**\n");
  166. }
  167. void Update() {  //因输入导致的游戏状态更新
  168.     //GetKeyState如果高位为1表示按键按下，此时返回值为负数（<0）;如果高位为0表示按键弹起，此时返回值为正数（>0）
  169.     char key_W = GetKeyState('W'),  //监测 W 键是否按下
  170.         key_S = GetKeyState('S'),  //监测 S 键是否按下
  171.         key_A = GetKeyState('A'),  //监测 A 键是否按下
  172.         key_D = GetKeyState('D'),  //监测 D 键是否按下
  173.         key_attack = GetKeyState(' '),//监测 空格 键是否按下
  174.         key_out = GetKeyState('T');//监测 T 键是否按下
  175.     if (kbhit()) { //当有键按下时为1，无为0
  176.         if (key_W < 0) {  //当按下 W 键，上移
  177.             if (pos_h > 1) {
  178.                 canvas[pos_h][pos_w] = blank;
  179.                 if (canvas[pos_h - 1][pos_w] == enemy) {  //下个位置是敌机，撞毁
  180.                     canvas[pos_h - 1][pos_w] = destroy;
  181.                     Over？ = 0;
  182.                 }
  183.                 else canvas[--pos_h][pos_w] = plane;
  184.             }
  185.         }
  186.         if (key_S < 0) {  //当按下 S 键，下移
  187.             if (pos_h < high) {
  188.                 canvas[pos_h][pos_w] = blank;
  189.                 if (canvas[pos_h + 1][pos_w] == enemy) {  //下个位置是敌机，撞毁
  190.                     canvas[pos_h + 1][pos_w] = destroy;
  191.                     Over？ = 0;
  192.                 }
  193.                 else canvas[++pos_h][pos_w] = plane;
  194.             }
  195.         }
  196.         if (key_A < 0) {  //当按下 A 键，左移
  197.             if (pos_w > 1) {
  198.                 canvas[pos_h][pos_w] = blank;
  199.                 if (canvas[pos_h][pos_w - 1] == enemy) {  //下个位置是敌机，撞毁
  200.                     canvas[pos_h][pos_w - 1] = destroy;
  201.                     Over？ = 0;
  202.                 }
  203.                 else canvas[pos_h][--pos_w] = plane;
  204.             }
  205.         }
  206.         if (key_D < 0) {  //当按下 D 键，右移
  207.             if (pos_w < width) {
  208.                 canvas[pos_h][pos_w] = blank;
  209.                 if (canvas[pos_h][pos_w + 1] == enemy) {  //下个位置是敌机，撞毁
  210.                     canvas[pos_h][pos_w + 1] = destroy;
  211.                     Over？ = 0;
  212.                 }
  213.                 else canvas[pos_h][++pos_w] = plane;
  214.             }
  215.         }
  216.         if (key_attack < 0) {   //当按下空格键，发射子弹
  217.             if (pos_h != 1) {
  218.                 canvas[pos_h - 1][pos_w] = bullet;
  219.                 num++;
  220.             }
  221.         }
  222.         if (key_out < 0) {
  223.             Over？ = 0;
  224.         }
  225.     }
  226. }
  227. void Update1() {  //因输入导致的游戏状态更新
  228.     char key_W = GetKeyState('W'),  //监测 W 键是否按下
  229.         key_S = GetKeyState('S'),  //监测 S 键是否按下
  230.         key_A = GetKeyState('A'),  //监测 A 键是否按下
  231.         key_D = GetKeyState('D'),  //监测 D 键是否按下
  232.         key_attack = GetKeyState(' '),  //监测 空格 键是否按下
  233.         key_out = GetKeyState('T');//监测 T 键是否按下
  234.     if (kbhit()) { //当有键按下时为1，无为0
  235.         if (key_W < 0) {  //当按下 W 键，上移
  236.             if (pos_h > 1) {
  237.                 canvas[pos_h][pos_w] = blank;
  238.                 canvas[--pos_h][pos_w] = plane;
  239.             }
  240.         }
  241.         if (key_S < 0) {  //当按下 S 键，下移
  242.             if (pos_h < high) {
  243.                 canvas[pos_h][pos_w] = blank;
  244.                 canvas[++pos_h][pos_w] = plane;
  245.             }
  246.         }
  247.         if (key_A < 0) {  //当按下 A 键，左移
  248.             if (pos_w > 1) {
  249.                 canvas[pos_h][pos_w] = blank;
  250.                 canvas[pos_h][--pos_w] = plane;
  251.             }
  252.         }
  253.         if (key_D < 0) {  //当按下 D 键，右移
  254.             if (pos_w < width) {
  255.                 canvas[pos_h][pos_w] = blank;
  256.                 canvas[pos_h][++pos_w] = plane;
  257.             }
  258.         }
  259.         if (key_attack < 0) {   //当按下空格键，发射子弹
  260.             if (pos_h != 1) {
  261.                 canvas[pos_h - 1][pos_w] = bullet;
  262.                 num++;
  263.             }
  264.         }
  265.         if (key_out < 0) {
  266.             Over？ = 0;
  267.         }
  268.     }
  269. }
  270. void Update2() {  //因输入导致的游戏状态更新
  271.     char key_W = GetKeyState('W'),  //监测 W 键是否按下
  272.         key_S = GetKeyState('S'),  //监测 S 键是否按下
  273.         key_A = GetKeyState('A'),  //监测 A 键是否按下
  274.         key_D = GetKeyState('D'),  //监测 D 键是否按下
  275.         key_attack = GetKeyState(' '),//监测 空格 键是否按下
  276.         key_out = GetKeyState('T');//监测 T 键是否按下
  277.     if (kbhit()) { //当有键按下时为1，无为0
  278.         if (key_W < 0) {  //当按下 W 键，上移
  279.             if (pos_h > 1) {
  280.                 canvas[pos_h][pos_w] = blank;
  281.                 if (canvas[pos_h - 1][pos_w] == enemy) {  //下个位置是敌机，撞毁
  282.                     canvas[pos_h - 1][pos_w] = destroy;
  283.                     life--;
  284.                     if (life == 0) { Over？ = 0; }
  285.                 }
  286.                 else canvas[--pos_h][pos_w] = plane;
  287.             }
  288.         }
  289.         if (key_S < 0) {  //当按下 S 键，下移
  290.             if (pos_h < high) {
  291.                 canvas[pos_h][pos_w] = blank;
  292.                 if (canvas[pos_h + 1][pos_w] == enemy) {  //下个位置是敌机，撞毁
  293.                     canvas[pos_h + 1][pos_w] = destroy;
  294.                     life--;
  295.                     if (life == 0) { Over？ = 0; }
  296.                 }
  297.                 else canvas[++pos_h][pos_w] = plane;
  298.             }
  299.         }
  300.         if (key_A < 0) {  //当按下 A 键，左移
  301.             if (pos_w > 1) {
  302.                 canvas[pos_h][pos_w] = blank;
  303.                 if (canvas[pos_h][pos_w - 1] == enemy) {  //下个位置是敌机，撞毁
  304.                     canvas[pos_h][pos_w - 1] = destroy;
  305.                     life--;
  306.                     if (life == 0) { Over？ = 0; }
  307.                 }
  308.                 else canvas[pos_h][--pos_w] = plane;
  309.             }
  310.         }
  311.         if (key_D < 0) {  //当按下 D 键，右移
  312.             if (pos_w < width) {
  313.                 canvas[pos_h][pos_w] = blank;
  314.                 if (canvas[pos_h][pos_w + 1] == enemy) {  //下个位置是敌机，撞毁
  315.                     canvas[pos_h][pos_w + 1] = destroy;
  316.                     life--;
  317.                     if (life == 0) { Over？ = 0; }
  318.                 }
  319.                 else canvas[pos_h][++pos_w] = plane;
  320.             }
  321.         }
  322.         if (key_attack < 0) {   //当按下空格键，发射子弹
  323.             if (pos_h != 1) {
  324.                 canvas[pos_h - 1][pos_w] = bullet;
  325.                 num++;
  326.             }
  327.         }
  328.         if (key_out < 0) {
  329.             Over？ = 0;
  330.         }
  331.     }
  332. }
  333. void NoUpdate() {  //与输入无关的游戏状态更新
  334.     int temp[high + 2][width + 2];  //用来判断原位置的临时数组
  335.     for (int i = 1; i <= high; i++) {
  336.         for (int j = 1; j <= width; j++) {
  337.             temp[i][j] = canvas[i][j];
  338.         }
  339.     }
  340.     for (int i = 1; i <= high; i++) {  //遍历临时数组，修改数组
  341.         for (int j = 1; j <= width; j++) {
  342.             if (temp[i][j] == enemy && record % rec_move == 0) { //当前位置为敌机
  343.                 canvas[i][j] = blank;
  344.                 if (temp[i + 1][j] == bullet) {  //下面为子弹，敌机被击中
  345.                     canvas[i + 1][j] = blank;
  346.                     score++;
  347.  
  348.                 }
  349.                 else if (i < high) {
  350.                     canvas[i + 1][j] = enemy;
  351.                 }
  352.                 if (i + 1 == pos_h && j == pos_w) {  //下面为飞机，玩家飞机被撞毁
  353.                     canvas[i + 1][j] = destroy;
  354.                     Over？ = 0;
  355.                 }
  356.             }
  357.             if (temp[i][j] == bullet) { //当前位置为子弹
  358.                 canvas[i][j] = blank;
  359.                 if (temp[i - 1][j] == enemy) {  //下个位置是敌机，敌机被击毁
  360.                     canvas[i - 1][j] = blank;
  361.                     score++;
  362.  
  363.                 }
  364.                 else if (i > 1) {
  365.                     canvas[i - 1][j] = bullet;
  366.                 }
  367.             }
  368.         }
  369.     }
  370.     if (record % rec_new == 0)  //刚好到时间间隔
  371.         for (int i = 0; i < enemynum; i++) {   //新增敌机群
  372.             canvas[rand() % 2 + 1][rand() % width + 1] = enemy;
  373.         }
  374.     if (record <= 100) {  //时间间隔计次
  375.         record++;
  376.     }
  377.     else {    //时间间隔计次清零
  378.         record = 0;
  379.     }
  380. }
  381. void NoUpdate1() {  //与输入无关的游戏状态更新
  382.     int temp[high + 2][width + 2];  //用来判断原位置的临时数组
  383.     for (int i = 1; i <= high; i++) {
  384.         for (int j = 1; j <= width; j++) {
  385.             temp[i][j] = canvas[i][j];
  386.         }
  387.     }
  388.     for (int i = 1; i <= high; i++) {  //遍历临时数组，修改数组
  389.         for (int j = 1; j <= width; j++) {
  390.             if (temp[i][j] == enemy && record % rec_move == 0) { //当前位置为敌机
  391.                 canvas[i][j] = blank;
  392.                 if (temp[i + 1][j] == bullet) {  //下面为子弹，敌机被击中
  393.                     canvas[i + 1][j] = blank;
  394.                     score++;
  395.  
  396.                 }
  397.                 else if (i < high) {
  398.                     canvas[i + 1][j] = enemy;
  399.                 }
  400.  
  401.             }
  402.             if (temp[i][j] == bullet) { //当前位置为子弹
  403.                 canvas[i][j] = blank;
  404.                 if (temp[i - 1][j] == enemy) {  //下个位置是敌机，敌机被击毁
  405.                     canvas[i - 1][j] = blank;
  406.                     score++;
  407.  
  408.                 }
  409.                 else if (i > 1) {
  410.                     canvas[i - 1][j] = bullet;
  411.                 }
  412.             }
  413.         }
  414.     }
  415.     if (record % rec_new == 0)  //刚好到时间间隔
  416.         for (int i = 0; i < enemynum; i++) {   //新增敌机群
  417.             canvas[rand() % 2 + 1][rand() % width + 1] = enemy;
  418.         }
  419.     if (record <= 100) {  //时间间隔计次
  420.         record++;
  421.     }
  422.     else {    //时间间隔计次清零
  423.         record = 0;
  424.     }
  425. }
  426. void NoUpdate2() {  //与输入无关的游戏状态更新
  427.     int temp[high + 2][width + 2];  //用来判断原位置的临时数组
  428.     for (int i = 1; i <= high; i++) {
  429.         for (int j = 1; j <= width; j++) {
  430.             temp[i][j] = canvas[i][j];
  431.         }
  432.     }
  433.     for (int i = 1; i <= high; i++) {  //遍历临时数组，修改数组
  434.         for (int j = 1; j <= width; j++) {
  435.             if (temp[i][j] == enemy && record % rec_move == 0) { //当前位置为敌机
  436.                 canvas[i][j] = blank;
  437.                 if (temp[i + 1][j] == bullet) {  //下面为子弹，敌机被击中
  438.                     canvas[i + 1][j] = blank;
  439.                     score++;
  440.  
  441.                 }
  442.                 else if (i < high) {
  443.                     canvas[i + 1][j] = enemy;
  444.                 }
  445.                 if (i + 1 == pos_h && j == pos_w) {  //下面为飞机，玩家飞机被撞毁
  446.                     canvas[i + 1][j] = destroy;
  447.                     life--;
  448.                     if (life == 0) {
  449.                         Over？ = 0;
  450.                     }
  451.                 }
  452.             }
  453.             if (temp[i][j] == bullet) { //当前位置为子弹
  454.                 canvas[i][j] = blank;
  455.                 if (temp[i - 1][j] == enemy) {  //下个位置是敌机，敌机被击毁
  456.                     canvas[i - 1][j] = blank;
  457.                     score++;
  458.  
  459.                 }
  460.                 else if (i > 1) {
  461.                     canvas[i - 1][j] = bullet;
  462.                 }
  463.             }
  464.         }
  465.     }
  466.     if (record % rec_new == 0)  //刚好到时间间隔
  467.         for (int i = 0; i < enemynum; i++) {   //新增敌机群
  468.             canvas[rand() % 2 + 1][rand() % width + 1] = enemy;
  469.         }
  470.     if (record <= 100) {  //时间间隔计次
  471.         record++;
  472.     }
  473.     else {    //时间间隔计次清零
  474.         record = 0;
  475.     }
  476. }
  477. void gotoxy(int x, int y) { //回调光标
  478.     COORD pos;
  479.     pos.X = x - 1;
  480.     pos.Y = y - 1;
  481.     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
  482. }
  483. void HideCursor() { //隐藏光标函数
  484.     CONSOLE_CURSOR_INFO cursor;
  485.     cursor.bVisible = FALSE;
  486.     cursor.dwSize = sizeof(cursor);
  487.     HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  488.     SetConsoleCursorInfo(handle, &cursor);
  489. }
  490. int  menu()
  491. {
  492.     ///**********************************************************
  493. ///  函数名  ：menu                                         *
  494. ///  输入参数：无返回值                                     *
  495. ///  返回值  ：    无                                       *
  496. ///  函数功能：                                             *
  497. ///           用于显示主界面并衔接游戏设置                  *
  498. ///**********************************************************
  499.     cout << endl;
  500.     cout << endl;
  501.     cout << endl;
  502.     cout << "\t\t\t\t        Annihilator Battle     " << endl;
  503.     cout << "\t\t\t\t|-----------------------------|" << endl;
  504.     cout << "\t\t\t\t|          1:开始游戏         |" << endl;
  505.     cout << "\t\t\t\t|          2: 设 置           |" << endl;
  506.     cout << "\t\t\t\t|          3:游戏介绍         |" << endl;
  507.     cout << "\t\t\t\t|          4:退出游戏         |" << endl;
  508.     cout << "\t\t\t\t|-----------------------------|" << endl;
  509. HA:
  510.     cout << "\t\t\t\t           请输入选项：        ";
  511.     int choice = 0;
  512.     cin >> choice;
  513.     switch (choice)
  514.     {
  515.     case 1:
  516.         system("cls");//可以用gotoxy（0,0）
  517.         rewind(stdin);
  518.         return 1;
  519.         break;
  520.     case 2:
  521.         system("cls");//可以用gotoxy（0,0）
  522.         rewind(stdin);
  523.         return setting();
  524.         break;
  525.     case 3:
  526.         system("cls");//可以用gotoxy（0,0）
  527.         rewind(stdin);
  528.         return introduce();
  529.         break;
  530.     case 4:return 0; break;
  531.     default:
  532.         cout << "输入错误，请重新输入！！";
  533.         goto HA;
  534.         break;
  535.     }
  536. }
  537. int introduce() {
  538.     cout << endl;
  539.     cout << endl;
  540.     cout << endl;
  541.     cout << "\t\t\t\t            introduce            " << endl;
  542.     cout << "\t\t\t\t|-----------------------------|" << endl;
  543.     cout << "\t\t\t\t|          1:操作介绍         |" << endl;
  544.     cout << "\t\t\t\t|          2:背景介绍         |" << endl;
  545.     cout << "\t\t\t\t|          3：返 回           |" << endl;
  546.     cout << "\t\t\t\t|-----------------------------|" << endl;
  547.  
  548. YE:
  549.     cout << "\t\t\t\t           请输入选项：";
  550.     int select;
  551.  
  552.     cin >> select;
  553.  
  554.     switch (select)
  555.     {
  556.     case 1:return control_introduce(); break;
  557.     case 2:return background_introduce(); break;
  558.     case 3:system("cls"); return menu(); break;
  559.     default: cout << "输入错误，请重新输入！！";
  560.         goto YE; break;
  561.     }
  562. }
  563. int control_introduce() {
  564.     system("cls");
  565.     printf("操作说明: ASDW分别操作 左下右上四个的移动\n");
  566.     printf("**空格是发出子弹**\n");
  567.     printf("**T退出游戏**\n");
  568.     cout << endl << "是否返回主菜单?" << endl << "返回主菜单为1，退出游戏为0" << endl;
  569.     cout << "你的选择是：";
  570.     int i;
  571.     cin >> i;
  572.     if (i == 1) {
  573.         system("cls");
  574.         return menu();
  575.     }
  576.     if (i == 0) {
  577.         system("cls");
  578.         return 0;
  579.     }
  580. }
  581. int background_introduce() {
  582.     system("cls");
  583.     printf("飞机游戏是一款风靡全球的电视机游戏和掌上游戏机产品,\n");
  584.     printf("曾几何时，它打造了一个无数人回忆的梦，\n");
  585.     printf("曾几何时，它创造了一个无法企及的游戏巅峰，\n");
  586.     printf("也曾影响了一代产业链。虽然它辉煌的业绩在历史的涡轮中渐渐远去，\n");
  587.     printf("但这款游戏每每提及，总会令人爱不释手，魂牵梦绕。 \n");
  588.     cout << endl << "是否返回主菜单?" << endl << "返回主菜单为1，返回设置为0" << endl;
  589.     cout << "你的选择是：";
  590.     int i;
  591.     cin >> i;
  592.     if (i == 1) {
  593.         system("cls");
  594.         return menu();
  595.     }
  596.     if (i == 0) {
  597.         system("cls");
  598.         return setting();
  599.     }
  600. }
  601. int setting()
  602. {
  603.     cout << endl;
  604.     cout << endl;
  605.     cout << endl;
  606.     cout << "\t\t\t\t            Setting            " << endl;
  607.     cout << "\t\t\t\t|-----------------------------|" << endl;
  608.     cout << "\t\t\t\t|          1:敌机移动速度     |" << endl;
  609.     cout << "\t\t\t\t|          2:敌机刷新速度     |" << endl;
  610.     cout << "\t\t\t\t|          3:敌机数目         |" << endl;
  611.     cout << "\t\t\t\t|          4:生命数目         |" << endl;
  612.     cout << "\t\t\t\t|          5：返 回           |" << endl;
  613.     cout << "\t\t\t\t|-----------------------------|" << endl;
  614.  
  615. RE:
  616.     cout << "\t\t\t\t           请输入选项：";
  617.     int select;
  618.  
  619.     cin >> select;
  620.     switch (select)
  621.     {
  622.     case 1:return speed_setting(); break;
  623.     case 2:return rec_new_setting(); break;
  624.     case 3:return enemynum_setting(); break;
  625.     case 4:return life_setting(); break;
  626.     case 5:system("cls"); return menu(); break;
  627.     default: cout << "输入错误，请重新输入！！";
  628.         goto RE; break;
  629.     }
  630. }
  631. int speed_setting() {
  632.     system("cls");
  633.     cout << "提示：敌机速度尽量设置在0-15，且数值越大移动越慢" << endl;
  634.     cout << "敌机的移动速度设置为:";
  635.     cin >> rec_move;
  636.     cout << "已修改速度为：" << rec_move;
  637.     cout << endl << "是否返回主菜单?" << endl << "返回主菜单为1，返回设置为0" << endl;
  638.     cout << "你的选择是：";
  639.     int i;
  640.     cin >> i;
  641.     if (i == 1) {
  642.         system("cls");
  643.         return menu();
  644.     }
  645.     if (i == 0) {
  646.         system("cls");
  647.         return setting();
  648.     }
  649. }
  650. int rec_new_setting() {
  651.     system("cls");
  652.     cout << "提示：敌机刷新速度尽量设置在1-20，" << endl;
  653.     cout << "备注：数值越小，刷新速度越快，但上限不超过设置的敌机数目！" << endl;
  654.     cout << "敌机的刷新速度设置为:";
  655.     cin >> rec_new;
  656.     cout << "已修改敌机刷新速度为：" << rec_new;
  657.     cout << endl << "是否返回主菜单?" << endl << "返回主菜单为1，返回设置为0" << endl;
  658.     cout << "你的选择是：";
  659.     int i;
  660.     cin >> i;
  661.     if (i == 1) {
  662.         system("cls");
  663.         return menu();
  664.     }
  665.     if (i == 0) {
  666.         system("cls");
  667.         return setting();
  668.     }
  669. }
  670. int enemynum_setting() {
  671.     system("cls");
  672.     cout << "提示：敌机数目尽量设置在2-30，" << endl;
  673.     cout << "敌机的数目设置为:";
  674.     cin >> enemynum;
  675.     cout << "已修改敌机数目为：" << enemynum;
  676.     cout << endl << "是否返回主菜单?" << endl << "返回主菜单为1，返回设置为0" << endl;
  677.     cout << "你的选择是：";
  678.     int i;
  679.     cin >> i;
  680.     if (i == 1) {
  681.         system("cls");
  682.         return menu();
  683.     }
  684.     if (i == 0) {
  685.         system("cls");
  686.         return setting();
  687.     }
  688. }
  689. int life_setting() {
  690.     system("cls");
  691.     cout << "提示：生命数目尽量设置在2-30，" << endl;
  692.     cout << "生命的数目设置为:";
  693.     cin >> life;
  694.     cout << "已修改敌机数目为：" << life;
  695.     cout << endl << "是否返回主菜单?" << endl << "返回主菜单为1，返回设置为0" << endl;
  696.     cout << "你的选择是：";
  697.     int i;
  698.     cin >> i;
  699.     if (i == 1) {
  700.         system("cls");
  701.         return menu();
  702.     }
  703.     if (i == 0) {
  704.         system("cls");
  705.         return setting();
  706.     }
  707. }
  708. int mode()
  709. {
  710.  
  711.     cout << endl;
  712.     cout << endl;
  713.     cout << endl;
  714.     cout << "\t\t\t\t              Mode             " << endl;
  715.     cout << "\t\t\t\t|-----------------------------|" << endl;
  716.     cout << "\t\t\t\t|          1:生存模式         |" << endl;
  717.     cout << "\t\t\t\t|          2:无敌模式         |" << endl;
  718.     cout << "\t\t\t\t|          3:多命模式         |" << endl;
  719.     cout << "\t\t\t\t|          4:主菜单           |" << endl;
  720.     cout << "\t\t\t\t|-----------------------------|" << endl;
  721. WH:
  722.     int select;
  723.     cout << "\t\t\t\t          请输入选项：";
  724.     cin >> select;
  725.     switch (select)
  726.     {
  727.  
  728.     case 1:
  729.         system("cls");
  730.         rewind(stdin);//清空输入缓冲区
  731.         return 1;
  732.         break;
  733.     case 2:
  734.         system("cls");
  735.         rewind(stdin);
  736.         return 2;
  737.         break;
  738.     case 3:
  739.         system("cls");
  740.         rewind(stdin);
  741.         return 3;
  742.         break;
  743.     case 4:
  744.         system("cls");
  745.         rewind(stdin);
  746.         return 4; break;
  747.     default:
  748.         cout << "输入错误，请重新输入！！";
  749.         goto WH; break;
  750.     }
  751. }
  752. void mode1() {
  753.     SetSize(width + 10, high + 9);
  754.     Startup();  //初始化
  755.     while (Over？) {   //游戏循环
  756.         Update();
  757.         NoUpdate();
  758.         Show();
  759.     }
  760. }
  761. void mode2() {
  762.     SetSize(width + 10, high + 9);
  763.     Startup();  //初始化
  764.     while (Over？) {   //游戏循环
  765.         Update1();
  766.         NoUpdate1();
  767.         Show();
  768.     }
  769. }
  770. void mode3() {
  771.     SetSize(width + 10, high + 9);
  772.     Startup();  //初始化
  773.     while (Over？) {   //游戏循环
  774.         Update2();
  775.         NoUpdate2();
  776.         Show();
  777.         cout << "剩余生命为：" << life;
  778.     }
  779. }
  780. void result() {
  781.     system("cls");
  782.     double shoot = double(score) / double(num);
  783.     cout << endl;
  784.     cout << endl;
  785.     cout << endl;
  786.     cout << "\t\t\t\t           game over!         " << endl;
  787.     cout << "\t\t\t\t|-----------------------------" << endl;
  788.     printf("\t\t\t\t|       你的得分为:%d         \n", score);
  789.     printf("\t\t\t\t|       已发射子弹数目：%d    \n", num);
  790.     printf("\t\t\t\t|       精准度为：%f          \n", shoot);
  791.     cout << "\t\t\t\t|-----------------------------" << endl;
  792.     //评价
  793.     assist(shoot);
  794.     cout << endl;
  795.     Sleep(2500);    //暂停游戏结束界面（毫秒）
  796.     system("pause");
  797. }
  798. void assist(double shoot) {
  799.     if (shoot > 0 && shoot <= 0.4)
  800.     {
  801.         cout << "\t\t\t\t|       你的精准度较低!!";
  802.     }
  803.     else if (shoot > 0.4 && shoot <= 0.7) {
  804.         cout << "\t\t\t\t|       你的精准度较好!!";
  805.     }
  806.     else if (shoot > 0.7 && shoot <= 1.0) {
  807.         cout << "\t\t\t\t|       你的精准度优秀!!";
  808.     }
  809. }
  810. void SetSize(unsigned uCol, unsigned uLine)//控制台大小控制
  811. {
  812.     char cmd[64];
  813.     sprintf(cmd, "mode con cols=%d lines=%d", uCol, uLine);
  814.     system(cmd);
  815. }

分享结束，谢谢！

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

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

  

闽ICP备14008679号