devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言C++图形库---贪吃蛇大作战【附源码】_snakeplay和snakec++

作者：花生_TL007 | 2024-04-19 13:44:51

赞

踩

snakeplay和snakec++

这一节中，我们来做一款经典小游戏，贪吃蛇。先看看最终效果图

 

在开始之前，我们把窗体创建好。

创建一个800 * 600的窗体。这一次我们使用默认的原点和坐标轴：原点在窗体左上角，X轴正方向向右，Y轴正方向向下。背景色设置为RGB(164, 225, 202)，最后调用cleardevice函数，使用背景色清空整个窗体。

  1. #include <easyx.h>
  2. #include <stdio.h>
  3.  
  4. int main()
  5. {
  6.     initgraph(800, 600);
  7.     //  设置背景色
  8.     setbkcolor(RGB(164, 225, 202));
  9.     //  使用背景色清空窗体
  10.     cleardevice();
  11.  
  12.     getchar();
  13.     closegraph();
  14.     return 0;
  15. }

1. 定位网格

图片

将整个800 * 600的窗体，水平分隔为20等分，垂直分隔为15等分，作为整个游戏的网格坐标系统。在上图中，蛇用5格白色的矩形表示。食物用黄色的一格矩形表示。

图片

这样，蛇的每一格身体坐标为:

  • (5, 7)

  • (4, 7)

  • (3, 7)

  • (2, 7)

  • (1, 7)

食物的坐标为：

  • (12, 7)

为了方便观察，把窗体用线段画上上述网格。网格每一格的宽度设为40像素，用符号常量NODE_WIDTH表示。

#define NODE_WIDTH 40

竖向线段

先绘制竖向的线段。

竖向线段中，起始点y坐标固定为0，终止点y坐标固定为600。

图片

每条线段的起始点与终止点的x坐标一致，且随着线段不同而变化。

图片

设线段条数从0开始计数。

第0条线段: 起始点、终止点的x坐标为0。
第10条线段: 起始点、终止点的x坐标为10 * NODE_WIDTH。
第20条线段: 起始点、终止点的x坐标为20 * NODE_WIDTH。

观察各线段起始点终止点坐标，可以总结出规律：

第n条线段：起始点(n * NODE_WIDTH, 0)、终止点(n * NODE_WIDTH, 600)。且x坐标的范围为[0, 800]。

  1. //  竖线
  2. for (int x = 0; x <= 800; x += NODE_WIDTH)
  3. {
  4.     line(x, 0, x, 600);
  5. }

横向线段

再绘制横向的线段。

横向线段中，起始点x坐标固定为0，终止点x坐标固定为800。

图片

每条线段的起始点与终止点的y坐标一致，且随着线段不同而变化。

图片

设线段条数从0开始计数。

第0条线段: 起始点、终止点的y坐标为0。
第8条线段: 起始点、终止点的y坐标为8 * NODE_WIDTH。
第15条线段: 起始点、终止点的y坐标为15 * NODE_WIDTH。

观察各线段起始点终止点坐标，可以总结出规律：

第n条线段：起始点(0, n * NODE_WIDTH)、终止点(800, n * NODE_WIDTH)。且y坐标的范围为[0, 600]。

  1. //  横线
  2. for (int y = 0; y <= 600; y += NODE_WIDTH)
  3. {
  4.     line(0, y, 800, y);
  5. }

网格函数paintGrid

将绘制网格的代码封装成函数paintGrid。

  1. //  绘制网格
  2. //  横线(0, y), (800, y)   0 <= y <= 600
  3. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  4. void paintGrid()
  5. {
  6.     //  横线
  7.     for (int y = 0; y < 600; y += NODE_WIDTH)
  8.     {
  9.         line(0, y, 800, y);
  10.     }
  11.     //  竖线
  12.     for (int x = 0; x < 800; x += NODE_WIDTH)
  13.     {
  14.         line(x, 0, x, 600);
  15.     }
  16. }

主函数中调用paintGrid函数，给整个窗体绘制上网格。

图片

现阶段代码如下：

  1. #include <easyx.h>
  2. #include <stdio.h>
  3.  
  4. #define NODE_WIDTH 40
  5.  
  6. //  绘制网格
  7. //  横线(0, y), (800, y)   0 <= y <= 600
  8. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  9. void paintGrid()
  10. {
  11.     //  横线
  12.     for (int y = 0; y < 600; y += NODE_WIDTH)
  13.     {
  14.         line(0, y, 800, y);
  15.     }
  16.     //  竖线
  17.     for (int x = 0; x < 800; x += NODE_WIDTH)
  18.     {
  19.         line(x, 0, x, 600);
  20.     }
  21. }
  22.  
  23. int main()
  24. {
  25.     initgraph(800, 600);
  26.     //  设置背景色
  27.     setbkcolor(RGB(164, 225, 202));
  28.     //  使用背景色清空窗体
  29.     cleardevice();
  30.  
  31.     //  绘制网格
  32.     paintGrid();
  33.  
  34.     getchar();
  35.     closegraph();
  36.     return 0;
  37. }

2. 绘制蛇节点

图片

设定初始状态下，蛇有5个节点。我们把之前设置的网格规划出来的坐标称作网格坐标。每个节点的网格坐标为:

  • (5, 7)

  • (4, 7)

  • (3, 7)

  • (2, 7)

  • (1, 7)

每一个蛇节点使用一个白色正方形表示，而绘制矩形需要左上角和右下角的实际坐标。白色矩形的左上角坐标与右下角实际坐标为：

左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】

图片

右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】

图片

每个节点需要存储x坐标、y坐标两个坐标，可以定义含有两个int成员的结构用于表示节点。

  1. //  节点
  2. typedef struct {
  3.     int x;
  4.     int y;
  5. }node;

在主函数中，声明node的数组，并将前5个元素初始化为蛇的初始位置。设节点(5, 7)为蛇头，蛇头存储在数组的首元素中。

  1. //  蛇节点坐标
  2. node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };

现在，我们定义一个函数paintSnake用于将所有组成蛇的矩形绘制出来。

  1. void paintSnake(node* snake, int n)
  2. {
  3.     int left, top, right, bottom;
  4.     for (int i = 0; i < n; i++)
  5.     {
  6.         //  左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】
  7.         left = snake[i].x * NODE_WIDTH;
  8.         top = snake[i].y * NODE_WIDTH;
  9.         //  右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】
  10.         right = (snake[i].x + 1) * NODE_WIDTH;
  11.         bottom = (snake[i].y + 1) * NODE_WIDTH;
  12.         //  通过左上角与右下角坐标绘制矩形
  13.         solidrectangle(left, top, right, bottom);
  14.     }
  15. }

paintSnake函数需要蛇节点数组首元素指针和蛇节点个数两个参数。在主函数中定义一个变量int length用于记录蛇长度，目前初始化为5。声明蛇节点数组，绘制网格及蛇节点。

 

//  蛇节点坐标
 node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
 //  蛇节点长度
 int length = 5;

 //  绘制网格
 paintGrid();
 //  绘制蛇节点
 paintSnake(snake, length);   
 

图片
 

现阶段代码如下：
 

  1. #include <easyx.h>
  2. #include <stdio.h>
  3.  
  4. #define NODE_WIDTH 40
  5.  
  6. //  节点
  7. typedef struct {
  8.     int x;
  9.     int y;
  10. }node;
  11.  
  12. //  绘制网格
  13. //  横线(0, y), (800, y)   0 <= y <= 600
  14. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  15. void paintGrid()
  16. {
  17.     //  横线
  18.     for (int y = 0; y < 600; y += NODE_WIDTH)
  19.     {
  20.         line(0, y, 800, y);
  21.     }
  22.     //  竖线
  23.     for (int x = 0; x < 800; x += NODE_WIDTH)
  24.     {
  25.         line(x, 0, x, 600);
  26.     }
  27. }
  28.  
  29. void paintSnake(node* snake, int n)
  30. {
  31.     int left, top, right, bottom;
  32.     for (int i = 0; i < n; i++)
  33.     {
  34.         //  左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】
  35.         left = snake[i].x * NODE_WIDTH;
  36.         top = snake[i].y * NODE_WIDTH;
  37.         //  右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】
  38.         right = (snake[i].x + 1) * NODE_WIDTH;
  39.         bottom = (snake[i].y + 1) * NODE_WIDTH;
  40.         //  通过左上角与右下角坐标绘制矩形
  41.         solidrectangle(left, top, right, bottom);
  42.     }
  43. }
  44.  
  45. int main()
  46. {
  47.     initgraph(800, 600);
  48.     //  设置背景色
  49.     setbkcolor(RGB(164, 225, 202));
  50.     //  使用背景色清空窗体
  51.     cleardevice();
  52.  
  53.     //  蛇节点坐标
  54.     node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
  55.     //  蛇节点长度
  56.     int length = 5;
  57.  
  58.     //  绘制网格
  59.     paintGrid();
  60.     //  绘制蛇节点
  61.     paintSnake(snake, length);
  62.  
  63.     getchar();
  64.     closegraph();
  65.     return 0;
  66. }
 

3.  移动蛇节点
 

现在，我们希望让蛇向右运动，蛇头节点为(5, 7)。以下两幅图为初始位置和向右移动一步后的位置。
 

图片
 

初始位置：
 

  •  
    (5, 7)
     
  •  
    (4, 7)
     
  •  
    (3, 7)
     
  •  
    (2, 7)
     
  •  
    (1, 7)
     
 

图片
 

向右移动一步后位置：
 

  •  
    (6, 7)
     
  •  
    (5, 7)
     
  •  
    (4, 7)
     
  •  
    (3, 7)
     
  •  
    (2, 7)
     
 

可以看出移动后，蛇节点中，尾部节点(1, 7)被删除，而新增了一个头部节点(6,7)。
 

图片
 

怎样对存储蛇节点的数组进行操作，可以达到删除尾部节点，而新增一个头节点的效果呢？
 

逐个向后移动
 

从蛇尾节点前一个节点开始，即从数组下标为3的元素开始。元素3设置为当前元素，将当前元素的值，移动到后一个元素当中。接着，将当前元素设置为元素2，重复该动作，直到数组元素0的值，移动到元素1为止。
 

图片
 

  •  
    元素3-->元素4
     
  •  
    元素2-->元素3
     
  •  
    元素1-->元素2
     
  •  
    元素0-->元素1
     
 

这样即可把蛇尾节点去掉，并留出了新蛇头节点的位置。
 

设置新蛇头
 

若蛇向右运动，那么将新蛇头设置为(6,7)即可。
 

图片
 

但是，蛇头除了可以向右运动，还可以做另外3个方向的运动，共4个方向的运动。
 

  •  
    上
     
  •  
    下
     
  •  
    左
     
  •  
    右
     
 

图片
 

设旧蛇头坐标为(x, y)。对于各个方向的运动，新蛇头的网格坐标相对于旧蛇头的坐标作如下运算：
 

上：(x, y + 1)
 

下：(x, y - 1)
 

左：(x - 1, y)
 

右：(x + 1, y)
 

为了更加明确地在程序中表明方向，我们将4个方向声明为枚举类型。
 

  1. //  方向枚举
  2. enum direction
  3. {
  4.     eUp,
  5.     eDown,
  6.     eLeft,
  7.     eRight
  8. };
 

接着定义一个函数snakeMove，传入数组首元素指针、蛇节点个数和蛇前进方向。它将按照上述方法，依次移动蛇节点并根据前进方向设置蛇头。
 

  1. //  蛇节点移动
  2. void snakeMove(node* snake, int length, int direction)
  3. {
  4.     //  从尾结点开始，前一个节点覆盖后一个节点
  5.     //  4 3 2 1 0      4 3 2 1 0
  6.     //  E D C B A ---> D E C B A
  7.     for (int i = length - 1; i > 0; i--)
  8.     {
  9.         snake[i] = snake[i - 1];
  10.     }
  11.  
  12.     //  根据方向，确定下一个头节点
  13.     node newHead;
  14.     newHead = snake[0];
  15.     if (direction == eUp)
  16.     {
  17.         newHead.y--;
  18.     }
  19.     else if (direction == eDown)
  20.     {
  21.         newHead.y++;
  22.     }
  23.     else if (direction == eLeft)
  24.     {
  25.         newHead.x--;
  26.     }
  27.     else //  right
  28.     {
  29.         newHead.x++;
  30.     }
  31.  
  32.     //  更新头节点
  33.     //  D E C B A ---> D E C B N
  34.     snake[0] = newHead;
  35. }
 

在主函数中放置一个死循环，循环体中依次执行以下步骤：
 

  1.  
    清空整个窗体
     
  2.  
    绘制网格
     
  3.  
    绘制蛇节点
     
  4.  
    休眠500ms
     
  5.  
    向右移动蛇节点
     
 

 

while (1)
 {
     //  清空整个窗体
     cleardevice();
     //  绘制网格
     paintGrid();
     //  绘制蛇节点
     paintSnake(snake, length);
     //  休眠500ms
     Sleep(500);
     //  向右移动蛇节点
     snakeMove(snake, length, eRight);
 }
 

图片
 

现阶段代码如下：
 

  1. #include <easyx.h>
  2. #include <stdio.h>
  3.  
  4. #define NODE_WIDTH 40
  5.  
  6. //  节点
  7. typedef struct {
  8.     int x;
  9.     int y;
  10. }node;
  11.  
  12. //  绘制网格
  13. //  横线(0, y), (800, y)   0 <= y <= 600
  14. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  15. void paintGrid()
  16. {
  17.     //  横线
  18.     for (int y = 0; y < 600; y += NODE_WIDTH)
  19.     {
  20.         line(0, y, 800, y);
  21.     }
  22.     //  竖线
  23.     for (int x = 0; x < 800; x += NODE_WIDTH)
  24.     {
  25.         line(x, 0, x, 600);
  26.     }
  27. }
  28.  
  29. void paintSnake(node* snake, int n)
  30. {
  31.     int left, top, right, bottom;
  32.     for (int i = 0; i < n; i++)
  33.     {
  34.         //  左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】
  35.         left = snake[i].x * NODE_WIDTH;
  36.         top = snake[i].y * NODE_WIDTH;
  37.         //  右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】
  38.         right = (snake[i].x + 1) * NODE_WIDTH;
  39.         bottom = (snake[i].y + 1) * NODE_WIDTH;
  40.         //  通过左上角与右下角坐标绘制矩形
  41.         solidrectangle(left, top, right, bottom);
  42.     }
  43. }
  44.  
  45. //  方向枚举
  46. enum direction
  47. {
  48.     eUp,
  49.     eDown,
  50.     eLeft,
  51.     eRight
  52. };
  53.  
  54.  
  55. //  蛇节点移动
  56. void snakeMove(node* snake, int length, int direction)
  57. {
  58.     //  从尾结点开始，前一个节点覆盖后一个节点
  59.     //  4 3 2 1 0      4 3 2 1 0
  60.     //  E D C B A ---> D E C B A
  61.     for (int i = length - 1; i > 0; i--)
  62.     {
  63.         snake[i] = snake[i - 1];
  64.     }
  65.  
  66.     //  根据方向，确定下一个头节点
  67.     node newHead;
  68.     newHead = snake[0];
  69.     if (direction == eUp)
  70.     {
  71.         newHead.y--;
  72.     }
  73.     else if (direction == eDown)
  74.     {
  75.         newHead.y++;
  76.     }
  77.     else if (direction == eLeft)
  78.     {
  79.         newHead.x--;
  80.     }
  81.     else //  right
  82.     {
  83.         newHead.x++;
  84.     }
  85.  
  86.     //  更新头节点
  87.     //  D E C B A ---> D E C B N
  88.     snake[0] = newHead;
  89. }
  90.  
  91. int main()
  92. {
  93.     initgraph(800, 600);
  94.     //  设置背景色
  95.     setbkcolor(RGB(164, 225, 202));
  96.     //  使用背景色清空窗体
  97.     cleardevice();
  98.  
  99.     //  蛇节点坐标
  100.     node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
  101.     //  蛇节点长度
  102.     int length = 5;
  103.  
  104.     while (1)
  105.     {
  106.         //  清空整个窗体
  107.         cleardevice();
  108.         //  绘制网格
  109.         paintGrid();
  110.         //  绘制蛇节点
  111.         paintSnake(snake, length);
  112.         //  休眠500ms
  113.         Sleep(500);
  114.         //  向右移动蛇节点
  115.         snakeMove(snake, length, eRight);
  116.     }
  117.  
  118.  
  119.     getchar();
  120.     closegraph();
  121.     return 0;
  122. }
 

4. 控制移动方向
 

现在，程序开始后蛇会向右移动，接下来，加入用键盘来控制蛇的移动方向的功能。
 

键盘交互功能如下：
 

  •  
    按下w键，蛇向上移动
     
  •  
    按下s键，蛇向下移动
     
  •  
    按下a键，蛇向左移动
     
  •  
    按下d键，蛇向右移动
     
 

在主函数中声明一个枚举变量d，初始为向右移动。
 

  1. //  移动方向
  2. enum direction d = eRight;
 

将d传递给snakeMove函数的第三个参数。snakeMove函数的第三个参数可以根据方向设置新蛇头的位置。若蛇需要更改移动方向，只要更改枚举变量d即可。
 

  1. //  枚举变量d，控制蛇的移动方向
  2. snakeMove(snake, length, d);
 

与之前的键盘交互一样，使用_getch与_kbhit函数配合，可以获取键盘输入且不会导致程序阻塞。使用这两个函数别忘了包含头文件#include <conio.h>。获取到键盘输入后，通过传入枚举变量指针pD，修改变量枚举值。
 

  1. //  键盘输入改变direction
  2. void changeDirection(enum direction* pD)
  3. {
  4.     //  检查输入缓存区中是否有数据
  5.     if (_kbhit() != 0)
  6.     {
  7.         //  _getch函数获取输入缓存区中的数据
  8.         char c = _getch();
  9.         //  判断输入并转向
  10.         switch (c)
  11.         {
  12.         case 'w':
  13.             //  向上移动
  14.             *pD = eUp;
  15.             break;
  16.         case 's':
  17.             //  向下移动
  18.             *pD = eDown;
  19.             break;
  20.         case 'a':
  21.             //  向左移动
  22.             *pD = eLeft;
  23.             break;
  24.         case 'd':
  25.             //  向右移动
  26.             *pD = eRight;
  27.             break;
  28.         }
  29.     }
  30. }
 

这里还需要注意一个问题，蛇不能后退，如果新的方向与原方向相反，那么按键无效。
 

  1. //  键盘输入改变direction
  2. void changeDirection(enum direction* pD)
  3. {
  4.     //  检查输入缓存区中是否有数据
  5.     if (_kbhit() != 0)
  6.     {
  7.         //  _getch函数获取输入缓存区中的数据
  8.         char c = _getch();
  9.         //  判断输入并转向
  10.         switch (c)
  11.         {
  12.         case 'w':
  13.             //  向上移动
  14.             if (*pD != eDown)
  15.                 *pD = eUp;
  16.             break;
  17.         case 's':
  18.             //  向下移动
  19.             if (*pD != eUp)
  20.                 *pD = eDown;
  21.             break;
  22.         case 'a':
  23.             //  向左移动
  24.             if (*pD != eRight)
  25.                 *pD = eLeft;
  26.             break;
  27.         case 'd':
  28.             //  向右移动
  29.             if (*pD != eLeft)
  30.                 *pD = eRight;
  31.             break;
  32.         }
  33.     }
  34. }
 

主函数中，在snakeMove函数前调用changeDirection函数检查是否有键盘输入，若有输入且非回头方向的输入，则改变方向枚举变量d。新的方向枚举变量d传入snakeMove函数后，即可使用新方向设置新蛇头的位置，实现蛇改变移动方向功能。
 

 

//  蛇节点坐标
 node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
 //  蛇节点长度
 int length = 5;
 enum direction d = eRight;

 while (1)
 {
     cleardevice();
     paintGrid();
     paintSnake(snake, length);
     Sleep(500);

     //  获取键盘输入并将方向存储到变量d
     changeDirection(&d);
     //  根据变量d的方向移动蛇节点
     snakeMove(snake, length, d);
 }
 

图片
 

现阶段代码：
 

  1. #include <easyx.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4.  
  5. #define NODE_WIDTH 40
  6.  
  7. //  节点
  8. typedef struct {
  9.     int x;
  10.     int y;
  11. }node;
  12.  
  13. //  绘制网格
  14. //  横线(0, y), (800, y)   0 <= y <= 600
  15. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  16. void paintGrid()
  17. {
  18.     //  横线
  19.     for (int y = 0; y < 600; y += NODE_WIDTH)
  20.     {
  21.         line(0, y, 800, y);
  22.     }
  23.     //  竖线
  24.     for (int x = 0; x < 800; x += NODE_WIDTH)
  25.     {
  26.         line(x, 0, x, 600);
  27.     }
  28. }
  29.  
  30. void paintSnake(node* snake, int n)
  31. {
  32.     int left, top, right, bottom;
  33.     for (int i = 0; i < n; i++)
  34.     {
  35.         //  左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】
  36.         left = snake[i].x * NODE_WIDTH;
  37.         top = snake[i].y * NODE_WIDTH;
  38.         //  右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】
  39.         right = (snake[i].x + 1) * NODE_WIDTH;
  40.         bottom = (snake[i].y + 1) * NODE_WIDTH;
  41.         //  通过左上角与右下角坐标绘制矩形
  42.         solidrectangle(left, top, right, bottom);
  43.     }
  44. }
  45.  
  46. //  方向枚举
  47. enum direction
  48. {
  49.     eUp,
  50.     eDown,
  51.     eLeft,
  52.     eRight
  53. };
  54.  
  55.  
  56. //  蛇节点移动
  57. void snakeMove(node* snake, int length, int direction)
  58. {
  59.     //  从尾结点开始，前一个节点覆盖后一个节点
  60.     //  4 3 2 1 0      4 3 2 1 0
  61.     //  E D C B A ---> D E C B A
  62.     for (int i = length - 1; i > 0; i--)
  63.     {
  64.         snake[i] = snake[i - 1];
  65.     }
  66.  
  67.     //  根据方向，确定下一个头节点
  68.     node newHead;
  69.     newHead = snake[0];
  70.     if (direction == eUp)
  71.     {
  72.         newHead.y--;
  73.     }
  74.     else if (direction == eDown)
  75.     {
  76.         newHead.y++;
  77.     }
  78.     else if (direction == eLeft)
  79.     {
  80.         newHead.x--;
  81.     }
  82.     else //  right
  83.     {
  84.         newHead.x++;
  85.     }
  86.  
  87.     //  更新头节点
  88.     //  D E C B A ---> D E C B N
  89.     snake[0] = newHead;
  90. }
  91.  
  92. //  键盘输入改变direction
  93. void changeDirection(enum direction* pD)
  94. {
  95.     //  检查输入缓存区中是否有数据
  96.     if (_kbhit() != 0)
  97.     {
  98.         //  _getch函数获取输入缓存区中的数据
  99.         char c = _getch();
  100.         //  判断输入并转向
  101.         switch (c)
  102.         {
  103.         case 'w':
  104.             //  向上移动
  105.             if (*pD != eDown)
  106.                 *pD = eUp;
  107.             break;
  108.         case 's':
  109.             //  向下移动
  110.             if (*pD != eUp)
  111.                 *pD = eDown;
  112.             break;
  113.         case 'a':
  114.             //  向左移动
  115.             if (*pD != eRight)
  116.                 *pD = eLeft;
  117.             break;
  118.         case 'd':
  119.             //  向右移动
  120.             if (*pD != eLeft)
  121.                 *pD = eRight;
  122.             break;
  123.         }
  124.     }
  125. }
  126.  
  127. int main()
  128. {
  129.     initgraph(800, 600);
  130.     //  设置背景色
  131.     setbkcolor(RGB(164, 225, 202));
  132.     //  使用背景色清空窗体
  133.     cleardevice();
  134.  
  135.     //  蛇节点坐标
  136.     node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
  137.     //  蛇节点长度
  138.     int length = 5;
  139.     enum direction d = eRight;
  140.  
  141.     while (1)
  142.     {
  143.         //  清空整个窗体
  144.         cleardevice();
  145.         //  绘制网格
  146.         paintGrid();
  147.         //  绘制蛇节点
  148.         paintSnake(snake, length);
  149.         //  休眠500ms
  150.         Sleep(500);
  151.         //  获取键盘输入并将方向存储到变量d
  152.         changeDirection(&d);
  153.         //  根据变量d的方向移动蛇节点
  154.         snakeMove(snake, length, d);
  155.     }
  156.  
  157.     getchar();
  158.     closegraph();
  159.     return 0;
  160. }
 

5. 创建食物
 

目前蛇的部分已经完成了，还差需要创建食物，让蛇吃到食物后长大。
 

主函数中声明一个node类型的变量作为食物的节点。
 

node food;

 

食物的位置是随机生成的，但是有两个要求：
 

  1.  
    不能生成在窗体外
     
  2.  
    不能生成在蛇节点上
     
 

对于网格坐标来说，宽度有800/NODE_WIDTH，即20格。高度有600 / NODE_WIDTH，即15格。限制食物的x坐标在区间[0, 19]以内，y坐标在区间[0, 14]内。
 

  1. food.x = rand() % (800 / NODE_WIDTH);   //  区间[0, 19]内
  2. food.y = rand() % (600 / NODE_WIDTH);   //  区间[0, 14]内
 

对于第二个条件，只能遍历所有蛇节点，检查是否食物与蛇任何一个节点重合了。如果重合，那么重新随机生成一次食物，直到食物与所有蛇节点不重合为止。
 

  1. while (1)
  2. {
  3.     food.x = rand() % (800 / NODE_WIDTH);
  4.     food.y = rand() % (600 / NODE_WIDTH);
  5.  
  6.     int i;
  7.     for (i = 0; i < length; i++)
  8.     {
  9.         if (snake[i].x == food.x && snake[i].y == food.y)
  10.         {
  11.             break;
  12.         }
  13.     }
  14.     if (i < length)
  15.         continue;
  16.     else
  17.         break;
  18. }
 

将生成食物封装成createFood函数，函数传入两个参数，一个参数为蛇节点数组首元素指针，另一个参数为蛇节点个数。生成完成食物坐标后，返回装有食物坐标的food结构。
 

  1. //  随机创建食物
  2. node createFood(node* snake, int length)
  3. {
  4.     node food;
  5.     while (1)
  6.     {
  7.         food.x = rand() % (800 / NODE_WIDTH);
  8.         food.y = rand() % (600 / NODE_WIDTH);
  9.  
  10.         int i;
  11.         for (i = 0; i < length; i++)
  12.         {
  13.             if (snake[i].x == food.x && snake[i].y == food.y)
  14.             {
  15.                 break;
  16.             }
  17.         }
  18.         if (i < length)
  19.             continue;
  20.         else
  21.             break;
  22.     }
  23.     return food;
  24. }
 

根据createFood函数返回的食物坐标，在窗体上绘制一个黄色矩形代表食物。将绘制食物的代码封装成函数paintFood。
 

食物的左上角坐标为：【food.x * NODE_WIDTH, food.y * NODE_WIDTH】
 

食物的右下角坐标为：【(food.x + 1) * NODE_WIDTH, (food.y + 1) * NODE_WIDTH】
 

  1. //  绘制食物
  2. void paintFood(node food)
  3. {
  4.     int left, top, right, bottom;
  5.     left = food.x * NODE_WIDTH;
  6.     top = food.y * NODE_WIDTH;
  7.     right = (food.x + 1) * NODE_WIDTH;
  8.     bottom = (food.y + 1) * NODE_WIDTH;
  9.     setfillcolor(YELLOW);
  10.     solidrectangle(left, top, right, bottom);
  11.     setfillcolor(WHITE);
  12. }
 

主函数中，第一次生成食物在循环外。循环内部每次循环绘制一次食物。使用了随机数，别忘了使用当前时间作为随机数种子。另外，time函数需要包含头文件#include <time.h>。
 

 

//  随机生成食物
 srand(unsigned int(time(NULL)));
 node food = createFood(snake, length);

 while (1)
 {
     cleardevice();
     paintGrid();
     paintSnake(snake, length);
     //  绘制食物
     paintFood(food);
     Sleep(500);
     changeDirection(&d);
     snakeMove(snake, length, d);
 }
 

图片
 

现阶段代码：
 

  1. #include <easyx.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <time.h>
  5.  
  6. #define NODE_WIDTH 40
  7.  
  8. //  节点
  9. typedef struct {
  10.     int x;
  11.     int y;
  12. }node;
  13.  
  14. //  绘制网格
  15. //  横线(0, y), (800, y)   0 <= y <= 600
  16. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  17. void paintGrid()
  18. {
  19.     //  横线
  20.     for (int y = 0; y < 600; y += NODE_WIDTH)
  21.     {
  22.         line(0, y, 800, y);
  23.     }
  24.     //  竖线
  25.     for (int x = 0; x < 800; x += NODE_WIDTH)
  26.     {
  27.         line(x, 0, x, 600);
  28.     }
  29. }
  30.  
  31. void paintSnake(node* snake, int n)
  32. {
  33.     int left, top, right, bottom;
  34.     for (int i = 0; i < n; i++)
  35.     {
  36.         //  左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】
  37.         left = snake[i].x * NODE_WIDTH;
  38.         top = snake[i].y * NODE_WIDTH;
  39.         //  右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】
  40.         right = (snake[i].x + 1) * NODE_WIDTH;
  41.         bottom = (snake[i].y + 1) * NODE_WIDTH;
  42.         //  通过左上角与右下角坐标绘制矩形
  43.         solidrectangle(left, top, right, bottom);
  44.     }
  45. }
  46.  
  47. //  方向枚举
  48. enum direction
  49. {
  50.     eUp,
  51.     eDown,
  52.     eLeft,
  53.     eRight
  54. };
  55.  
  56.  
  57. //  蛇节点移动
  58. void snakeMove(node* snake, int length, int direction)
  59. {
  60.     //  从尾结点开始，前一个节点覆盖后一个节点
  61.     //  4 3 2 1 0      4 3 2 1 0
  62.     //  E D C B A ---> D E C B A
  63.     for (int i = length - 1; i > 0; i--)
  64.     {
  65.         snake[i] = snake[i - 1];
  66.     }
  67.  
  68.     //  根据方向，确定下一个头节点
  69.     node newHead;
  70.     newHead = snake[0];
  71.     if (direction == eUp)
  72.     {
  73.         newHead.y--;
  74.     }
  75.     else if (direction == eDown)
  76.     {
  77.         newHead.y++;
  78.     }
  79.     else if (direction == eLeft)
  80.     {
  81.         newHead.x--;
  82.     }
  83.     else //  right
  84.     {
  85.         newHead.x++;
  86.     }
  87.  
  88.     //  更新头节点
  89.     //  D E C B A ---> D E C B N
  90.     snake[0] = newHead;
  91. }
  92.  
  93. //  键盘输入改变direction
  94. void changeDirection(enum direction* pD)
  95. {
  96.     //  检查输入缓存区中是否有数据
  97.     if (_kbhit() != 0)
  98.     {
  99.         //  _getch函数获取输入缓存区中的数据
  100.         char c = _getch();
  101.         //  判断输入并转向
  102.         switch (c)
  103.         {
  104.         case 'w':
  105.             //  向上移动
  106.             if (*pD != eDown)
  107.                 *pD = eUp;
  108.             break;
  109.         case 's':
  110.             //  向下移动
  111.             if (*pD != eUp)
  112.                 *pD = eDown;
  113.             break;
  114.         case 'a':
  115.             //  向左移动
  116.             if (*pD != eRight)
  117.                 *pD = eLeft;
  118.             break;
  119.         case 'd':
  120.             //  向右移动
  121.             if (*pD != eLeft)
  122.                 *pD = eRight;
  123.             break;
  124.         }
  125.     }
  126. }
  127.  
  128. //  绘制食物
  129. /*
  130.  
  131. (x * NODE_WIDTH, y * NODE_WIDTH)
  132. @-----------
  133. |          |
  134. |          |
  135. |          |
  136. |          |
  137. |          |
  138. -----------@ ((x + 1) * NODE_WIDTH, (y + 1) * NODE_WIDTH)
  139.  
  140. */
  141. void paintFood(node food)
  142. {
  143.     int left, top, right, bottom;
  144.     left = food.x * NODE_WIDTH;
  145.     top = food.y * NODE_WIDTH;
  146.     right = (food.x + 1) * NODE_WIDTH;
  147.     bottom = (food.y + 1) * NODE_WIDTH;
  148.     setfillcolor(YELLOW);
  149.     solidrectangle(left, top, right, bottom);
  150.     setfillcolor(WHITE);
  151. }
  152.  
  153.  
  154. //  随机创建食物
  155. node createFood(node* snake, int length)
  156. {
  157.     node food;
  158.     while (1)
  159.     {
  160.         food.x = rand() % (800 / NODE_WIDTH);
  161.         food.y = rand() % (600 / NODE_WIDTH);
  162.  
  163.         int i;
  164.         for (i = 0; i < length; i++)
  165.         {
  166.             if (snake[i].x == food.x && snake[i].y == food.y)
  167.             {
  168.                 break;
  169.             }
  170.         }
  171.         if (i < length)
  172.             continue;
  173.         else
  174.             break;
  175.     }
  176.     return food;
  177. }
  178.  
  179. int main()
  180. {
  181.     initgraph(800, 600);
  182.     //  设置背景色
  183.     setbkcolor(RGB(164, 225, 202));
  184.     //  使用背景色清空窗体
  185.     cleardevice();
  186.  
  187.     //  蛇节点坐标
  188.     node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
  189.     //  蛇节点长度
  190.     int length = 5;
  191.     enum direction d = eRight;
  192.  
  193.     //  食物
  194.     srand(unsigned int(time(NULL)));
  195.     node food = createFood(snake, length);
  196.  
  197.     while (1)
  198.     {
  199.         //  清空整个窗体
  200.         cleardevice();
  201.         //  绘制网格
  202.         paintGrid();
  203.         //  绘制蛇节点
  204.         paintSnake(snake, length);
  205.         //  绘制食物
  206.         paintFood(food);
  207.         //  休眠500ms
  208.         Sleep(500);
  209.         //  获取键盘输入并将方向存储到变量d
  210.         changeDirection(&d);
  211.         //  根据变量d的方向移动蛇节点
  212.         snakeMove(snake, length, d);
  213.     }
  214.  
  215.     getchar();
  216.     closegraph();
  217.     return 0;
  218. }
 

6. 吃掉食物并长大
 

观察下图，蛇头为节点(11, 7)。而蛇目前向右运动，下一步即将吃到在(12, 7)位置的食物。
 

图片
 

现在蛇头移动到了(12, 7)的位置，并吃掉了食物。原蛇尾节点(6, 7)本应该删除，但是这时蛇吃掉了食物，需要长大一节。再将蛇尾节点(6, 7)加回来。
 

图片
 

为了获得被删除的原蛇尾节点，snakeMove函数需要返回原蛇尾节点，函数返回值从void改为node。函数中需要记录原蛇尾节点，并在最后返回原蛇尾节点。
 

  1. //  蛇身体移动
  2. node snakeMove(node* snake, int length, int direction)
  3. {
  4.     //  记录尾节点
  5.     node tail = snake[length - 1];
  6.  
  7.     for (int i = length - 1; i > 0; i--)
  8.     {
  9.         snake[i] = snake[i - 1];
  10.     }
  11.     node newHead;
  12.     newHead = snake[0];
  13.     if (direction == eUp)
  14.     {
  15.         newHead.y--;
  16.     }
  17.     else if (direction == eDown)
  18.     {
  19.         newHead.y++;
  20.     }
  21.     else if (direction == eLeft)
  22.     {
  23.         newHead.x--;
  24.     }
  25.     else
  26.     {
  27.         newHead.x++;
  28.     }
  29.     snake[0] = newHead;
  30.  
  31.     //  返回尾节点
  32.     return tail;
  33. }
 

在主函数的循环中，作新的蛇头节点是否与食物节点重合的判断。若蛇头节点与食物节点重合，那么蛇会长大一节。将snakeMove函数返回的上一次尾结点添加到蛇尾后面，蛇节点长度加1。并且，食物被吃掉以后，应当重新生成新的食物，作为新的目标。
 

注意蛇不能无限生长而超过snake数组的长度，当length大于等于100时，吃到食物就不再增加长度了。
 

 

while (1)
 {
     cleardevice();
     paintGrid();
     paintSnake(snake, length);
     paintFood(food);

     Sleep(500);

     changeDirection(&d);
     node lastTail = snakeMove(snake, length, d);
     //  新的蛇头节点是否与食物节点重合
     if (snake[0].x == food.x && snake[0].y == food.y)
     {
         //  限制snake节点最大长度
         if (length < 100)
         {
             //  已经吃到食物，长度+1
             snake[length] = lastTail;
             length++;
         }
         //  重新生成新的食物
         food = createFood(snake, length);
     }
 }
 

图片
 

现阶段代码：
 

  1. #include <easyx.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <time.h>
  5.  
  6. #define NODE_WIDTH 40
  7.  
  8. //  节点
  9. typedef struct {
  10.     int x;
  11.     int y;
  12. }node;
  13.  
  14. //  绘制网格
  15. //  横线(0, y), (800, y)   0 <= y <= 600
  16. //  竖线(x, 0),(x, 600)    0 <= x <= 800
  17. void paintGrid()
  18. {
  19.     //  横线
  20.     for (int y = 0; y < 600; y += NODE_WIDTH)
  21.     {
  22.         line(0, y, 800, y);
  23.     }
  24.     //  竖线
  25.     for (int x = 0; x < 800; x += NODE_WIDTH)
  26.     {
  27.         line(x, 0, x, 600);
  28.     }
  29. }
  30.  
  31. void paintSnake(node* snake, int n)
  32. {
  33.     int left, top, right, bottom;
  34.     for (int i = 0; i < n; i++)
  35.     {
  36.         //  左上角：【网格x坐标 * 网格宽度, 网格y坐标 * 网格宽度】
  37.         left = snake[i].x * NODE_WIDTH;
  38.         top = snake[i].y * NODE_WIDTH;
  39.         //  右下角：【(网格x坐标 + 1) * 网格宽度, (网格y坐标 + 1) * 网格宽度】
  40.         right = (snake[i].x + 1) * NODE_WIDTH;
  41.         bottom = (snake[i].y + 1) * NODE_WIDTH;
  42.         //  通过左上角与右下角坐标绘制矩形
  43.         solidrectangle(left, top, right, bottom);
  44.     }
  45. }
  46.  
  47. //  方向枚举
  48. enum direction
  49. {
  50.     eUp,
  51.     eDown,
  52.     eLeft,
  53.     eRight
  54. };
  55.  
  56.  
  57. //  蛇身体移动
  58. node snakeMove(node* snake, int length, int direction)
  59. {
  60.     //for (int i = 0; i < length; i++)
  61.     //    printf("(%d, %d)\n", snake[i].x, snake[i].y);
  62.  
  63.     //  记录尾节点
  64.     node tail = snake[length - 1];
  65.  
  66.     //  从尾结点开始，前一个节点覆盖后一个节点
  67.     //  0 1 2 3 4      0 1 2 3 4
  68.     //  E D C B A ---> E E D C B
  69.     for (int i = length - 1; i > 0; i--)
  70.     {
  71.         snake[i] = snake[i - 1];
  72.     }
  73.  
  74.     //  下一个头节点
  75.     node newHead;
  76.     newHead = snake[0];
  77.     if (direction == eUp)
  78.     {
  79.         newHead.y--;
  80.     }
  81.     else if (direction == eDown)
  82.     {
  83.         newHead.y++;
  84.     }
  85.     else if (direction == eLeft)
  86.     {
  87.         newHead.x--;
  88.     }
  89.     else //  right
  90.     {
  91.         newHead.x++;
  92.     }
  93.  
  94.     //  更新头节点
  95.     //  E D C B A ---> F E D C B
  96.     snake[0] = newHead;
  97.  
  98.     //for (int i = 0; i < length; i++)
  99.     //    printf("(%d, %d)\n", snake[i].x, snake[i].y);
  100.  
  101.     //  返回尾节点
  102.     return tail;
  103. }
  104.  
  105. //  键盘输入改变direction
  106. void changeDirection(enum direction* pD)
  107. {
  108.     //  检查输入缓存区中是否有数据
  109.     if (_kbhit() != 0)
  110.     {
  111.         //  _getch函数获取输入缓存区中的数据
  112.         char c = _getch();
  113.         //  判断输入并转向
  114.         switch (c)
  115.         {
  116.         case 'w':
  117.             //  向上移动
  118.             if (*pD != eDown)
  119.                 *pD = eUp;
  120.             break;
  121.         case 's':
  122.             //  向下移动
  123.             if (*pD != eUp)
  124.                 *pD = eDown;
  125.             break;
  126.         case 'a':
  127.             //  向左移动
  128.             if (*pD != eRight)
  129.                 *pD = eLeft;
  130.             break;
  131.         case 'd':
  132.             //  向右移动
  133.             if (*pD != eLeft)
  134.                 *pD = eRight;
  135.             break;
  136.         }
  137.     }
  138. }
  139.  
  140. //  绘制食物
  141. /*
  142.  
  143. (x * NODE_WIDTH, y * NODE_WIDTH)
  144. @-----------
  145. |          |
  146. |          |
  147. |          |
  148. |          |
  149. |          |
  150. -----------@ ((x + 1) * NODE_WIDTH, (y + 1) * NODE_WIDTH)
  151.  
  152. */
  153. void paintFood(node food)
  154. {
  155.     int left, top, right, bottom;
  156.     left = food.x * NODE_WIDTH;
  157.     top = food.y * NODE_WIDTH;
  158.     right = (food.x + 1) * NODE_WIDTH;
  159.     bottom = (food.y + 1) * NODE_WIDTH;
  160.     setfillcolor(YELLOW);
  161.     solidrectangle(left, top, right, bottom);
  162.     setfillcolor(WHITE);
  163. }
  164.  
  165.  
  166. //  随机创建食物
  167. node createFood(node* snake, int length)
  168. {
  169.     node food;
  170.     while (1)
  171.     {
  172.         food.x = rand() % (800 / NODE_WIDTH);
  173.         food.y = rand() % (600 / NODE_WIDTH);
  174.  
  175.         int i;
  176.         for (i = 0; i < length; i++)
  177.         {
  178.             if (snake[i].x == food.x && snake[i].y == food.y)
  179.             {
  180.                 break;
  181.             }
  182.         }
  183.         if (i < length)
  184.             continue;
  185.         else
  186.             break;
  187.     }
  188.     return food;
  189. }
  190.  
  191. int main()
  192. {
  193.     initgraph(800, 600);
  194.     //  设置背景色
  195.     setbkcolor(RGB(164, 225, 202));
  196.     //  使用背景色清空窗体
  197.     cleardevice();
  198.  
  199.     //  蛇节点坐标
  200.     node snake[100] = { {5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7} };
  201.     //  蛇节点长度
  202.     int length = 5;
  203.     enum direction d = eRight;
  204.  
  205.     //  食物
  206.     srand(unsigned int(time(NULL)));
  207.     node food = createFood(snake, length);
  208.  
  209.     while (1)
  210.     {
  211.         //  清空整个窗体
  212.         cleardevice();
  213.         //  绘制网格
  214.         paintGrid();
  215.         //  绘制蛇节点
  216.         paintSnake(snake, length);
  217.         //  绘制食物
  218.         paintFood(food);
  219.         //  休眠500ms
  220.         Sleep(500);
  221.         //  获取键盘输入并将方向存储到变量d
  222.         changeDirection(&d);
  223.  
  224.         node lastTail = snakeMove(snake, length, d);
  225.         //  新的蛇头节点是否与食物节点重合
  226.         if (snake[0].x == food.x && snake[0].y == food.y)
  227.         {
  228.             //  限制snake节点最大长度
  229.             if (length < 100)
  230.             {
  231.                 //  已经吃到食物, 长度+1
  232.                 snake[length] = lastTail;
  233.                 length++;
  234.             }
  235.             //  重新生成新的食物
  236.             food = createFood(snake, length);
  237.         }
  238.     }
  239.  
  240.     getchar();
  241.     closegraph();
  242.     return 0;
  243. }
 

7.游戏结束
 

最后，我们需要判断游戏是否结束。游戏结束的条件为：
 

  1.  
    蛇头吃到墙壁
     
  2.  
    蛇头吃到蛇身
     
 

如果满足以上两个条件，则游戏结束，并复位所有设置，重新开始游戏。
 

游戏网格x坐标区间为[0, 800 / NODE_WIDTH)，即[0, 20)。
 游戏网格y坐标区间为[0, 600 / NODE_WIDTH)，即[0, 19)。
 

蛇头snake[0].x小于0或大于等于20，蛇头即吃到左边或右边的墙壁。
 蛇头snake[0].y小于0或大于等于15，蛇头即吃到上边或下边的墙壁。
 

遍历除了蛇头外的所有蛇节点坐标，若有节点坐标与蛇头坐标一致，则表明蛇头吃到了蛇身。
 

将上面两个结束条件封装成isGameOver函数，若游戏结束则返回true，否则返回false。
 

  1. bool isGameOver(node *snake, int length)
  2. {
  3.     //  是否撞墙
  4.     if (snake[0].x < 0 || snake[0].x > 800 / NODE_WIDTH)
  5.         return true;
  6.  
  7.     if (snake[0].y < 0 || snake[0].y > 600 / NODE_WIDTH)
  8.         return true;
  9.  
  10.     //  是否吃到蛇身
  11.     for (int i = 1; i < length; i++)
  12.     {
  13.         if (snake[0].x == snake[i].x && snake[0].y == snake[i].y)
  14.             return true;
  15.     }
  16.     return false;
  17. }
 

游戏结束后，需要调用reset函数，复位蛇节点坐标，蛇节点长度以及前进方向。
 

  1. void reset(node* snake, int *pLength, enum direction *d)
  2. {
  3.     snake[0] = node{5, 7};
  4.     snake[1] = node{ 4, 7 };
  5.     snake[2] = node{ 3, 7 };
  6.     snake[3] = node{ 2, 7 };
  7.     snake[4] = node{ 1, 7 };
  8.     *pLength = 5;
  9.     *d = eRight;
  10. }
 

在主函数的循环中，添加游戏结束的判断。若游戏结束，复位各种设置。由于，蛇身坐标被复位，有可能与之前的食物坐标重合。因此，也应当重新生成食物。
 

完整源码请加群【881577770】获取！里面有一些资料可以帮助大家更好的学习，在学习C语言的过程中遇到任何的问题，都可以发出来一起讨论，大家都是学习C/C++的，或是转行，或是大学生，还有工作中想提升自己能力的前端党，如果你是正在学习C/C++的小伙伴可以加入学习。
 

 

  1. while (1)
  2. {
  3.     cleardevice();
  4.     paintGrid();
  5.     paintSnake(snake, length);
  6.     paintFood(food);
  7.     Sleep(500);
  8.     changeDirection(&d); 
  9.     node lastTail = snakeMove(snake, length, d);
  10.     if (snake[0].x == food.x && snake[0].y == food.y)
  11.     {
  12.         if (length < 100)
  13.         {
  14.             snake[length] = lastTail;
  15.             length++;
  16.         }
  17.         food = createFood(snake, length);
  18.     } 
  19.  
  20.     //  游戏是否结束
  21.     if (isGameOver(snake, length) == true)
  22.     {
  23.         //  游戏结束，复位设置，重新生成食物
  24.         reset(snake, &length, &d);
  25.         food = createFood(snake, length);
  26.     }
  27. }

                

               本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/451975
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号