设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › 改进后的飞机大战
返回列表 发新帖
查看: 1140|回复: 0

[技术交流] 改进后的飞机大战

[复制链接]
就是要努力呀
发表于 2020-3-11 19:22:45 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
敌机会动了，也会攻击了，不过只能攻击一次，bug很多，在检测方面做的很差，折腾了一天了，从早上9.写到现在，受不了了，暂时这样吧，代码贴出来展示下思路
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <sys/time.h>
  5. #include <signal.h>
  6. #include <ncurses.h>

  8. #define X_MAX 53  地图大小
  9. #define Y_MAX 100
  10. #define BLACKDROP ' ' 背景
  11. #define BOUNDARY '0' 边界
  12. #define ENEMY 'v' 敌机
  13. #define PLANE '^' 自己
  14. #define ATTACK '|' 己方子弹
  15. #define ATTACK1 '*' 地方子弹

  17. typedef struct Enemy 敌机结构体
  18. {
  19.         int x;
  20.         int y;
  21.         _Bool tof;
  22.         struct Enemy *next;
  23. }
  24. Enemy;

  26. typedef struct Enemy_attack 敌机子弹结构体
  27. {
  28.         int x;
  29.         int y;
  30.         struct Enemy_attack *next;
  31. }
  32. Enemy_attack;

  34. typedef struct Attack 己方子弹结构体
  35. {
  36.         int x;
  37.         int y;
  38.         struct Attack *next;
  39. }
  40. Attack;

  42. Enemy *EHEAD, *ETAIL;
  43. Enemy_attack *EAHEAD, *EATAIL;
  44. Attack *HEAD, *TAIL;
  45. int X = 52, Y = 50; 自己坐标

  47. void my_refresh(); 刷新
  48. void printmain(void); 打印菜单
  49. void make_HEAD(void); 创建链表头指针
  50. void set_itimerval(struct itimerval *t); 设定定时时间
  51. void printmap(void); 打印地图
  52. void set_plane(void); 放置飞机
  53. int get_move(char move); 获取移动
  54. void clear_plane(void); 清楚飞机
  55. void plane_attack(void); 攻击指令
  56. void set_attack(int x, int y); 放置子弹
  57. void attack_refresh(void); 刷新子弹
  58. void clear_attack(int x, int y); 清楚子弹
  59. void free_attack(Attack *last, Attack *next); 释放子弹链表

  61. void add_enemy(void); 添加敌机
  62. void move_enemy(void); 敌机移动
  63. void clear_enemy(int x, int y); 清除敌机
  64. void free_enemy(Enemy *last, Enemy *next); 释放敌机链表
  65. void set_enemy(int x, int y); 放置敌机
  66. void enemy_attack(Enemy *next); 敌机攻击
  67. void set_enemy_attack(int x, int y); 放置敌机子弹
  68. void enemy_attack_refresh(void); 刷新敌机子弹
  69. void clear_enemy_attack(int x, int y); 清楚敌机子弹
  70. void free_enemy_attack(Enemy_attack *last, Enemy_attack *next); 释放敌机子弹链表
  71. void exit_game(void); 退出游戏

  73. void exit_game(void)
  74. {
  75.         endwin();
  76.         exit(0);
  77. }

  79. void free_enemy_attack(Enemy_attack *last, Enemy_attack *next)
  80. {
  81.         last->next = next->next;

  83.         free(next);

  85.         refresh();
  86. }

  88. void clear_enemy_attack(int x, int y)
  89. {
  90.         move(x, y);
  91.         addch(BLACKDROP);

  93.         refresh();
  94. }

  96. void enemy_attack_refresh(void)
  97. {
  98.         Enemy_attack *last, *next;

  100.         last = EAHEAD;
  101.         next = EAHEAD->next;

  103.         while(next != NULL)
  104.         {
  105.                 clear_enemy_attack(next->x, next->y);

  107.                 next->x++;

  109.                 move(next->x, next->y);

  111.                 if(inch() == BOUNDARY)
  112.                 {
  113.                         free_enemy_attack(last, next);

  115.                         next = last->next;
  116.                 }
  117.                 else
  118.                 {
  119.                         set_enemy_attack(next->x, next->y);

  121.                         last->next;
  122.                         next = next->next;
  123.                 }
  124.         }

  126.         refresh();
  127. }

  129. void set_enemy_attack(int x, int y)
  130. {
  131.         move(x, y);
  132.         addch(ATTACK1);

  134.         refresh();
  135. }

  137. void enemy_attack(Enemy *next)
  138. {
  139.         Enemy_attack *new;

  141.         new = (Enemy_attack *)malloc(sizeof(Enemy_attack));

  143.         new->x = next->x;
  144.         new->y = next->y;

  146.         if(EAHEAD->next == NULL)
  147.         {
  148.                 EAHEAD->next = new;
  149.         }
  150.         else
  151.         {
  152.                 EATAIL->next = new;
  153.         }

  155.         new->next = NULL;
  156.         EATAIL = new;

  158.         set_enemy_attack(new->x, new->y);

  160.         refresh();
  161. }

  163. void set_enemy(int x, int y)
  164. {
  165.         move(x, y);
  166.         addch(ENEMY);

  168.         refresh();
  169. }

  171. void free_enemy(Enemy *last, Enemy *next)
  172. {
  173.         last->next = next->next;

  175.         free(next);

  177.         refresh();
  178. }

  180. void clear_enemy(int x, int y)
  181. {
  182.         move(x, y);
  183.         addch(BLACKDROP);

  185.         refresh();
  186. }

  188. void move_enemy(void)
  189. {
  190.         Enemy *last, *next;
  191.         int i;
  192.         char a;

  194.         last = EHEAD;
  195.         next = EHEAD->next;

  197.         while(next != NULL)
  198.         {
  199.                 i = rand()%5;

  201.                 clear_enemy(next->x, next->y);

  203.                 switch(i)
  204.                 {
  205.                         case 0:
  206.                                 next->x++;
  207.                                 break;
  208.                         case 1:
  209.                                 next->x--;
  210.                                 break;
  211.                         case 2:
  212.                                 next->y++;
  213.                                 break;
  214.                         case 3:
  215.                                 next->y--;
  216.                                 break;
  217.                         case 4:
  218.                                 if(next->tof == 0)
  219.                                 {
  220.                                         next->tof = 1;
  221.                                         enemy_attack(next);
  222.                                 }
  223.                                 break;
  224.                 }

  226.                 move(next->x, next->y);

  228.                 a = inch();

  230.                 if(a == BOUNDARY || a == ATTACK)
  231.                 {
  232.                         free_enemy(last, next);
  233.                         next = last->next;
  234.                 }
  235.                 else
  236.                 {
  237.                         set_enemy(next->x, next->y);

  239.                         last = next;
  240.                         next = next->next;
  241.                 }
  242.         }

  244.         refresh();
  245. }

  247. void add_enemy(void)
  248. {
  249.         Enemy *enemy;
  250.         int x, y;
  251.         _Bool tof;

  253.         enemy = (Enemy *)malloc(sizeof(Enemy));

  255.         do
  256.         {
  257.                 tof = 1;
  258.                 enemy->x = rand()%(X_MAX - 1) + 1;
  259.                 enemy->y = rand()%(X_MAX - 1) + 1;

  261.                 move(enemy->x, enemy->y);

  263.                 if(inch() !=  BLACKDROP)
  264.                 {
  265.                         tof = 0;
  266.                 }
  267.         }
  268.         while(!tof);

  270.         if(EHEAD->next == NULL)
  271.         {
  272.                 EHEAD->next = enemy;
  273.         }
  274.         else
  275.         {
  276.                 ETAIL->next = enemy;
  277.         }

  279.         enemy->next = NULL;
  280.         ETAIL = enemy;

  282.         refresh();
  283. }

  285. void free_attack(Attack *last, Attack *next)
  286. {
  287.         last->next = next->next;

  289.         free(next);

  291.         refresh();
  292. }

  294. void clear_attack(int x, int y)
  295. {
  296.         move(x, y);
  297.         addch(BLACKDROP);

  299.         refresh();
  300. }

  302. void attack_refresh(void)
  303. {
  304.         Attack *last, *next, *temp;

  306.         last = HEAD;
  307.         next = HEAD->next;

  309.         while(next != NULL)
  310.         {
  311.                 clear_attack(next->x, next->y);

  313.                 next->x--;

  315.                 move(next->x, next->y);

  317.                 if(inch() == BOUNDARY)
  318.                 {
  319.                         free_attack(last, next);
  320.                         next = last->next;
  321.                 }
  322.                 else
  323.                 {
  324.                         set_attack(next->x, next->y);

  326.                         last = next;
  327.                         next = next->next;
  328.                 }
  329.         }

  331.         refresh();
  332. }

  334. void set_attack(int x, int y)
  335. {
  336.         move(x, y);
  337.         addch(ATTACK);

  339.         refresh();
  340. }

  342. void plane_attack(void)
  343. {
  344.         Attack *new;

  346.         new = (Attack *)malloc(sizeof(Attack));

  348.         new->x = X - 1;
  349.         new->y = Y;

  351.         if(HEAD->next == NULL)
  352.         {
  353.                 HEAD->next = new;
  354.         }
  355.         else
  356.         {
  357.                 TAIL->next = new;
  358.         }

  360.         new->next = NULL;
  361.         TAIL = new;

  363.         set_attack(new->x, new->y);

  365.         refresh();
  366. }

  368. void clear_plane(void)
  369. {
  370.         move(X, Y);
  371.         addch(BLACKDROP);

  373.         refresh();
  374. }

  376. int get_move(char move)
  377. {
  378.         int  x, y;
  379.         char a;

  381.         x = X;
  382.         y = Y;

  384.         clear_plane();

  386.         switch(move)
  387.         {
  388.                 case 'w':
  389.                         X--;
  390.                         break;
  391.                 case 'a':
  392.                         Y--;
  393.                         break;
  394.                 case 's':
  395.                         X++;
  396.                         break;
  397.                 case 'd':
  398.                         Y++;
  399.                         break;
  400.                 case 'j':
  401.                         plane_attack();
  402.                         break;
  403.                 case 'q':
  404.                         return 0;
  405.         }

  407.         move(X, Y);

  409.         a = inch();

  411.         if(a == ATTACK1 || a == ENEMY)
  412.         {
  413.                 exit_game();
  414.         }
  415.         if(a == BOUNDARY)
  416.         {
  417.                 X = x;
  418.                 Y = y;
  419.         }


  422.         refresh();

  424.         return 1;
  425. }

  427. void set_plane(void)
  428. {
  429.         move(X, Y);
  430.         addch(PLANE);

  432.         refresh();
  433. }

  435. void printmap(void)
  436. {
  437.         int x, y;

  439.         move(0, 0);
  440.         addstr("      \n      \n ");

  442.         for(x = 0; x <= X_MAX; x++)
  443.         {
  444.                 for(y = 0; y <= Y_MAX; y++)
  445.                 {
  446.                         if(x == 0 || y == 0 || x == X_MAX || y == Y_MAX)
  447.                         {
  448.                                 move(x, y);
  449.                                 addch(BOUNDARY);
  450.                         }
  451.                 }

  453.         }

  455.         move(X_MAX + 1, 0);
  456.         addstr("(w/a/s/d/j/q):");

  458.         refresh();
  459. }

  461. void set_itimerval(struct itimerval *t)
  462. {
  463.         t->it_interval.tv_usec = 200000;
  464.         t->it_interval.tv_sec = 0;
  465.         t->it_value.tv_usec = 10;
  466.         t->it_value.tv_sec = 0;
  467. }

  469. void make_HEAD(void)
  470. {
  471.         HEAD = (Attack *)malloc(sizeof(Attack));
  472.         HEAD->x = 0;
  473.         HEAD->y = 0;
  474.         HEAD->next = NULL;

  476.         EHEAD = (Enemy *)malloc(sizeof(Enemy));
  477.         EHEAD->x = 0;
  478.         EHEAD->y = 0;
  479.         EHEAD->tof = 0;
  480.         EHEAD->next = NULL;

  482.         EAHEAD = (Enemy_attack *)malloc(sizeof(Enemy_attack));
  483.         EAHEAD->x = 0;
  484.         EAHEAD->y = 0;
  485.         EAHEAD->next = NULL;
  486. }

  488. void printmain()
  489. {
  490.         move(0, 0);

  492.         addstr("1.begin\n");
  493.         addstr("2.quit\n");
  494.         addch(':');

  496.         refresh();
  497. }

  499. void my_refresh()
  500. {
  501.         int i = rand()%100;

  503.         attack_refresh();

  505.         if(i >= 0 && i <= 20)
  506.         {
  507.                 add_enemy();
  508.         }

  510.         move_enemy();
  511.         enemy_attack_refresh();

  513.         refresh();
  514. }

  516. int main(void)
  517. {
  518.         struct itimerval t;
  519.         char move;

  521.         initscr();
  522.         cbreak();
  523.         noecho();
  524.         curs_set(0);

  526.         printmain();

  528.         move = getch();

  530.         if(move == '1')
  531.         {
  532.                 make_HEAD();
  533.                 set_itimerval(&t);
  534.                 setitimer(ITIMER_REAL, &t, NULL);
  535.                 signal(SIGALRM, my_refresh);

  537.                 printmap();

  539.                 do
  540.                 {
  541.                         srand(time(NULL));

  543.                         do
  544.                         {
  545.                                 set_plane();
  546.                                 move = getch();
  547.                         }
  548.                         while(move != 'q' && move != 'w' && move != 'a' && move != 's' && move != 'd' && move != 'j');
  549.                 }
  550.                 while(get_move(move));
  551.         }

  553.         endwin();

  555.         return 0;
  556. }
复制代码




小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-7-13 04:54

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表