[原创]贡献一个unix的贪吃蛇小游戏

zhangjy2008327

linux下貌似有点问题，不过瑕不掩玉啊，LZ

dididimeme01

我是AIX的环境，没有发现问题。呵呵，挺好的

cobras

windows控制台版本。

1. /***snake.c***/
   
2. 
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <time.h>
   
7. 
   
8. #include <windows.h>
   
9. 
   
10. #define SNAKE_INITX 5
    
11. #define SNAKE_INITY 5
    
12. #define SNAKE_SHAPE '*'
    
13. #define SNAKE_INITLEN 8
    
14. 
    
15. #define WIN_X1 0
    
16. #define WIN_X2 79
    
17. #define WIN_Y1 0
    
18. #define WIN_Y2 24
    
19. 
    
20. #define MAX_LEVEL 20
    
21. #define MAX_INTER 200000
    
22. #define MIN_INTER 0
    
23. #define MAX_RICH 10
    
24. #define DEVRATE 5
    
25. #define OVER "Game Over!!!"
    
26. 
    
27. struct stNode
    
28. {
    
29.         int x;
    
30.         int y;
    
31.         char shape;
    
32.         struct stNode *next;
    
33. };
    
34. 
    
35. struct stFood
    
36. {
    
37.         int x;
    
38.         int y;
    
39. };
    
40. 
    
41. struct stNode *gpstHead,*gpstTail;
    
42. struct stFood gastFood[MAX_RICH];
    
43. int giLevel=1;
    
44. int giRich=1;
    
45. int giScore=0;
    
46. int giLen=0;
    
47. 
    
48. int con_get_size(int *o_width, int *o_height)
    
49. {
    
50.         CONSOLE_SCREEN_BUFFER_INFO info;
    
51.         HANDLE hStdOutput;
    
52.        
    
53.         hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    
54.         GetConsoleScreenBufferInfo(hStdOutput, &info);
    
55.         if (o_width != NULL) {
    
56.                 *o_width = info.dwMaximumWindowSize.X;
    
57.         }
    
58.         if (o_height != NULL) {
    
59.                 *o_height = info.dwMaximumWindowSize.Y;
    
60.         }
    
61.         return 0;
    
62. }
    
63. 
    
64. int con_rectangle(int x1, int y1, int x2, int y2, char c)
    
65. {
    
66.         HANDLE hStdOutput;
    
67.         COORD coord;
    
68.         DWORD dwOutputlen;
    
69.         int len;
    
70.         int width, height;
    
71.        
    
72.         con_get_size(&width, &height);
    
73.         if (x1 < 0) {
    
74.                 x1 = 0;
    
75.         }
    
76.         if (y1 < 0) {
    
77.                 y1 = 0;
    
78.         }
    
79.         if (x2 >= width) {
    
80.                 x2 = width - 1;
    
81.         }
    
82.         if (y2 >= height) {
    
83.                 y2 = height - 1;
    
84.         }
    
85.         if (x1 <= x2 && y1 <= y2) {
    
86.                 hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    
87.                 len = x2 - x1 + 1;
    
88.                 coord.X = x1;
    
89.                 for (coord.Y = y1; coord.Y <= y2; ++coord.Y) {
    
90.                         FillConsoleOutputCharacter(hStdOutput, c, len, coord, &dwOutputlen);
    
91.                 }
    
92.                 return 0;
    
93.         }
    
94.         return -1;
    
95. }
    
96. 
    
97. int con_init(void)
    
98. {
    
99.         HANDLE hStdOutput;
    
100.         DWORD dwMode;
     
101.        
     
102.         hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
     
103.         GetConsoleMode(hStdOutput, &dwMode);
     
104.         dwMode &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
     
105.         SetConsoleMode(hStdOutput, dwMode);
     
106.         return 0;
     
107. }
     
108. 
     
109. int con_show_cursor(int yes)
     
110. {
     
111.         HANDLE hStdOutput;
     
112.         CONSOLE_CURSOR_INFO info;
     
113.        
     
114.         hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
     
115.         GetConsoleCursorInfo(hStdOutput, &info);
     
116.         info.bVisible = yes != 0;
     
117.         SetConsoleCursorInfo(hStdOutput, &info);
     
118.         return 0;
     
119. }
     
120. 
     
121. int con_setxy(int x, int y)
     
122. {
     
123.         HANDLE hStdOutput;
     
124.         COORD coord;
     
125.        
     
126.         hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
     
127.         coord.X = x;
     
128.         coord.Y = y;
     
129.         SetConsoleCursorPosition(hStdOutput, coord);
     
130.         return 0;
     
131. }
     
132. 
     
133. int con_putchar(int x, int y, char c)
     
134. {
     
135.         int width, height;
     
136.        
     
137.         con_get_size(&width, &height);
     
138.         if (x >= 0 && x < width && y >= 0 && y < height) {
     
139.                 con_setxy(x, y);
     
140.                 putchar(c);
     
141.                 return 0;
     
142.         }
     
143.         return -1;
     
144. }
     
145. 
     
146. int con_puttext(int x, int y, const char *text, int text_len)
     
147. {
     
148.         int tx;
     
149.         int i;
     
150.         int width, height;
     
151.        
     
152.         con_get_size(&width, &height);
     
153.         tx = x;
     
154.         for (i = 0; i < text_len; ++i) {
     
155.                 switch (text[i]) {
     
156.                 case '\n':
     
157.                         tx = x;
     
158.                         ++y;
     
159.                         break;
     
160.                 case '\t':
     
161.                         tx = (tx + 8 - 1) / 8;
     
162.                         tx *= 8;
     
163.                         break;
     
164.                 case '\r':
     
165.                         tx = x;
     
166.                         break;
     
167.                 case '\b':
     
168.                         if (tx > x) {
     
169.                                 --tx;
     
170.                         }
     
171.                         break;
     
172.                 default:
     
173.                         if (tx >= 0 && tx < width && y >= 0 && y < height) {
     
174.                                 con_setxy(tx, y);
     
175.                                 putchar(text[i]);
     
176.                         }
     
177.                         ++tx;
     
178.                         break;
     
179.                 }
     
180.         }
     
181.         return 0;
     
182. }
     
183. 
     
184. int con_box(int x1, int y1, int x2, int y2)
     
185. {
     
186.         int i;
     
187.        
     
188.         for (i = x1 + 1; i < x2; ++i) {
     
189.                 con_puttext(i, y1, "-", 1);
     
190.                 con_puttext(i, y2, "-", 1);
     
191.         }
     
192.         for (i = y1 + 1; i < y2; ++i) {
     
193.                 con_puttext(x1, i, "|", 1);
     
194.                 con_puttext(x2, i, "|", 1);
     
195.         }
     
196.         con_puttext(x1, y1, "+", 1);
     
197.         con_puttext(x2, y1, "+", 1);
     
198.         con_puttext(x1, y2, "+", 1);
     
199.         con_puttext(x2, y2, "+", 1);
     
200.         return 0;
     
201. }
     
202. 
     
203. int con_readkey(void)
     
204. {
     
205.         HANDLE hStdInput;
     
206.         INPUT_RECORD buf;
     
207.         DWORD dwRead;
     
208.         int retval;
     
209.        
     
210.         hStdInput = GetStdHandle(STD_INPUT_HANDLE);
     
211.         for (;;) {
     
212.                 if (PeekConsoleInput(hStdInput, &buf, 1, &dwRead)) {
     
213.                         if (dwRead == 1) {
     
214.                                 if (ReadConsoleInput(hStdInput, &buf, 1, &dwRead)) {
     
215.                                         if (buf.EventType == KEY_EVENT) {
     
216.                                                 return buf.Event.KeyEvent.wVirtualScanCode;
     
217.                                         }else {
     
218.                                                 continue;
     
219.                                         }
     
220.                                 }else {
     
221.                                         retval = -2; /* READ ERROR */
     
222.                                 }
     
223.                         }else {
     
224.                                 retval = 0; /* NO KEY PRESSED */
     
225.                         }
     
226.                 }else {
     
227.                         retval = -1; /* PEEK ERROR */
     
228.                 }
     
229.                 break;
     
230.         }
     
231.         return retval;
     
232. }
     
233. 
     
234. int con_delay(int ms)
     
235. {
     
236.         Sleep(ms);
     
237.         return 0;
     
238. }
     
239. 
     
240. void vDrawOneNode(struct stNode *pstNode,int iFlag)
     
241. {
     
242.         con_puttext(pstNode->x, pstNode->y, iFlag ? &pstNode->shape : " ", 1);
     
243. }
     
244. 
     
245. void vDrawOneFood(int x,int y)
     
246. {
     
247.         con_puttext(x, y, "@", 1);
     
248. }
     
249. 
     
250. int iGetDir(int iOriDir)
     
251. {
     
252.         switch (con_readkey()) {
     
253.         case 72  ://UP
     
254.                 return 0;
     
255.         case 80 ://DOWN
     
256.                 return 1;
     
257.         case 77  ://RIGHT
     
258.                 return 2;
     
259.         case 75 ://LEFT
     
260.                 return 3;
     
261.         default:
     
262.                 return iOriDir;
     
263.         }
     
264. }
     
265. 
     
266. void vInitScreen()
     
267. {
     
268.         con_init();
     
269.         con_show_cursor(0);
     
270.         con_rectangle(WIN_X1, WIN_Y1, WIN_X2, WIN_Y2, ' ');
     
271. }
     
272. 
     
273. void vRestoreScreen()
     
274. {
     
275.         con_show_cursor(1);
     
276. }
     
277. 
     
278. void vDrawScope()
     
279. {
     
280.         con_box(WIN_X1, WIN_Y1, WIN_X2, WIN_Y2);
     
281. }
     
282. 
     
283. void vCreateSnake()
     
284. {
     
285.         struct stNode *pstNew;
     
286.         int i;
     
287.        
     
288.         gpstHead=(struct stNode*)malloc(sizeof(struct stNode));
     
289.         gpstHead->x=SNAKE_INITX;        
     
290.         gpstHead->y=SNAKE_INITY;
     
291.         gpstHead->shape=SNAKE_SHAPE;
     
292.         gpstHead->next=NULL;
     
293.         vDrawOneNode(gpstHead,1);
     
294.         gpstTail=gpstHead;
     
295.         for(i=1;i<SNAKE_INITLEN;i++)
     
296.         {
     
297.                 pstNew=(struct stNode*)malloc(sizeof(struct stNode));
     
298.                 pstNew->x=gpstHead->x+1;        
     
299.                 pstNew->y=gpstHead->y;
     
300.                 pstNew->shape=SNAKE_SHAPE;
     
301.                 pstNew->next=NULL;
     
302.                 vDrawOneNode(pstNew,1);
     
303.                 gpstHead->next=pstNew;
     
304.                 gpstHead=pstNew;
     
305.         }
     
306.         return;
     
307. }
     
308. 
     
309. void vKillSnake()
     
310. {
     
311.         struct stNode *pstNode;
     
312.        
     
313.         for(pstNode=gpstTail;gpstTail!=NULL;)
     
314.         {
     
315.                 gpstTail=pstNode->next;
     
316.                 free(pstNode);
     
317.                 pstNode=gpstTail;
     
318.         }
     
319. }
     
320. 
     
321. void vGenFood(int iIdx)
     
322. {
     
323.         struct stNode *pstNode;
     
324.         int i,iFound=0;
     
325.        
     
326.         for(;!iFound;)
     
327.         {
     
328.                 iFound=1;
     
329.                 gastFood[iIdx].x=rand()%(WIN_X2-WIN_X1-1)+WIN_X1+1;
     
330.                 gastFood[iIdx].y=rand()%(WIN_Y2-WIN_Y1-1)+WIN_Y1+1;
     
331.                 for(i=0;i<giRich;i++)
     
332.                 {
     
333.                         if(i!=iIdx && gastFood[iIdx].x==gastFood[i].x &&
     
334.                                 gastFood[iIdx].y==gastFood[i].y)
     
335.                         {
     
336.                                 iFound=0;
     
337.                                 break;
     
338.                         }
     
339.                 }
     
340.                 if(!iFound) continue;
     
341.                 for(pstNode=gpstTail;pstNode!=NULL;pstNode=pstNode->next)
     
342.                 {
     
343.                         if(gastFood[iIdx].x==pstNode->x &&
     
344.                                 gastFood[iIdx].y==pstNode->y)
     
345.                         {
     
346.                                 iFound=0;
     
347.                                 break;
     
348.                         }
     
349.                 }
     
350.                 if(!iFound) continue;
     
351.         }
     
352.         vDrawOneFood(gastFood[iIdx].x,gastFood[iIdx].y);
     
353. }
     
354. 
     
355. void vInitFood()
     
356. {
     
357.         int i;
     
358.        
     
359.         srand(time(NULL));
     
360.         for(i=0;i<giRich;i++)        vGenFood(i);
     
361. }
     
362. 
     
363. int iIsValid(int x,int y)
     
364. {
     
365.         struct stNode *pstNode;
     
366.        
     
367.         if(x<=WIN_X1 || x>=WIN_X2 || y<=WIN_Y1 || y>=WIN_Y2)
     
368.                 return(0);
     
369.         pstNode=gpstTail;
     
370.         for(;pstNode!=NULL;)
     
371.         {
     
372.                 if(x==pstNode->x && y==pstNode->y)
     
373.                         return(0);
     
374.                 pstNode=pstNode->next;
     
375.         }
     
376.         return(1);
     
377. }
     
378. 
     
379. int iEat(int x,int y)
     
380. {
     
381.         int i;
     
382.        
     
383.         for(i=0;i<giRich;i++)
     
384.         {
     
385.                 if(x==gastFood[i].x && y==gastFood[i].y)
     
386.                 {
     
387.                         vGenFood(i);
     
388.                         giScore+=giLevel*10;
     
389.                         giLen++;
     
390.                         if(giLevel<MAX_LEVEL)
     
391.                                 if(giLen%DEVRATE==0)
     
392.                                         giLevel++;
     
393.                                 return(1);
     
394.                 }
     
395.         }
     
396.         return(0);
     
397. }
     
398. 
     
399. int main(void)
     
400. {
     
401.         int iDir=2,iNextX,iNextY;
     
402.         struct stNode *pstNew;
     
403.         char sPrompt[80];
     
404.        
     
405.         vInitScreen();
     
406.         vDrawScope();
     
407.         vCreateSnake();
     
408.         vInitFood();
     
409.         for(;;) {
     
410.                 iDir=iGetDir(iDir);
     
411.                 iNextX=gpstHead->x+(iDir>>1)*(5-(iDir<<1));
     
412.                 iNextY=gpstHead->y-(!(iDir>>1))*(1-(iDir<<1));
     
413.                 if(!iIsValid(iNextX,iNextY)) {
     
414.                         con_puttext((WIN_X1+WIN_X2)/2-strlen(OVER)/2, WIN_Y2-1,OVER, strlen(OVER));
     
415.                         break;
     
416.                 }
     
417.                 pstNew=(struct stNode*)malloc(sizeof(struct stNode));
     
418.                 pstNew->x=iNextX;
     
419.                 pstNew->y=iNextY;
     
420.                 pstNew->shape=SNAKE_SHAPE;
     
421.                 pstNew->next=NULL;
     
422.                 gpstHead->next=pstNew;
     
423.                 gpstHead=pstNew;
     
424.                 vDrawOneNode(gpstHead, 1);
     
425.                 if(!iEat(iNextX,iNextY)) {
     
426.                         vDrawOneNode(gpstTail, 0);
     
427.                         pstNew = gpstTail;
     
428.                         gpstTail = gpstTail->next;
     
429.                         free(pstNew);
     
430.                 }
     
431.                 sprintf(sPrompt,"Score:%7d Level:%2d",giScore,giLevel);
     
432.                 con_puttext((WIN_X1+WIN_X2)/2-strlen(sPrompt)/2, WIN_Y2, sPrompt, strlen(sPrompt));
     
433.                 con_delay((MAX_INTER-(MAX_INTER-MIN_INTER)/MAX_LEVEL*giLevel)/1000);
     
434.         }
     
435.         vKillSnake();
     
436.         vRestoreScreen();
     
437.         return 0;
     
438. }
     

复制代码

除美灭日平韩

马克刘明！

zsszss0000

楼主，你太牛了

ANONYMOUS419

为了不挨砖，喷一下。。楼主代码风骚

jimmy817817

试过了，编辑有错误，不过可以玩。系统是 solaris的

incle

不错，很赞啊。