当前位置:   article > 正文

C语言实现童年经典——贪吃蛇(附源码呦!)_地图贪吃蛇

地图贪吃蛇

1.实现基本的功能

  • 贪吃蛇地图的绘制(墙壁)
  • 贪吃蛇吃食物的功能(包括上、下、左、右控制移动;吃掉食物身体变长等)
  • 贪吃蛇撞到墙壁或自己死亡
  • 计算得分
  • 改变游戏难度(蛇的移动速度)
  • 暂停游戏

2.贪吃蛇游戏设计思路

2.1地图的绘制

话不多说,首先要实现的是贪吃蛇地图的绘制。我们要绘制的贪吃蛇地图如下图所示:

要实现地图就必须得有坐标,方便我们找到对应的位置绘制墙壁、贪吃蛇的身体以及食物,控制台窗口的坐标如下图所示,横向的是X轴,从左向右依次增⻓纵向是Y轴,从上到下依次增⻓

 游戏地图上我们以宽字符'□'来打印墙壁;宽字符'●'打印贪吃蛇的身体;宽字符'◆'食物。注:普通字符占一个字节,这类宽字符是占2个字节的。我们需要使用 wprintf() 来打印这类宽字符,由于c语言默认采用ASCLL编码,无法打印宽字符,所以需要<locale.h>本地化来实现宽字符的打印。

2.1.1<locale.h>本地化

这里就不详细说明<locale.h>,我们只需要使用setlocale函数即可。该函数是用来修改当前地区,可以针对一个类项修改,也可以对所有类项修改。

 setlocale函数有两个参数,第一个参数表示被修改的类项,可以是某一个类项也可以是全部类项,如果第⼀个参数是LC_ALL,就会影响所有的类项。第二个参数有两种取值:"C" (正常模式)和 " " (本地化模式)。使用如下代码就可以实现本地化了。

setlocale(LC_ALL, " ");
2.1.2 wprintf()

在本地化之后我们就可以使用wprint()来打印宽字符了,那么 wprint() printf() 在使用过程中有何不同呢?

  1. printf("%c",'a');
  2. //printf()函数打印一个字符'a'
  3. wprintf(L"%lc",L'●');
  4. //wprintf()函数打印一个宽字符'●'

上面这两段代码可以看出wprintf函数和printf函数在使用的时候非常相似,仅仅是多了前缀“L”在单引号前⾯,表⽰宽字符,对应 wprintf() 的占位符为 %lc

2.1.3地图坐标

 宽字符在打印的时候是占用两个普通字符的位置的,所以我们在设计地图的时候横纵坐标是不同的。

2.2蛇身和食物

初始化状态,假设蛇的⻓度是5,蛇⾝的每个节点是●,在固定的⼀个坐标处,⽐如(24, 5)处开始出现蛇,连续5个节点。
注意: 蛇的每个节点的x坐标必须是2个倍数 ,否则可能会出现蛇的⼀个节点有⼀半⼉出现在墙体中,另外⼀般在墙外的现象,坐标不好对⻬。
关于⻝物,就是在墙体内随机⽣成⼀个坐标(x坐标必须是2的倍数), 坐标不能和蛇的⾝体重合 ,然后打印★。

2.3数据结构设计

在游戏运⾏的过程中,蛇每次吃⼀个⻝物,蛇的⾝体就会变⻓⼀节,如果我们使⽤链表存储蛇的信
息,那么蛇的每⼀节其实就是链表的每个节点。每个节点只要记录好蛇⾝节点在地图上的坐标就⾏,所以蛇节点结构如下:
  1. typedef struct SnakeNode
  2. {
  3. int x;
  4. int y;
  5. struct SnakeNode* next;
  6. }SnakeNode,* pSnakeNode;
要管理整条贪吃蛇,我们再封装⼀个Snake的结构来维护整条贪吃蛇:
  1. typedef struct Snake
  2. {
  3. pSnakeNode _pSnake;//蛇的身体节点的指针
  4. pSnakeNode _pFood;//食物节点的指针
  5. enum Direction _Dir;//方向
  6. enum Game_Status _Status;//游戏状态
  7. int _Score;//总得分
  8. int _Food_Weight;//当前食物的分数
  9. int _SleepTime;//休息时间
  10. }Snake,* pSnake;

方向有上、下、左、右,是可以列举的,使用枚举:

  1. enum Direction
  2. {
  3. UP = 1,
  4. DOWN,
  5. LEFT,
  6. RIGHT
  7. };

游戏状态有:正常运行、被墙撞死、被自己撞死以及主动退出四种,也使用枚举:

  1. enum Game_Status
  2. {
  3. OK,//正常运行
  4. KILL_BY_WALL,//撞到墙
  5. KILL_BY_SELF,//撞到自己
  6. END_NOMAL//正常退出
  7. };

3.逻辑实现思路

程序开始就设置程序⽀持本地模式,然后进⼊游戏的主逻辑。
主逻辑分为3个过程:
  1. 游戏开始(GameStart)完成游戏的初始化
  2. 游戏运⾏(GameRun)完成游戏运⾏逻辑的实现
  3. 游戏结束(GameEnd)完成游戏结束的说明,实现资源释放
  1. void test()
  2. {
  3. char n = 0;
  4. srand((unsigned int)time(NULL));
  5. do
  6. {
  7. Snake Snake = { 0 };
  8. system("cls");
  9. //开始游戏
  10. GameStart(&Snake);
  11. //游戏运行
  12. GameRun(&Snake);
  13. //游戏结束
  14. GameEnd(&Snake);
  15. _SetPos(24, 17);
  16. printf("是否先后来一局?(Y/N)");
  17. n=getchar();
  18. } while (n=='Y');
  19. }
  20. int main()
  21. {
  22. setlocale(LC_ALL, "");//修改为本地模式(为了打印宽字符)
  23. test();
  24. _SetPos(0, 27);
  25. return 0;
  26. }

 3.1游戏开始(GameStart)

该模块完成游戏的初始化

  • 控制台窗⼝⼤⼩的设置
  • 控制台窗⼝名字的设置
  • ⿏标光标的隐藏
  • 打印欢迎界⾯
  • 创建地图
  • 初始化第蛇
  • 创建第⼀个⻝物
  1. //开始游戏
  2. void GameStart(pSnake ps)
  3. {
  4. //设置窗口为100列30行
  5. system("mode con cols=100 lines=30");
  6. //设置窗口名称
  7. system("title 贪吃蛇");
  8. //设置光标不显示
  9. _SetCursorInfo(false);
  10. //打印欢迎界面
  11. WelcomeToGame();
  12. //打印地图
  13. CreateMap();
  14. //初始化蛇身
  15. InitSnake(ps);
  16. //创建第一个食物
  17. CreateFood(ps);
  18. }

3.2游戏运⾏(GameRun)

  • 游戏运⾏期间,右侧打印帮助信息,提⽰玩家,坐标开始位置(64, 15)
  • 根据游戏状态检查游戏是否继续,如果是状态是OK,游戏继续,否则游戏结束。
  • 如果游戏继续,就是检测按键情况,确定蛇下⼀步的⽅向,或者是否加速减速,是否暂停或者退出游戏。
需要的虚拟按键的罗列:
  • 上:VK_UP
  • 下:VK_DOWN
  • 左:VK_LEFT
  • 右:VK_RIGHT
  • 空格:VK_SPACE
  • ESC:VK_ESCAPE  
  • F3:VK_F3
  • F4:VK_F4
  1. //游戏运行
  2. void GameRun(pSnake ps)
  3. {
  4. //打印右侧帮助信息
  5. PrintInfo();
  6. do
  7. {
  8. _SetPos(64, 10);
  9. printf("分数:%2d", ps->_Score);
  10. _SetPos(64, 11);
  11. printf("当前食物分数:%2d", ps->_Food_Weight);
  12. if (KEY_PRESS(VK_UP) && ps->_Dir != DOWN)
  13. {
  14. ps->_Dir = UP;
  15. }
  16. else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP)
  17. {
  18. ps->_Dir = DOWN;
  19. }
  20. else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT)
  21. {
  22. ps->_Dir = LEFT;
  23. }
  24. else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT)
  25. {
  26. ps->_Dir = RIGHT;
  27. }
  28. else if (KEY_PRESS(VK_F1))
  29. {
  30. if (ps->_SleepTime > 80)
  31. {
  32. ps->_SleepTime -= 30;
  33. ps->_Food_Weight += 2;
  34. }
  35. }
  36. else if (KEY_PRESS(VK_F2))
  37. {
  38. if (ps->_Food_Weight>2)
  39. {
  40. ps->_SleepTime += 30;
  41. ps->_Food_Weight -= 2;
  42. }
  43. }
  44. else if (KEY_PRESS(VK_ESCAPE))
  45. {
  46. ps->_Status = END_NOMAL;
  47. break;
  48. }
  49. else if (KEY_PRESS(VK_SPACE))
  50. {
  51. pause();
  52. }
  53. ///蛇每次⼀定之间要休眠的时间,时间短,蛇移动速度就快
  54. Sleep(ps->_SleepTime);
  55. //蛇的移动
  56. SnakeMove(ps);
  57. } while (ps->_Status==OK);
  58. }

3.3游戏结束(GameEnd)

游戏状态不再是OK(游戏继续)的时候,要告知游戏结束的原因,并且释放蛇⾝节点。
  1. //游戏结束
  2. void GameEnd(pSnake ps)
  3. {
  4. pSnakeNode cur = ps->_pSnake;
  5. _SetPos(24, 12);
  6. switch (ps->_Status)
  7. {
  8. case KILL_BY_WALL:
  9. printf("被墙撞死了!");
  10. break;
  11. case KILL_BY_SELF:
  12. printf("被自己撞死了!");
  13. break;
  14. case END_NOMAL:
  15. printf("主动退出!");
  16. break;
  17. }
  18. while (cur)
  19. {
  20. pSnakeNode del = cur;
  21. cur = cur->next;
  22. free(del);
  23. }
  24. }

4.源码

4.1 test.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include "Snake.h"
  3. //开始游戏
  4. void GameStart(pSnake ps)
  5. {
  6. //设置窗口为10030
  7. system("mode con cols=100 lines=30");
  8. //设置窗口名称
  9. system("title 贪吃蛇");
  10. //设置光标不显示
  11. _SetCursorInfo(false);
  12. //打印欢迎界面
  13. WelcomeToGame();
  14. //打印地图
  15. CreateMap();
  16. //初始化蛇身
  17. InitSnake(ps);
  18. //创建第一个食物
  19. CreateFood(ps);
  20. }
  21. void pause()
  22. {
  23. while (1)
  24. {
  25. Sleep(200);
  26. if (KEY_PRESS(VK_SPACE))
  27. {
  28. break;
  29. }
  30. }
  31. }
  32. //游戏运行
  33. void GameRun(pSnake ps)
  34. {
  35. //打印右侧帮助信息
  36. PrintInfo();
  37. do
  38. {
  39. _SetPos(64, 10);
  40. printf("分数:%2d", ps->_Score);
  41. _SetPos(64, 11);
  42. printf("当前食物分数:%2d", ps->_Food_Weight);
  43. if (KEY_PRESS(VK_UP) && ps->_Dir != DOWN)
  44. {
  45. ps->_Dir = UP;
  46. }
  47. else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP)
  48. {
  49. ps->_Dir = DOWN;
  50. }
  51. else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT)
  52. {
  53. ps->_Dir = LEFT;
  54. }
  55. else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT)
  56. {
  57. ps->_Dir = RIGHT;
  58. }
  59. else if (KEY_PRESS(VK_F1))
  60. {
  61. if (ps->_SleepTime > 80)
  62. {
  63. ps->_SleepTime -= 30;
  64. ps->_Food_Weight += 2;
  65. }
  66. }
  67. else if (KEY_PRESS(VK_F2))
  68. {
  69. if (ps->_Food_Weight>2)
  70. {
  71. ps->_SleepTime += 30;
  72. ps->_Food_Weight -= 2;
  73. }
  74. }
  75. else if (KEY_PRESS(VK_ESCAPE))
  76. {
  77. ps->_Status = END_NOMAL;
  78. break;
  79. }
  80. else if (KEY_PRESS(VK_SPACE))
  81. {
  82. pause();
  83. }
  84. ///蛇每次⼀定之间要休眠的时间,时间短,蛇移动速度就快
  85. Sleep(ps->_SleepTime);
  86. //蛇的移动
  87. SnakeMove(ps);
  88. } while (ps->_Status==OK);
  89. }
  90. //游戏结束
  91. void GameEnd(pSnake ps)
  92. {
  93. pSnakeNode cur = ps->_pSnake;
  94. _SetPos(24, 12);
  95. switch (ps->_Status)
  96. {
  97. case KILL_BY_WALL:
  98. printf("被墙撞死了!");
  99. break;
  100. case KILL_BY_SELF:
  101. printf("被自己撞死了!");
  102. break;
  103. case END_NOMAL:
  104. printf("主动退出!");
  105. break;
  106. }
  107. while (cur)
  108. {
  109. pSnakeNode del = cur;
  110. cur = cur->next;
  111. free(del);
  112. }
  113. }
  114. void test()
  115. {
  116. char n = 0;
  117. srand((unsigned int)time(NULL));
  118. do
  119. {
  120. Snake Snake = { 0 };
  121. system("cls");
  122. //开始游戏
  123. GameStart(&Snake);
  124. //游戏运行
  125. GameRun(&Snake);
  126. //游戏结束
  127. GameEnd(&Snake);
  128. _SetPos(24, 17);
  129. printf("是否先后来一局?(Y/N)");
  130. n=getchar();
  131. } while (n=='Y');
  132. }
  133. int main()
  134. {
  135. setlocale(LC_ALL, "");//修改为本地模式(为了打印宽字符)
  136. test();
  137. _SetPos(0, 27);
  138. return 0;
  139. }

4.2 Snake.h

  1. #pragma once
  2. #include<windows.h>
  3. #include<string.h>
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<stdbool.h>
  7. #include<locale.h>
  8. #include<assert.h>
  9. #include<time.h>
  10. #define POS_X 20
  11. #define POS_Y 8
  12. #define KEY_PRESS(VK) (GetAsyncKeyState(VK) &0X1 ? 1 : 0 )
  13. typedef struct SnakeNode
  14. {
  15. int x;
  16. int y;
  17. struct SnakeNode* next;
  18. }SnakeNode,* pSnakeNode;
  19. enum Direction
  20. {
  21. UP = 1,
  22. DOWN,
  23. LEFT,
  24. RIGHT
  25. };
  26. enum Game_Status
  27. {
  28. OK,//正常运行
  29. KILL_BY_WALL,//撞到墙
  30. KILL_BY_SELF,//撞到自己
  31. END_NOMAL//正常退出
  32. };
  33. typedef struct Snake
  34. {
  35. pSnakeNode _pSnake;//蛇的身体节点的指针
  36. pSnakeNode _pFood;//食物节点的指针
  37. enum Direction _Dir;//方向
  38. enum Game_Status _Status;//游戏状态
  39. int _Score;//总得分
  40. int _Food_Weight;//当前食物的分数
  41. int _SleepTime;//休息时间
  42. }Snake,* pSnake;
  43. //设置光标位置
  44. void _SetPos(short x, short y);
  45. //设置光标是否显示
  46. void _SetCursorInfo(bool a);
  47. //打印欢迎界面
  48. void WelcomeToGame();
  49. //打印地图
  50. void CreateMap();
  51. //创建节点
  52. pSnakeNode BuyNode(short x, short y);
  53. //初始化蛇身
  54. void InitSnake(pSnake ps);
  55. //创建第一个食物
  56. void CreateFood(pSnake ps);
  57. //打印右侧帮助信息
  58. void PrintInfo();
  59. //蛇的移动
  60. void SnakeMove(pSnake ps);

4.3 Snake.c

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include "Snake.h"
  3. //设置光标位置
  4. void _SetPos(short x, short y)
  5. {
  6. COORD pos = { x,y };
  7. HANDLE hOutput = NULL;
  8. //获取标准输出流句柄
  9. hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  10. //设置光标于所给参数位置
  11. SetConsoleCursorPosition(hOutput, pos);
  12. }
  13. //设置光标是否显示
  14. void _SetCursorInfo(bool a)
  15. {
  16. HANDLE hOutput = NULL;
  17. hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  18. CONSOLE_CURSOR_INFO CursorInfo = { 0 };
  19. GetConsoleCursorInfo(hOutput, &CursorInfo);
  20. CursorInfo.bVisible = a;
  21. SetConsoleCursorInfo(hOutput, &CursorInfo);
  22. }
  23. //打印欢迎界面
  24. void WelcomeToGame()
  25. {
  26. _SetPos(41, 13);
  27. printf("欢迎来到贪吃蛇!\n");
  28. _SetPos(41, 25);
  29. system("pause");
  30. system("cls");
  31. _SetPos(15, 13);
  32. wprintf(L"按 ↑ . ↓ . ← . → 控制方向;");
  33. _SetPos(15, 14);
  34. wprintf(L"按F1加快移动速度并提升食物分数,按F2降低移动速度并减少食物分数;");
  35. _SetPos(15, 15);
  36. wprintf(L"按ESC退出游戏,按space暂停/继续游戏;");
  37. _SetPos(15, 16);
  38. wprintf(L"不能撞到墙或自己。");
  39. _SetPos(41, 25);
  40. system("pause");
  41. system("cls");
  42. }
  43. //打印地图
  44. void CreateMap()
  45. {
  46. _SetPos(0, 0);
  47. int i = 0;
  48. for (i = 0; i < 58; i += 2)
  49. {
  50. wprintf(L"%c", L'□');
  51. }
  52. _SetPos(0, 26);
  53. for (i = 0; i < 58; i += 2)
  54. {
  55. wprintf(L"%c", L'□');
  56. }
  57. for (i = 1; i < 26; i++)
  58. {
  59. _SetPos(0, i);
  60. wprintf(L"%c", L'□');
  61. _SetPos(56, i);
  62. wprintf(L"%c", L'□');
  63. }
  64. }
  65. //创建节点
  66. pSnakeNode BuyNode(short x, short y)
  67. {
  68. pSnakeNode cur = (pSnakeNode)malloc(sizeof(SnakeNode));
  69. if (cur == NULL)
  70. {
  71. perror("InitSnake:: BuyNode::malloc");
  72. return NULL;
  73. }
  74. cur->x = x;
  75. cur->y = y;
  76. cur->next = NULL;
  77. return cur;
  78. }
  79. //初始化蛇身
  80. void InitSnake(pSnake ps)
  81. {
  82. //创建蛇身节点
  83. int i = 0;
  84. for (i = 0; i < 5; i++)
  85. {
  86. pSnakeNode cur = BuyNode((short)POS_X + i * 2, (short)POS_Y);
  87. if (ps->_pSnake == NULL)
  88. {
  89. ps->_pSnake = cur;
  90. }
  91. else
  92. {
  93. cur->next = ps->_pSnake;
  94. ps->_pSnake = cur;
  95. }
  96. }
  97. //打印蛇的身体
  98. pSnakeNode cur = NULL;
  99. cur = ps->_pSnake;
  100. while (cur)
  101. {
  102. _SetPos(cur->x, cur->y);
  103. wprintf(L"%c", L'●');
  104. cur = cur->next;
  105. }
  106. //初始化蛇的数据
  107. ps->_Dir = RIGHT;
  108. ps->_Food_Weight = 10;
  109. ps->_Score = 0;
  110. ps->_SleepTime = 200;
  111. ps->_Status = OK;
  112. }
  113. #define FOOD L'◆'
  114. //创建第一个食物
  115. void CreateFood(pSnake ps)
  116. {
  117. short x = 0;
  118. short y = 0;
  119. again:
  120. //随机生成食物节点坐标
  121. do
  122. {
  123. x = rand() % 53 + 2;
  124. y = rand() % 25 + 1;
  125. } while (x % 2 != 0);
  126. pSnakeNode cur = ps->_pSnake;
  127. //遍历蛇身,食物不能与蛇身重合
  128. while (cur)
  129. {
  130. if (cur->x == x && cur->y == y)
  131. {
  132. goto again;
  133. }
  134. cur = cur->next;
  135. }
  136. //创建食物
  137. pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));
  138. if (pFood == NULL)
  139. {
  140. perror("pSnakeNode::malloc");
  141. return;
  142. }
  143. else
  144. {
  145. pFood->x = x;
  146. pFood->y = y;
  147. _SetPos(x, y);
  148. wprintf(L"%c", FOOD);
  149. ps->_pFood = pFood;
  150. }
  151. }
  152. //打印右侧帮助信息
  153. void PrintInfo()
  154. {
  155. _SetPos(62, 15);
  156. wprintf(L"按 ↑ . ↓ . ← . → 控制方向;");
  157. _SetPos(62, 16);
  158. wprintf(L"按F1加快移动速度并提升食物分数,");
  159. _SetPos(62, 17);
  160. wprintf(L"按F2降低移动速度并减少食物分数;");
  161. _SetPos(62, 18);
  162. wprintf(L"按ESC退出游戏,按space暂停/继续游戏;");
  163. _SetPos(62, 19);
  164. wprintf(L"不能撞到墙或自己。");
  165. }
  166. //判断下一个坐标是否是食物
  167. int NextIsFood(pSnakeNode nextnode, pSnake ps)
  168. {
  169. if ((ps->_pFood->x == nextnode->x) && (ps->_pFood->y == nextnode->y))
  170. {
  171. return 1;
  172. }
  173. else
  174. {
  175. return 0;
  176. }
  177. }
  178. //吃食物
  179. void EatFood(pSnakeNode nextnode, pSnake ps)
  180. {
  181. nextnode->next = ps->_pSnake;
  182. ps->_pSnake = nextnode;
  183. pSnakeNode cur = ps->_pSnake;
  184. while (cur)
  185. {
  186. _SetPos(cur->x, cur->y);
  187. wprintf(L"%c", L'●');
  188. cur = cur->next;
  189. }
  190. ps->_Score += ps->_Food_Weight;
  191. free(ps->_pFood);
  192. //创建新食物
  193. CreateFood(ps);
  194. }
  195. //不是食物
  196. void NoFood(pSnakeNode nextnode, pSnake ps)
  197. {
  198. nextnode->next = ps->_pSnake;
  199. ps->_pSnake = nextnode;
  200. pSnakeNode cur = ps->_pSnake;
  201. while (cur->next->next)
  202. {
  203. _SetPos(cur->x, cur->y);
  204. wprintf(L"%c", L'●');
  205. cur = cur->next;
  206. }
  207. pSnakeNode del = cur->next;
  208. cur->next = NULL;
  209. _SetPos(del->x, del->y);
  210. printf(" ");
  211. free(del);
  212. del = NULL;
  213. }
  214. void KillByWall(pSnake ps)
  215. {
  216. if ((ps->_pSnake->x == 0) || (ps->_pSnake->x == 56) || (ps->_pSnake->y == 0) || (ps->_pSnake->y == 26))
  217. {
  218. ps->_Status = KILL_BY_WALL;
  219. }
  220. }
  221. void KillBySelf(pSnake ps)
  222. {
  223. pSnakeNode cur = ps->_pSnake->next;
  224. while (cur)
  225. {
  226. if ((cur->x == ps->_pSnake->x) && (cur->y == ps->_pSnake->y))
  227. {
  228. ps->_Status = KILL_BY_SELF;
  229. }
  230. cur = cur->next;
  231. }
  232. }
  233. //蛇的移动
  234. void SnakeMove(pSnake ps)
  235. {
  236. pSnakeNode pNextNode = (pSnakeNode)malloc(sizeof(SnakeNode));
  237. if (pNextNode == NULL)
  238. {
  239. perror("SnakeMove::malloc");
  240. return;
  241. }
  242. //确定下⼀个节点的坐标,下⼀个节点的坐标根据,蛇头的坐标和⽅向确定
  243. switch(ps->_Dir)
  244. {
  245. case UP:
  246. {
  247. pNextNode->x = ps->_pSnake->x;
  248. pNextNode->y = ps->_pSnake->y - 1;
  249. }
  250. break;
  251. case DOWN:
  252. {
  253. pNextNode->x = ps->_pSnake->x;
  254. pNextNode->y = ps->_pSnake->y + 1;
  255. }
  256. break;
  257. case LEFT:
  258. {
  259. pNextNode->x = ps->_pSnake->x-2;
  260. pNextNode->y = ps->_pSnake->y;
  261. } break;
  262. case RIGHT:
  263. {
  264. pNextNode->x = ps->_pSnake->x+2;
  265. pNextNode->y = ps->_pSnake->y;
  266. }
  267. break;
  268. }
  269. //如果下一个位置是食物
  270. if (NextIsFood(pNextNode, ps))
  271. {
  272. //吃食物
  273. EatFood(pNextNode, ps);
  274. }
  275. else//不是食物
  276. {
  277. NoFood(pNextNode, ps);
  278. }
  279. KillByWall(ps);
  280. KillBySelf(ps);
  281. }

5.结语

使用上述代码在VS环境下就可以实现一个简单的贪吃蛇小游戏了,喜欢的朋友可以点赞收藏呦。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小桥流水78/article/detail/1001483
推荐阅读
相关标签
  

闽ICP备14008679号