[已解决]C++贪吃蛇错误

livcui

1. #include <iostream>
   
2. #include <cstdio>
   
3. #include <graphics.h>
   
4. #include <Windows.h>
   
5. #include <conio.h>
   
6. #include <time.h>
   
7. 
   
8. /********************************
   
9. *        初始化蛇1                intiSnake
   
10. *        初始化蛇2                intiSnake_2
    
11. *        画蛇1                        drawSnake
    
12. *        画蛇2                        drawSnake_2
    
13. *        移动蛇1                        moveSnake
    
14. *        移动蛇2                        moveSnake_2
    
15. *        按键处理                keyDown
    
16. *        初始化食物                initFood
    
17. *        画食物                        drawFood
    
18. *        蛇1吃食物                eatFood
    
19. *        蛇2吃食物                eatFood_2
    
20. *        判断蛇1死亡                snakeDie
    
21. *        判断蛇2死亡                snakeDie_2
    
22. *        显示蛇1分数                showGrade
    
23. *        显示蛇2分数                showGrade_2
    
24. *********************************/
    
25. void initSnake();
    
26. void initSnake_2();
    
27. void drawSnake();
    
28. void drawSnake_2();
    
29. void moveSnake();
    
30. void moveSnake_2();
    
31. void keyDown();
    
32. void initFood();
    
33. void drawFood();
    
34. void eatFood();
    
35. void eatFood_2();
    
36. void snakeDie();
    
37. void snakeDie_2();
    
38. void showGrade();
    
39. void showGrade_2();
    
40. 
    
41. //坐标
    
42. struct point_XY {
    
43. 
    
44.         int x;
    
45.         int y;
    
46. 
    
47. };
    
48. 
    
49. //蛇属性
    
50. struct {
    
51. 
    
52.         int num;                                //蛇的节数
    
53.         point_XY snakeXY[100];  //最多100节
    
54.         char postion;                        //方向
    
55.         int flag;                                //判断是否蛇死亡
    
56. 
    
57. }snake, snake_2;
    
58. 
    
59. //食物的属性
    
60. struct {
    
61. 
    
62.         point_XY foodXY;        //食物坐标(X和Y)
    
63.         int eatGrade;                //吃掉食物所得分数
    
64.         int flag;                    //食物是否存在
    
65. 
    
66. }food;
    
67. 
    
68. //枚举方向  模拟键码值
    
69. enum movPostion {
    
70. 
    
71.         right = 72, left = 75, down = 77, up = 80,                        //对应右左下上键的键码值
    
72.         right_2 = 68, left_2 = 65, down_2 = 83, up_2 = 87        //对应dasw的键码值
    
73. 
    
74. };
    
75. 
    
76. HWND hwnd;
    
77. int speed = 50;
    
78. 
    
79. int main() {
    
80. 
    
81.         using namespace std;
    
82. 
    
83.         srand((unsigned int)time(NULL));
    
84.         hwnd = initgraph(640, 480);
    
85.         setbkcolor(WHITE);                //窗口颜色为白White
    
86.         cleardevice();                        //刷新
    
87.         initSnake();                        //创建蛇1
    
88.         initSnake_2();                        //创建蛇2
    
89.         snake.flag = 0;                        //蛇1活着
    
90.         snake_2.flag = 0;                //蛇2活着
    
91.         initFood();                                //创建食物
    
92. 
    
93.         while (true) {
    
94.                 cleardevice();                //刷新背景
    
95.                 drawSnake();                //画蛇1
    
96.                 drawSnake_2();                //画蛇2
    
97.                 moveSnake();                //移动蛇1
    
98.                 moveSnake_2();                //移动蛇2
    
99.                 snakeDie();                        //判断蛇1死亡
    
100.                 snakeDie_2();                //判断蛇2死亡
     
101.                 if (snake.flag == 1 or snake_2.flag == 1) break;                        //如果死了，停止循环
     
102.                 if (food.flag != 1) initFood();                //初始化食物
     
103.                 if (food.flag == 1) drawFood();                //画食物
     
104. 
     
105.                 eatFood();
     
106.                 eatFood_2();
     
107. 
     
108.                 while (_kbhit()) {
     
109. 
     
110.                         keyDown();                //如果有键盘输入，检测输入
     
111. 
     
112.                 }
     
113. 
     
114.                 Sleep(speed);                //间隔时间50ms
     
115. 
     
116.         }
     
117. 
     
118.         getchar();
     
119. 
     
120.         return 0;
     
121. }
     
122. 
     
123. //初始化蛇1
     
124. void initSnake() {
     
125. 
     
126.         snake.num = 3;        //初始化时为三节
     
127. 
     
128.         snake.snakeXY[0].x = 20;
     
129.         snake.snakeXY[0].y = 0;
     
130. 
     
131.         snake.snakeXY[1].x = 10;        //间隔10像素
     
132.         snake.snakeXY[1].y = 0;
     
133. 
     
134.         snake.snakeXY[2].x = 0;
     
135.         snake.snakeXY[2].y = 0;
     
136. 
     
137.         snake.postion = right;                //初始化方向为右
     
138. 
     
139.         food.flag = 0;
     
140. 
     
141. }
     
142. 
     
143. //初始化蛇2
     
144. void initSnake_2() {
     
145. 
     
146.         snake_2.num = 3;                                //初始化时为三节
     
147.        
     
148.         snake_2.snakeXY[0].x = 10;
     
149.         snake_2.snakeXY[0].y = 300;
     
150. 
     
151.         snake_2.snakeXY[1].x = 10;                //间隔10像素
     
152.         snake_2.snakeXY[1].y = 290;
     
153. 
     
154.         snake_2.snakeXY[2].x = 10;
     
155.         snake_2.snakeXY[2].y = 280;
     
156. 
     
157.         snake_2.postion = down_2;                //初始化方向为右
     
158. 
     
159.         food.flag = 0;
     
160. 
     
161. }
     
162. 
     
163. //画蛇1
     
164. void drawSnake() {
     
165. 
     
166.         for (int i = 0; i < snake.num; i++) {
     
167. 
     
168.                 setlinecolor(BLACK);        //矩形边框颜色为黑Black
     
169.                 setfillcolor(BLUE);                //矩形内部颜色为蓝blue
     
170.                 fillrectangle(snake.snakeXY[i].x, snake.snakeXY[i].y, snake.snakeXY[i].x + 10, snake.snakeXY[i].y + 10);
     
171. 
     
172.         }
     
173. 
     
174. }
     
175. 
     
176. //画蛇2
     
177. void drawSnake_2() {
     
178. 
     
179.         for (int i = 0; i < snake.num; i++) {
     
180. 
     
181.                 setlinecolor(BLACK);        //矩形边框颜色为黑Black
     
182.                 setfillcolor(GREEN);                //矩形内部颜色为绿Green
     
183.                 fillrectangle(snake_2.snakeXY[i].x, snake_2.snakeXY[i].y, snake_2.snakeXY[i].x + 10, snake_2.snakeXY[i].y + 10);
     
184. 
     
185.         }
     
186. 
     
187. }
     
188. 
     
189. //移动蛇1
     
190. void moveSnake() {
     
191.         //除蛇第一节以外的移动坐标处理
     
192.         for (int i = snake.num - 1; i > 0; i--) {
     
193. 
     
194.                 snake.snakeXY[i].x = snake.snakeXY[i - 1].x;
     
195.                 snake.snakeXY[i].y = snake.snakeXY[i - 1].y;
     
196. 
     
197.         }
     
198. 
     
199.         //第一节坐标处理
     
200.         switch (snake.postion) {
     
201. 
     
202.         case right:
     
203.                 snake.snakeXY[0].x += 10;
     
204.                 break;
     
205.         case left:
     
206.                 snake.snakeXY[0].x -= 10;
     
207.                 break;
     
208.         case down:
     
209.                 snake.snakeXY[0].y += 10;
     
210.                 break;
     
211.         case up:
     
212.                 snake.snakeXY[0].y -= 10;
     
213.                 break;
     
214.         default:
     
215.                 break;
     
216. 
     
217.         }
     
218. 
     
219. }
     
220. 
     
221. //移动蛇2
     
222. void moveSnake_2() {
     
223.         //除蛇第一节以外的移动坐标处理
     
224.         for (int i = snake_2.num - 1; i > 0; i--) {
     
225. 
     
226.                 snake_2.snakeXY[i].x = snake_2.snakeXY[i - 1].x;
     
227.                 snake_2.snakeXY[i].y = snake_2.snakeXY[i - 1].y;
     
228. 
     
229.         }
     
230. 
     
231.         //第一节坐标处理
     
232.         switch (snake_2.postion) {
     
233. 
     
234.         case right_2:
     
235.                 snake_2.snakeXY[0].x += 10;
     
236.                 break;
     
237.         case left_2:
     
238.                 snake_2.snakeXY[0].x -= 10;
     
239.                 break;
     
240.         case down_2:
     
241.                 snake_2.snakeXY[0].y += 10;
     
242.                 break;
     
243.         case up_2:
     
244.                 snake_2.snakeXY[0].y -= 10;
     
245.                 break;
     
246.         default:
     
247.                 break;
     
248. 
     
249.         }
     
250. 
     
251. }
     
252. 
     
253. //按键处理
     
254. void keyDown() {
     
255. 
     
256.         char userKey;
     
257.         userKey = _getch();
     
258. 
     
259.         switch (userKey) {
     
260. 
     
261.         case right:
     
262.                 if (snake.postion != down) snake.postion = up;
     
263.                 break;
     
264.         case left:
     
265.                 if (snake.postion != right) snake.postion = left;
     
266.                 break;
     
267.         case down:
     
268.                 if (snake.postion != left) snake.postion = right;
     
269.                 break;
     
270.         case up:
     
271.                 if (snake.postion != up) snake.postion = down;
     
272.                 break;
     
273.         case right_2:
     
274.                 if (snake_2.postion != down_2) snake_2.postion = up_2;
     
275.                 break;
     
276.         case left_2:
     
277.                 if (snake_2.postion != right_2) snake_2.postion = left_2;
     
278.                 break;
     
279.         case down_2:
     
280.                 if (snake_2.postion != left_2) snake_2.postion = right_2;
     
281.                 break;
     
282.         case up_2:
     
283.                 if (snake_2.postion != up_2) snake_2.postion = down_2;
     
284.                 break;
     
285.         case 49:
     
286.                 speed = 10;
     
287.                 break;
     
288.         case 50:
     
289.                 speed = 20;
     
290.                 break;
     
291.         case 51:
     
292.                 speed = 30;
     
293.                 break;
     
294.         case 52:
     
295.                 speed = 40;
     
296.                 break;
     
297.         case 53:
     
298.                 speed = 50;
     
299.                 break;
     
300.         case 54:
     
301.                 speed = 60;
     
302.                 break;
     
303.         case 55:
     
304.                 speed = 70;
     
305.                 break;
     
306.         case 56:
     
307.                 speed = 80;
     
308.                 break;
     
309.         case 57:
     
310.                 speed = 90;
     
311.                 break;
     
312.         case 48:
     
313.                 speed = 100;
     
314.                 break;
     
315.         default:
     
316.                 break;
     
317. 
     
318.         }
     
319. 
     
320. }
     
321. 
     
322. //初始化食物
     
323. void initFood() {
     
324. 
     
325.         food.foodXY.x = rand() % 65 * 10;        //坐标一定要是10的倍数
     
326.         food.foodXY.y = rand() % 48 * 10;
     
327.         food.flag = 1;
     
328. 
     
329.         for (int i = 0; i < snake.num; i++) {
     
330. 
     
331.                 //如果坐标重复，重新生成
     
332.                 if (food.foodXY.x == snake.snakeXY[i].x and food.foodXY.y == snake.snakeXY[i].y or food.foodXY.x == snake_2.snakeXY[i].x and food.foodXY.y == snake_2.snakeXY[i].y) {
     
333. 
     
334.                         food.foodXY.x = rand() % 65 * 10;
     
335.                         food.foodXY.y = rand() % 48 * 10;
     
336. 
     
337.                 }
     
338. 
     
339.         }
     
340. }
     
341. 
     
342. //画食物
     
343. void drawFood() {
     
344. 
     
345.         fillrectangle(food.foodXY.x, food.foodXY.y, food.foodXY.x + 10, food.foodXY.y + 10);
     
346.         setlinecolor(BLACK);        //矩形边框颜色为黑Black
     
347.         setfillcolor(BLUE);                //矩形内部颜色为蓝blue
     
348. 
     
349. }
     
350. 
     
351. //蛇1吃食物
     
352. void eatFood() {
     
353. 
     
354.         //蛇变长了
     
355.         if (snake.snakeXY[0].x == food.foodXY.x and snake.snakeXY[0].y == food.foodXY.y) {
     
356. 
     
357.                 snake.num++;
     
358.                 food.eatGrade += 10;
     
359.                 food.flag = 0;
     
360. 
     
361.                 //重新画食物
     
362. 
     
363.                 void drawFood();
     
364. 
     
365.         }
     
366. 
     
367. }
     
368. 
     
369. //蛇2吃食物
     
370. void eatFood_2() {
     
371. 
     
372.         //蛇变长了
     
373.         if (snake_2.snakeXY[0].x == food.foodXY.x and snake_2.snakeXY[0].y == food.foodXY.y) {
     
374. 
     
375.                 snake_2.num++;
     
376.                 food.eatGrade += 10;
     
377.                 food.flag = 0;
     
378. 
     
379.                 //重新画食物
     
380. 
     
381.                 void drawFood();
     
382. 
     
383.         }
     
384. 
     
385. }
     
386. 
     
387. //判断蛇1死亡
     
388. void snakeDie() {
     
389. 
     
390.         //撞墙而死
     
391.         if (snake.snakeXY[0].x > 640 or snake.snakeXY[0].x < 0 or snake.snakeXY[0].y > 480 or snake.snakeXY[0].y < 0) {
     
392. 
     
393.                 outtextxy(200, 200, "玩家1撞南墙了!");
     
394.                 MessageBox(hwnd, "玩家2赢了!", "玩家1撞墙了!!!", MB_OK);
     
395.                 snake.flag = 1;                        //蛇1死亡，游戏结束
     
396. 
     
397.         }
     
398.         //自杀而死
     
399.         for (int i = 1; i < snake.num; i++) {
     
400. 
     
401.                 if (snake.snakeXY[0].x == snake.snakeXY[i].x and snake.snakeXY[0].y == snake.snakeXY[i].y) {
     
402. 
     
403.                         outtextxy(200, 200, "玩家1撞自己了!");
     
404.                         MessageBox(hwnd, "玩家2赢了了!", "玩家1自杀了!!!", MB_OK);
     
405.                         snake.flag = 1;                //蛇1死亡，游戏结束
     
406. 
     
407.                 }
     
408. 
     
409.         }
     
410.         //头撞到对方身上而死
     
411.         for (int i = 1; i < snake_2.num; i++) {
     
412. 
     
413.                 if (snake.snakeXY[0].x == snake_2.snakeXY[i].x and snake.snakeXY[1].y == snake_2.snakeXY[i].y) {
     
414. 
     
415.                         outtextxy(200, 200, "玩家2赢了了!");
     
416.                         MessageBox(hwnd, "玩家1撞到玩家2了", "GameOver!!!", MB_OK);
     
417.                         snake.flag = 1;                //蛇1死亡，游戏结束
     
418. 
     
419.                 }
     
420. 
     
421.         }
     
422.         //两头相撞而死
     
423.         if (snake.snakeXY[0].x == snake_2.snakeXY[0].x and snake.snakeXY[0].y == snake_2.snakeXY[0].y) {
     
424. 
     
425.                 outtextxy(200, 200, "两头蛇相撞了");
     
426.                 MessageBox(hwnd, "两个都输了!", "两败俱伤!!!", MB_OK);
     
427.                 snake.flag = 1;                        //两蛇死亡，游戏结束
     
428. 
     
429.         }
     
430. 
     
431. }
     
432. 
     
433. //判断蛇2死亡
     
434. void snakeDie_2() {
     
435. 
     
436.         //撞墙而死
     
437.         if (snake_2.snakeXY[0].x > 640 or snake_2.snakeXY[0].x < 0 or snake_2.snakeXY[0].y > 480 or snake_2.snakeXY[0].y < 0) {
     
438. 
     
439.                 outtextxy(200, 200, "玩家2撞南墙了!");
     
440.                 MessageBox(hwnd, "玩家1赢了!!!", "玩家2撞南墙了!!!", MB_OK);
     
441.                 snake_2.flag = 1;                        //蛇2死亡，游戏结束
     
442. 
     
443.         }
     
444.         //自杀而死
     
445.         for (int i = 1; i < snake_2.num; i++) {
     
446. 
     
447.                 if (snake_2.snakeXY[0].x == snake_2.snakeXY[i].x and snake_2.snakeXY[0].y == snake_2.snakeXY[i].y) {
     
448. 
     
449.                         outtextxy(200, 200, "玩家2撞自己了!");
     
450.                         MessageBox(hwnd, "GameOver!!!", "玩家2自杀了!!!", MB_OK);                //蛇死亡，游戏结束
     
451.                         snake_2.flag = 1;                //蛇2死亡，游戏结束
     
452. 
     
453.                 }
     
454. 
     
455.         }       
     
456.         //头撞到对方身上而死
     
457.         for (int i = 1; i < snake_2.num; i++) {
     
458. 
     
459.                 if (snake_2.snakeXY[0].x == snake.snakeXY[i].x and snake_2.snakeXY[1].y == snake.snakeXY[i].y) {
     
460. 
     
461.                         outtextxy(200, 200, "玩家1赢了了!");
     
462.                         MessageBox(hwnd, "玩家2撞到玩家1了!", "玩家1赢了了!!!", MB_OK);
     
463.                         snake_2.flag = 1;                //蛇2死亡，游戏结束
     
464. 
     
465.                 }
     
466. 
     
467.         }
     
468. 
     
469. }

复制代码

今天把我之前写的贪吃蛇改成双人模式，结果最后运行发现第二条蛇控制不了（用asdw键），第一条蛇上下左右键还可以正常控制（头大），希望有dalao看看我的代码

最佳答案

月排行榜 / 总排行榜

superbe

2020-7-12 22:23:27

别放弃。。。改成虚拟键码试试，字母键的虚拟键码就是ASCII码，方向键的虚拟键码要调用函数得到。
大概是下面这样的，不知道我的理解对不对，参考下。

enum movPostion {

    up = VK_UP, down = VK_DOWN, left = VK_LEFT, right = VK_RIGHT,
    up_2 = 87, down_2 = 83, left_2 = 65, right_2 = 68

};

void keyDown() {

    int userKey = virtkey();

    switch (userKey) {

    (下面代码同上......)
｝

int virtkey()
{
    int ch = _getch();
    if (ch == 0 || ch == 0xE0)
        ch = MapVirtualKey(_getch(), MAPVK_VSC_TO_VK_EX);
    return ch;
}

在VS2015下运行是正常的，其它环境没测试。

跳转到最佳答案楼层

嘉岳呀

1. /********************************
   
2. *        初始化蛇1                intiSnake
   
3. *        初始化蛇2                intiSnake_2
   
4. *        画蛇1                        drawSnake
   
5. *        画蛇2                        drawSnake_2
   
6. *        移动蛇1                        moveSnake
   
7. *        移动蛇2                        moveSnake_2
   
8. *        按键处理                keyDown
   
9. *        初始化食物                initFood
   
10. *        画食物                        drawFood
    
11. *        蛇1吃食物                eatFood
    
12. *        蛇2吃食物                eatFood_2
    
13. *        判断蛇1死亡                snakeDie
    
14. *        判断蛇2死亡                snakeDie_2
    
15. *        显示蛇1分数                showGrade
    
16. *        显示蛇2分数                showGrade_2
    
17. *********************************/

复制代码

intiSnake是什么

嘉岳呀

其他我找不出来

我还是个小学生

superbe

按键控制乱了，替换以下代码，应该就可以了

1. //枚举方向  模拟键码值
   
2. enum movPostion {
   
3. 
   
4.     up = 72, down = 80, left = 75, right = 77,
   
5.     up_2 = 87, down_2 = 83, left_2 = 65, right_2 = 68
   
6. 
   
7. };

复制代码

1. //画蛇2
   
2. void drawSnake_2() {
   
3. 
   
4.     for (int i = 0; i < snake_2.num; i++) {
   
5. 
   
6.         setlinecolor(BLACK);        //矩形边框颜色为黑Black
   
7.         setfillcolor(GREEN);        //矩形内部颜色为绿Green
   
8.         fillrectangle(snake_2.snakeXY[i].x, snake_2.snakeXY[i].y, snake_2.snakeXY[i].x + 10, snake_2.snakeXY[i].y + 10);
   
9. 
   
10.     }
    
11. 
    
12. }

复制代码

1. //按键处理
   
2. void keyDown() {
   
3. 
   
4.     char userKey;
   
5.     userKey = _getch();
   
6.     //if (userKey == 0 || userKey == -32)
   
7.     //    userKey = _getch();
   
8. 
   
9.     switch (userKey) {
   
10.     case up:
    
11.         if (snake.postion != down) snake.postion = up;
    
12.         break;
    
13.     case down:
    
14.         if (snake.postion != up) snake.postion = down;
    
15.         break;
    
16.     case left:
    
17.         if (snake.postion != right) snake.postion = left;
    
18.         break;
    
19.     case right:
    
20.         if (snake.postion != left) snake.postion = right;
    
21.         break;
    
22.     case up_2:
    
23.     case up_2 + 32:
    
24.         if (snake_2.postion != down_2) snake_2.postion = up_2;
    
25.         break;
    
26.     case down_2:
    
27.     case down_2 + 32:
    
28.         if (snake_2.postion != up_2) snake_2.postion = down_2;
    
29.         break;
    
30.     case left_2:
    
31.     case left_2 + 32:
    
32.         if (snake_2.postion != right_2) snake_2.postion = left_2;
    
33.         break;
    
34.     case right_2:
    
35.     case right_2 + 32:
    
36.         if (snake_2.postion != left_2) snake_2.postion = right_2;
    
37.         break;
    
38.     case 49:
    
39.         speed = 10;
    
40.         break;
    
41.     case 50:
    
42.         speed = 20;
    
43.         break;
    
44.     case 51:
    
45.         speed = 30;
    
46.         break;
    
47.     case 52:
    
48.         speed = 40;
    
49.         break;
    
50.     case 53:
    
51.         speed = 50;
    
52.         break;
    
53.     case 54:
    
54.         speed = 60;
    
55.         break;
    
56.     case 55:
    
57.         speed = 70;
    
58.         break;
    
59.     case 56:
    
60.         speed = 80;
    
61.         break;
    
62.     case 57:
    
63.         speed = 90;
    
64.         break;
    
65.     case 48:
    
66.         speed = 100;
    
67.         break;
    
68.     default:
    
69.         break;
    
70. 
    
71.     }
    
72. 
    
73. }

复制代码

livcui

superbe 发表于 2020-7-10 21:23
按键控制乱了，替换以下代码，应该就可以了

确实是你所说的按键的问题，我也尝试着改过，但我觉得可能还是因为getch()函数用的键码值不是代码上的那些(一开始我不确定用的是哪个键码值，而我的代码里所用的是ASCII键码值，而后来我发现字母a ~ z的ASCII键码值是65 ~ 90，这就和我已经确认正确上下左右键的键码值72、80、75、77冲突了)，但我又找不到这个函数用的键码值，所以我也放弃了。

superbe

别放弃。。。改成虚拟键码试试，字母键的虚拟键码就是ASCII码，方向键的虚拟键码要调用函数得到。
大概是下面这样的，不知道我的理解对不对，参考下。

enum movPostion {

    up = VK_UP, down = VK_DOWN, left = VK_LEFT, right = VK_RIGHT,
    up_2 = 87, down_2 = 83, left_2 = 65, right_2 = 68

};

void keyDown() {

    int userKey = virtkey();

    switch (userKey) {

    (下面代码同上......)
｝

int virtkey()
{
    int ch = _getch();
    if (ch == 0 || ch == 0xE0)
        ch = MapVirtualKey(_getch(), MAPVK_VSC_TO_VK_EX);
    return ch;
}

在VS2015下运行是正常的，其它环境没测试。