新手写的贪吃蛇

lingehhhc666

以下代码包含的头文件conio.h只能在windows系统下编译运行！！！

1. //??????
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <windows.h>
   
6. #include <conio.h>
   
7. #include <time.h>
   
8. 
   
9. //??????
   
10. #define MAX 32
    
11. 
    
12. //??????
    
13. char a[20][51] = {"################################################",
    
14.                   "#                                              #",
    
15.                   "#                                              #",
    
16.                   "#                                              #",
    
17.                   "#                                              #",
    
18.                   "#                                              #",
    
19.                   "#                                              #",
    
20.                   "#                                              #",
    
21.                   "#                                              #",
    
22.                   "#                                              #",
    
23.                   "#                                              #",
    
24.                   "#                                              #",
    
25.                   "#                                              #",
    
26.                   "#                                              #",
    
27.                   "#                                              #",
    
28.                   "#                                              #",
    
29.                   "#                                              #",
    
30.                   "#                                              #",
    
31.                   "#                                              #",
    
32.                   "################################################"};
    
33. int game_s_long = 4;
    
34. 
    
35. //??
    
36. struct Body
    
37. {
    
38.     int x;
    
39.     int y;
    
40. } body[999];
    
41. 
    
42. struct Head
    
43. {
    
44.     int x;
    
45.     int y;
    
46.     char turn;
    
47. } head;
    
48. 
    
49. struct Food
    
50. {
    
51.     int x;
    
52.     int y;
    
53. } food;
    
54. 
    
55. //??????
    
56. void game_s_put(void)
    
57. {
    
58.     system("cls");
    
59.     for (int i = 0; i < 20; i++)
    
60.     {
    
61.         puts(a[i]);
    
62.     }
    
63.     printf("score:%d\n", game_s_long);
    
64. }
    
65. void game_s_start(void)
    
66. {
    
67.     a[10][24] = '@';
    
68. 
    
69.     for (int i = 1; i < 5; i++)
    
70.     {
    
71.         a[10 + i][24] = 'O';
    
72.     }
    
73.     head.x = 10, head.y = 24;
    
74.     body[0].x = 11, body[0].y = 24;
    
75.     body[1].x = 12, body[1].y = 24;
    
76.     body[2].x = 13, body[2].y = 24;
    
77.     body[3].x = 14, body[3].y = 24;
    
78.     head.turn = 'w';
    
79. }
    
80. 
    
81. int game_s_move(void)
    
82. {
    
83.     int x1 = 0, x2 = 0, y1 = 0, y2 = 0, i = 0;
    
84.     if (head.turn == 'w')
    
85.     {
    
86.         if (a[head.x - 1][head.y] == 'O' || a[head.x - 1][head.y] == '#')
    
87.         {
    
88.             return 0;
    
89.         }
    
90.     }
    
91.     if (head.turn == 's')
    
92.     {
    
93.         if (a[head.x + 1][head.y] == 'O' || a[head.x + 1][head.y] == '#')
    
94.         {
    
95.             return 0;
    
96.         }
    
97.     }
    
98.     if (head.turn == 'a')
    
99.     {
    
100.         if (a[head.x][head.y - 1] == 'O' || a[head.x][head.y - 1] == '#')
     
101.         {
     
102.             return 0;
     
103.         }
     
104.     }
     
105.     if (head.turn == 'd')
     
106.     {
     
107.         if (a[head.x][head.y + 1] == 'O' || a[head.x][head.y + 1] == '#')
     
108.         {
     
109.             return 0;
     
110.         }
     
111.     }
     
112.     switch (head.turn)
     
113.     {
     
114.     case 'w':
     
115.         if (head.turn != 's')
     
116.         {
     
117.             x1 = head.x;
     
118.             y1 = head.y;
     
119.             head.x--;
     
120.             for (i = 0; i < game_s_long; i += 2)
     
121.             {
     
122.                 x2 = body[i].x;
     
123.                 y2 = body[i].y;
     
124.                 body[i].x = x1;
     
125.                 body[i].y = y1;
     
126.                 if (game_s_long - i == 1)
     
127.                 {
     
128.                     break;
     
129.                 }
     
130.                 x1 = body[i + 1].x;
     
131.                 y1 = body[i + 1].y;
     
132.                 body[i + 1].x = x2;
     
133.                 body[i + 1].y = y2;
     
134.             }
     
135.             body[i + 1].x = x2;
     
136.             body[i + 1].y = y2;
     
137.         }
     
138.         break;
     
139.     case 's':
     
140.         if (head.turn != 'w')
     
141.         {
     
142.             x1 = head.x;
     
143.             y1 = head.y;
     
144.             head.x++;
     
145.             for (i = 0; i < game_s_long; i += 2)
     
146.             {
     
147.                 x2 = body[i].x;
     
148.                 y2 = body[i].y;
     
149.                 body[i].x = x1;
     
150.                 body[i].y = y1;
     
151.                 if (game_s_long - i == 1)
     
152.                 {
     
153.                     break;
     
154.                 }
     
155.                 x1 = body[i + 1].x;
     
156.                 y1 = body[i + 1].y;
     
157.                 body[i + 1].x = x2;
     
158.                 body[i + 1].y = y2;
     
159.             }
     
160.             body[i + 1].x = x2;
     
161.             body[i + 1].y = y2;
     
162.         }
     
163.         break;
     
164.     case 'a':
     
165.         if (head.turn != 'd')
     
166.         {
     
167.             x1 = head.x;
     
168.             y1 = head.y;
     
169.             head.y--;
     
170.             for (i = 0; i < game_s_long; i += 2)
     
171.             {
     
172.                 x2 = body[i].x;
     
173.                 y2 = body[i].y;
     
174.                 body[i].x = x1;
     
175.                 body[i].y = y1;
     
176.                 if (game_s_long - i == 1)
     
177.                 {
     
178.                     break;
     
179.                 }
     
180.                 x1 = body[i + 1].x;
     
181.                 y1 = body[i + 1].y;
     
182.                 body[i + 1].x = x2;
     
183.                 body[i + 1].y = y2;
     
184.             }
     
185.         }
     
186.         body[i + 1].x = x2;
     
187.         body[i + 1].y = y2;
     
188.         break;
     
189.     case 'd':
     
190.         if (head.turn != 'a')
     
191.         {
     
192.             x1 = head.x;
     
193.             y1 = head.y;
     
194.             head.y++;
     
195.             for (i = 0; i < game_s_long; i += 2)
     
196.             {
     
197.                 x2 = body[i].x;
     
198.                 y2 = body[i].y;
     
199.                 body[i].x = x1;
     
200.                 body[i].y = y1;
     
201.                 if (game_s_long - i == 1)
     
202.                 {
     
203.                     break;
     
204.                 }
     
205.                 x1 = body[i + 1].x;
     
206.                 y1 = body[i + 1].y;
     
207.                 body[i + 1].x = x2;
     
208.                 body[i + 1].y = y2;
     
209.             }
     
210.         }
     
211.         body[i + 1].x = x2;
     
212.         body[i + 1].y = y2;
     
213.         break;
     
214.     }
     
215. }
     
216. 
     
217. void game_s_get(void)
     
218. {
     
219.     if (kbhit())
     
220.     {
     
221.         head.turn = getch();
     
222.     }
     
223. }
     
224. 
     
225. void game_s_release(void)
     
226. {
     
227.     strcpy(a[0], "##################################################");
     
228.     strcpy(a[1], "#                                                #");
     
229.     strcpy(a[2], "#                                                #");
     
230.     strcpy(a[3], "#                                                #");
     
231.     strcpy(a[4], "#                                                #");
     
232.     strcpy(a[5], "#                                                #");
     
233.     strcpy(a[6], "#                                                #");
     
234.     strcpy(a[7], "#                                                #");
     
235.     strcpy(a[8], "#                                                #");
     
236.     strcpy(a[9], "#                                                #");
     
237.     strcpy(a[10], "#                                                #");
     
238.     strcpy(a[11], "#                                                #");
     
239.     strcpy(a[12], "#                                                #");
     
240.     strcpy(a[13], "#                                                #");
     
241.     strcpy(a[14], "#                                                #");
     
242.     strcpy(a[15], "#                                                #");
     
243.     strcpy(a[16], "#                                                #");
     
244.     strcpy(a[17], "#                                                #");
     
245.     strcpy(a[18], "#                                                #");
     
246.     strcpy(a[19], "##################################################");
     
247.     a[head.x][head.y] = '@';
     
248.     if (food.x != '\0' && food.y != '\0')
     
249.     {
     
250.         a[food.x][food.y] = '*';
     
251.     }
     
252.     for (int i = 0; i < game_s_long; i++)
     
253.     {
     
254.         a[body[i].x][body[i].y] = 'O';
     
255.     }
     
256. }
     
257. 
     
258. void game_s_food(void)
     
259. {
     
260.     int x, y;
     
261.     time_t t;
     
262.     while(1)
     
263.     {
     
264.     srand((unsigned)time(&t));
     
265.     x = rand() % 20;
     
266.     srand((unsigned)time(&t));
     
267.     y = rand() % 50;
     
268.     if (a[x][y] != '#' && a[x][y] != 'O' && a[x][y] != '@')
     
269.     {
     
270.         food.x = x;
     
271.         food.y = y;
     
272.         break;
     
273.     }
     
274.     }
     
275. }
     
276. 
     
277. int game_s_eat(void)
     
278. {
     
279.     if (head.turn == 'w')
     
280.     {
     
281.         if (a[head.x - 1][head.y] == '*')
     
282.         {
     
283.             food.x = '\0';
     
284.             food.y = '\0';
     
285.             game_s_long++;
     
286.             return 1;
     
287.         }
     
288.     }
     
289.     if (head.turn == 's')
     
290.     {
     
291.         if (a[head.x + 1][head.y] == '*')
     
292.         {
     
293.             food.x = '\0';
     
294.             food.y = '\0';
     
295.             game_s_long++;
     
296.             return 1;
     
297.         }
     
298.     }
     
299.     if (head.turn == 'a')
     
300.     {
     
301.         if (a[head.x][head.y - 1] == '*')
     
302.         {
     
303.             food.x = '\0';
     
304.             food.y = '\0';
     
305.             game_s_long++;
     
306.             return 1;
     
307.         }
     
308.     }
     
309.     if (head.turn == 'd')
     
310.     {
     
311.         if (a[head.x][head.y + 1] == '*')
     
312.         {
     
313.             food.x = '\0';
     
314.             food.y = '\0';
     
315.             game_s_long++;
     
316.             return 1;
     
317.         }
     
318.     }
     
319.     return 0;
     
320. }
     
321. 
     
322. void game_s(void)
     
323. {
     
324.     char ch;
     
325.     int q,p;
     
326.     game_s_food();
     
327.     game_s_start();
     
328.     while (1)
     
329.     {
     
330.         game_s_get();
     
331.         q = game_s_move();
     
332.         if (!q)
     
333.         {
     
334.             exit(0);
     
335.         }
     
336.         p=game_s_eat();
     
337.         if(p)
     
338.         {
     
339.             game_s_food();
     
340.         }
     
341.         game_s_release();
     
342.         game_s_put();
     
343.         Sleep(250);
     
344.     }
     
345. }
     
346. 
     
347. //??????
     
348. int main(void)
     
349. {
     
350.     game_s();
     
351.     return 0;
     
352. }

复制代码

不喜勿喷