这个应该叫飞机打豆豆 不叫飞机大战

就是要努力呀

感觉比昨天写的贪吃蛇差远了
不知道怎么解决在用户没有输入的时候不会卡在scanf那里，后果就是游戏是一帧一帧的，你按一下他就刷新一下
有点赶懒 飞机就是个^ 简单明了
进步就是用了昨天大佬说的gotoxy函数，不再像昨天贪吃蛇那样一直用clear一直清屏了

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <time.h>
   
4. #include <string.h>
   
5. 
   
6. #define MAX 50
   
7. #define RANGE 20        //飞机射程 值越小射程越远
   
8. int X = 40;        //飞机x坐标
   
9. int Y = 24;        //飞机y坐标
   
10. int COUNT = 0;        //得分
    
11. 
    
12. void gotoxy(int x, int y);
    
13. void printmain(void);        //打印主菜单
    
14. void map_set_up(char (*map)[MAX]);        //生成地图
    
15. void plane_set_up(char (*map)[MAX]);        //生成飞机
    
16. void enemy_set_up(char (*enemymap)[MAX]);        //生成敌机
    
17. void print_all(char (*map)[MAX], char (*enemymap)[MAX]);        //打印所有物品
    
18. int get_move(char (*map)[MAX], char (*enemymap)[MAX]);        //获取指令
    
19. void attack(char (*map)[MAX], char (*enemymap)[MAX]);        //进行攻击
    
20. int check_attack(int i, char (*map)[MAX], char (*enemymap)[MAX]);        //检测攻击是否命中
    
21. int do_move(char move, char (*map)[MAX], char (*enemymap)[MAX]);        //进行移动
    
22. int check_plane(char(*map)[MAX], char (*enemymap)[MAX]);        //检测飞机是否越界或碰到敌机
    
23. void reset_plane(char (*map)[MAX]);        //刷新飞机
    
24. 
    
25. void gotoxy(int x, int y)
    
26. {
    
27.         printf("%c[%d;%df", 0x1B, x, y);
    
28. }
    
29. 
    
30. void reset_plane(char (*map)[MAX])        //刷新飞机
    
31. {
    
32.         map[X][Y] = ' ';
    
33. }
    
34. 
    
35. int check_plane(char(*map)[MAX], char (*enemymap)[MAX])        //检测飞机是否越界或碰到敌机
    
36. {
    
37.         if(enemymap[X][Y] == '*')
    
38.         {
    
39.                 return 0;
    
40.         }
    
41. 
    
42.         if(X == 0 || X == MAX - 1 || Y == 0 || Y == MAX - 1)
    
43.         {
    
44.                 return 0;
    
45.         }
    
46. 
    
47.         return 1;
    
48. }
    
49. 
    
50. int do_move(char move, char (*map)[MAX], char (*enemymap)[MAX])        //进行移动
    
51. {
    
52.         reset_plane(map);
    
53. 
    
54.         switch(move)
    
55.         {
    
56.                 case 'w':
    
57.                         X--;
    
58.                         break;
    
59.                 case 'a':
    
60.                         Y--;
    
61.                         break;
    
62.                 case 's':
    
63.                         X++;
    
64.                         break;
    
65.                 case 'd':
    
66.                         Y++;
    
67.                         break;
    
68.         }
    
69. 
    
70.         plane_set_up(map);
    
71.         return check_plane(map, enemymap);
    
72. }
    
73. 
    
74. int check_attack(int i, char (*map)[MAX], char (*enemymap)[MAX])        //检测攻击是否命中
    
75. {
    
76.         if(enemymap[X - i][Y] == '*')
    
77.         {
    
78.                 COUNT++;
    
79. 
    
80.                 enemymap[X - i][Y] = ' ';
    
81.         }
    
82. 
    
83.         print_all(map, enemymap);
    
84. }
    
85. 
    
86. void attack(char (*map)[MAX], char (*enemymap)[MAX])        //进行攻击
    
87. {
    
88.         int i;
    
89.         time_t begin, end;
    
90. 
    
91.         begin = clock();
    
92. 
    
93.         for(i = 1; i <  RANGE && X - i > 0; i++)
    
94.         {
    
95.                 check_attack(i, map, enemymap);
    
96. 
    
97.                 map[X - i][Y] = '|';
    
98.         }
    
99. 
    
100.         end = clock();
     
101.        
     
102.         print_all(map, enemymap);
     
103. 
     
104.         do
     
105.         {
     
106.                 end = clock();
     
107.         }
     
108.         while((end - begin) <= 80000);
     
109. 
     
110.         for(i = 1; i <  RANGE && X - i > 0; i++)
     
111.         {
     
112.                 map[X - i][Y] = ' ';
     
113.         }
     
114. 
     
115.         print_all(map, enemymap);
     
116. }
     
117. 
     
118. int get_move(char (*map)[MAX], char (*enemymap)[MAX])        //获取指令
     
119. {
     
120.         char move;
     
121. 
     
122.         system("stty raw -echo");
     
123. 
     
124.         do
     
125.         {
     
126.                 scanf("%c", &move);
     
127.         }
     
128.         while(move != 'w' && move != 'a' && move != 's' && move != 'd' && move != ' ' && move != 'q');
     
129. 
     
130.         system("stty cooked echo");
     
131. 
     
132.         if(move == 'q')
     
133.         {
     
134.                 return 0;
     
135.         }
     
136. 
     
137.         if(move == ' ')
     
138.         {
     
139.                 attack(map, enemymap);
     
140.         }
     
141.         else return do_move(move, map, enemymap);
     
142. }
     
143. 
     
144. void print_all(char (*map)[MAX], char (*enemymap)[MAX])        //打印所有物品
     
145. {
     
146.         int i, j;
     
147. 
     
148.         gotoxy(0, 0);
     
149.         printf("得分:%d\n", COUNT);
     
150. 
     
151.         for(i = 0; i < MAX; i++)
     
152.         {
     
153.                 for(j = 0; j < MAX; j++)
     
154.                 {
     
155.                         if(enemymap[i][j] != ' ')
     
156.                         {
     
157.                                 printf("%c ", enemymap[i][j]);
     
158.                         }
     
159.                         else printf("%c ", map[i][j]);
     
160.                 }
     
161. 
     
162.                 putchar('\n');
     
163.         }
     
164. }
     
165. 
     
166. void enemy_set_up(char (*enemymap)[MAX])        //生成敌机
     
167. {
     
168.         int count, i, j;
     
169. 
     
170.         srand(time(NULL) + 1.345);
     
171. 
     
172.         for(count = 0; count < 5; count++)
     
173.         {
     
174.                 do
     
175.                 {
     
176.                         i = rand()%47 + 1;
     
177.                         j = rand()%47 + 1;
     
178.                 }
     
179.                 while(i != X && j != Y);
     
180.                
     
181.                 enemymap[i][j] = '*';
     
182.         }
     
183. }
     
184. 
     
185. void plane_set_up(char (*map)[MAX])        //生成飞机
     
186. {
     
187.         map[X][Y] = '^';
     
188. }
     
189. 
     
190. void map_set_up(char (*map)[MAX])        //生成地图
     
191. {
     
192.         int i, j;
     
193. 
     
194.         memset(map, ' ', MAX * MAX);
     
195. 
     
196.         for(i = 0; i < MAX; i++)
     
197.         {
     
198.                 for(j = 0; j < MAX; j++)
     
199.                 {
     
200.                         if(i == 0 || j == 0 || i == MAX - 1 || j == MAX - 1)
     
201.                         {
     
202.                                 map[i][j] = '0';
     
203.                         }
     
204.                 }
     
205.         }
     
206. }
     
207. 
     
208. void printmain(void)        //打印主菜单
     
209. {
     
210.         printf("1.开始游戏\n");
     
211.         printf("2.退出游戏\n");
     
212.         printf(":");
     
213. }
     
214. 
     
215. int main(void)
     
216. {
     
217.         char move;
     
218.         char map[MAX][MAX];
     
219.         char enemymap[MAX][MAX];
     
220.         time_t begin, end;
     
221. 
     
222.         memset(enemymap, ' ', MAX * MAX);
     
223. 
     
224.         do
     
225.         {
     
226.                 printmain();
     
227.                 scanf("%c", &move);
     
228.                 getchar();
     
229.         }
     
230.         while(move != '1' && move != '2');
     
231. 
     
232. 
     
233.         if(move == '1')
     
234.         {
     
235.                 map_set_up(map);
     
236.                 plane_set_up(map);
     
237. 
     
238.                 system("clear");
     
239. 
     
240.                 begin = time(NULL);
     
241. 
     
242.                 do
     
243.                 {
     
244.                         end = time(NULL);
     
245. 
     
246.                         if(((end - begin) % 3) == 0)
     
247.                         {
     
248.                                 enemy_set_up(enemymap);
     
249.                         }
     
250. 
     
251.                         print_all(map, enemymap);
     
252.                         gotoxy(52, 0);
     
253.                         printf("请输入指令(w/a/s/d/j/q):");
     
254.                 }
     
255.                 while(get_move(map, enemymap));
     
256.         }
     
257. 
     
258.         system("stty cooked echo");
     
259.        
     
260.         return 0;
     
261. }

复制代码

就是要努力呀

空格是攻击
提示里忘记改了

人造人

你需要的是非阻塞输入，可以试试ncurses库

1. #include <stdio.h>
   
2. #include <ncurses.h>
   
3. #include <unistd.h>
   
4. 
   
5. int main(void)
   
6. {
   
7.     WINDOW *w = initscr();
   
8.     cbreak();
   
9.     nodelay(w, TRUE);    // 进入非阻塞模式
   
10.     noecho();           // 不要回显
    
11. 
    
12.     sleep(3);
    
13.     mvprintw(10, 5, "hello\n");
    
14.     int ch;
    
15.     ch = getch();
    
16.     printw("%hhx\n", ch);
    
17. 
    
18.     // 退出非阻塞模式
    
19.     nodelay(w, FALSE);
    
20.     getch();
    
21.     endwin();
    
22.     return 0;
    
23. }
    

复制代码

这个程序用来测试非阻塞模式是不是正确
你有3秒时间按任意一个键，如果有按键，程序就输出这个按键
如果没有那就输出 ff
阻塞是由sleep(3);实现的，如果没有这个，你根本没有机会按下任何键
程序最后退出非阻塞模式，等待按下一个键后退出

编译这个程序用

1. gcc -o main main.c -lncurses

复制代码

我使用的是

1. gcc -g -Wall -o main main.c -lncurses

复制代码

1. -lncurses

复制代码

这个是关键

值得一提的是之前的gotoxy作废，ncurses中使用mvprintw

还有一件事，你上面的gotoxy拼错了，写成了goutoxy

^_^

就是要努力呀

人造人 发表于 2020-3-7 18:20
你需要的是非阻塞输入，可以试试ncurses库

ok谢谢大佬虽然看完一脸懵逼