• 贪吃蛇详解

    Win32 API介绍：

    在写贪吃蛇这款游戏时需要用到一些有关Win32 API的知识， 接下来我会将设计到的知识点列举并讲解：

    首先我们先了解一下Win32 API是什么，Windows这个多作业系统除了协调应⽤程序的执⾏、分配内存、管理资源之外，它同时也是⼀个很⼤ 的服务中⼼，调⽤这个服务中⼼的各种服务（每⼀种服务就是⼀个函数），可以帮应⽤程序达到开启 视窗、描绘图形、使⽤周边设备等⽬的，由于这些函数服务的对象是应⽤程序(Application)，所以便 称之为Application Programming Interface，简称API函数。WIN32 API也就是Microsoft Windows  32位平台的应⽤程序编程接⼝。

    控制台程序：

    控制台就是我们在运行代码时出现的那个窗口：

    有些人的可能是下面这张图的样子：

    这个是无法实现贪吃蛇的，我们需要进行设置上的修改，改成第一个图的样子即可，具体步骤如下：

    在更改完设置后我们就可以尝试对控制台进行一些操作了，比如说我们在玩贪吃蛇游戏的时候需要一个大小合适的游戏窗口，并且将控制台的标题改成“贪吃蛇”，这样会让我们写出来的游戏更加完美，接下来我来介绍一下这些命令：

    1.mode命令：

    （参考链接mode | Microsoft Learn ）

    代码：
    system("mode con cols=30 lines=30");
    演示效果：

    我们把列和行的大小都设置为30，这样只是让效果更加明显，在实际使用时需要我们不断去尝试运行去找到一个合适的大小。

    2.title命令

    参考链接（title | Microsoft Learn）

    代码：
        system("title 贪吃蛇");
    演示效果：

     这里我使用了“pause”命令，它会使代码暂停下来，如果不加这个命令的话，我们不会看到效果，因为在程序运行结束时，title也会结束，我们不妨看一下没有这个命令时的效果：

     

    ​

    控制台屏幕上的坐标COORD：

    参考链接（COORD 结构 - Windows Console | Microsoft Learn）

    COORD是Windows  API中定义的⼀个结构体，表⽰⼀个字符在控制台屏幕幕缓冲区上的坐标，坐标系(0，0)的原点位于缓冲区的顶部左侧单元格。

    COORD的类型：

    1. typedef struct _COORD {
    2.  SHORT X;
    3.  SHORT Y;
    4. } COORD, *PCOORD;

    控制台其实是有坐标的，但它会与我们平常认识的有些许不同，如下图所示：

    ​

    需要注意的是x和y坐标的单位长度是不一样的，大概就是1 ：2的比例，如下图所示：

    ​

    在打印东西的时候，总会在光标处打印，打印一下光标就会向后移动一下，在我们实现贪吃蛇的时候会需要在特定的位置进行打印，那就需要将光标放在指定的位置，也就是上面所讲的坐标，接下来我就介绍一下如何实现在指定位置打印的功能。

    ​

     GetStdHandle 函数：

    参考链接（GetStdHandle 函数 - Windows Console | Microsoft Learn）

    仔细观察运行窗口会发现有个光标在一直闪烁，设想一下，在使用贪吃蛇时总会有一个光标在闪来闪去，这会非常影响游戏体验，那我们就要想办法将光标隐藏掉。

    怎么隐藏呢？这就需要我们获得光标的一个控制权，那光标的控制权又在哪里，这就需要我们设想一下炒菜的这么一个情景，在颠锅的时候我们需要手持锅的把手，再回到代码的世界里，控制台就是这口大锅，GetStdHandle就是获得控制台控制权的一个函数，这里我们将这种控制权叫做句柄。

    有了这样的思考，这个函数的定义也就易于理解了。

    GetStdHandle是⼀个Windows  API函数。它⽤于从⼀个特定的标准设备（标准输⼊、标准输出或标 准错误）中取得⼀个句柄（⽤来标识不同设备的数值），使⽤这个句柄可以操作设备。

    函数声明：（并不需要我们自己声明，写出来只是为了便于理解）

    不难看出函数的返回类型是HANDLE，它是一个指向句柄的指针，如果获取失败，就会返回空指针；

    HANDLE GetStdHandle(DWORD nStdHandle);

    函数的参数只有一个，这种类型的参数只有三种，只需选择需要的然后copy到代码中即可。

    示例：

    1. HANDLE hOutput = NULL;
    2. //获取标准输出的句柄(⽤来标识不同设备的数值) 
    3. hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    4. if (hOutput == NULL)//如果获取失败，直接退出程序并打印错误信息
    5. {
    6.     perror("GetStdHandle");
    7.     exit(1);
    8. }

     GetConsoleCursorInfo 函数：

    参考链接（GetConsoleCursorInfo 函数 - Windows Console | Microsoft Learn）

    既然已经拿到句柄，我们就可以进行操作了，怎么操作呢？这还需要借助一个函数。

    GetConsoleCursorInfo的作用就是检索有关指定控制台屏幕缓冲区的光标⼤⼩和可⻅性的信息。

    语法：

    可见函数有两个参数，一个就是我们使用 GetStdHandle获得的句柄，

    1. BOOL WINAPI GetConsoleCursorInfo(
    2.   _In_  HANDLE               hConsoleOutput,
    3.   _Out_ PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
    4. );
    5. PCONSOLE_CURSOR_INFO 是指向 CONSOLE_CURSOR_INFO 结构的指针，该结构接收有关主机游标

    另一个是是指向 CONSOLE_CURSOR_INFO 结构的指针，该结构接收有关主机游标，它包含两个类型的变量，一个是由游标填充的字符单元的百分比，另一个是光标的显示与隐藏。

    1. typedef struct _CONSOLE_CURSOR_INFO {
    2.   DWORD dwSize;
    3.   BOOL  bVisible;
    4. } CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;

    示例：

    1. HANDLE hOutput = NULL;
    2. //获取标准输出的句柄(⽤来标识不同设备的数值) 
    3. hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    4. CONSOLE_CURSOR_INFO CursorInfo;
    5. GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息 
    6. CursorInfo.bVisible = false;

    我们来看一下效果：发现光标并没有消失，要想实现对光标的设置，还需要调用一个函数。

     SetConsoleCursorInfo函数：

    参考链接（SetConsoleCursorInfo 函数 - Windows Console | Microsoft Learn）

    设置指定控制台屏幕缓冲区的光标的⼤⼩和可⻅性。

    语法：SetConsoleCursorInfo函数的参数与GetConsoleCursorInfo 函数的参数类型相同 。

    1. BOOL WINAPI SetConsoleCursorInfo(
    2.   _In_       HANDLE              hConsoleOutput,
    3.   _In_ const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
    4. );

    示例：

    1. HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    2. //影藏光标操作 
    3. CONSOLE_CURSOR_INFO CursorInfo;
    4. GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息 
    5. CursorInfo.bVisible = false; //隐藏控制台光标 
    6. SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态

    效果图：

     SetConsoleCursorPosition 函数：

    参考链接（SetConsoleCursorPosition 函数 - Windows Console | Microsoft Learn）

    在隐藏好光标后，就可以尝试将光标放置到指定坐标上了，这就需要借助SetConsoleCursorPosition 函数。

    语法：参数有两个，分别是获得的句柄和创建的COORD类型的变量。

    1. BOOL WINAPI SetConsoleCursorPosition(
    2.   _In_ HANDLE hConsoleOutput,
    3.   _In_ COORD  dwCursorPosition
    4. );

    示例：

    1. COORD pos = { 10, 5};
    2.  HANDLE hOutput = NULL;
    3.  //获取标准输出的句柄(⽤来标识不同设备的数值) 
    4.  hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    5.  //设置标准输出上光标的位置为pos 
    6.  SetConsoleCursorPosition(hOutput, pos);

    效果图：

    学到这里，我们就可以尝试去封装一个函数来控制光标的位置，具体代码如下： 

    1. //设置光标的坐标 
    2. void SetPos(short x, short y)
    3. {
    4.  COORD pos = { x, y };
    5.  HANDLE hOutput = NULL;
    6.  //获取标准输出的句柄(⽤来标识不同设备的数值) 
    7.  hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    8.  //设置标准输出上光标的位置为pos 
    9.  SetConsoleCursorPosition(hOutput, pos);
    10. }

    这样我们就可以通过调用该函数并传入想要设置的坐标就可以实现这一功能。

    GetAsyncKeyState函数：

    参考链接（getAsyncKeyState 函数 (winuser.h) - Win32 apps | Microsoft Learn）

    思考一下，在玩贪吃蛇游戏的时候，我们会通过按相应的按键来控制蛇的移动，这种功能是如何实现的？接下来就介绍一下实现这个功能的函数。

    GetAsyncKeyState函数会获取按键情况，我们需要知道的一点是键盘上的所有按键都有一个专属的虚拟值，将键盘上每个键的虚拟键值传递给函数，函数通过返回值来分辨按键的状态。GetAsyncKeyState 的返回值是short类型，在上⼀次调⽤ GetAsyncKeyState 函数后，如果 返回的16位的short数据中，最⾼位是1，说明按键的状态是按下，如果最⾼是0，说明按键的状态是抬 起；如果最低位被置为1则说明，该按键被按过，否则为0。 

    如果我们要判断⼀个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1。

    语法：

    1. SHORT GetAsyncKeyState(
    2.  int vKey
    3. );

    示例：

    这里我用了一个宏定义，宏的内容就是( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )，0x1其实就等价于十进制中的1，写成二进制为0000 0000 0000 0000 0000 0000 0000 0001，与1进行&得到的是最后一位是否是1。这样可以让代码看起来更加简洁。

    1. #include 
    2. #include 
    3. #define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )
    4.  
    5. int main()
    6. {
    7.     while (1)
    8.     {
    9.         if (KEY_PRESS(0x30))
    10.         {
    11.             printf("0\n");
    12.         }
    13.         else if (KEY_PRESS(0x31))
    14.         {
    15.             printf("1\n");
    16.         }
    17.         else if (KEY_PRESS(0x32))
    18.         {
    19.             printf("2\n");
    20.         }
    21.         else if (KEY_PRESS(0x33))
    22.         {
    23.             printf("3\n");
    24.         }
    25.         else if (KEY_PRESS(0x34))
    26.         {
    27.             printf("4\n");
    28.         }
    29.         else if (KEY_PRESS(0x35))
    30.         {
    31.             printf("5\n");
    32.         }
    33.         else if (KEY_PRESS(0x36))
    34.         {
    35.             printf("6\n");
    36.         }
    37.         else if (KEY_PRESS(0x37))
    38.         {
    39.             printf("7\n");
    40.         }
    41.         else if (KEY_PRESS(0x38))
    42.         {
    43.             printf("8\n");
    44.         }
    45.         else if (KEY_PRESS(0x39))
    46.         {
    47.             printf("9\n");
    48.         }
    49.     }
    50.     return 0;
    51. }

    效果演示：

    我们按键盘上的数字，按几控制台上就会打印几。

    接下来我们步入正题，讲解一下贪吃蛇游戏的实现思路。

     贪吃蛇游戏设计与分析：

    联想一下我们自己玩游戏的时候，刚进入游戏它会打印一个欢迎界面，然后显示游戏规则，最后进入游戏，贪吃蛇的速度和方向通过我们的控制在一定的区域内吃食物，蛇头碰到自己或者撞到墙会直接结束游戏，游戏期间还可以加速和减速，加速吃到的食物分数会更高，减速吃到的食物分数会低一点，游戏期间可以暂停，直接退出。

    那我们就以这个思路来写代码：（接下来的功能实现我都会以函数的形式进行书写，最终会有完整代码）

    游戏运行前数据的初始化：

    0.设置窗口的大小并隐藏光标：

    这里就使用我们上面所讲的对光标的状态设置和控制台设置的知识点，写起来也会相对轻松一点。

    代码：

    1. //0.设置窗口的大小并隐藏光标
    2. void Std_set()
    3. {
    4. 	system("mode con cols=100 lines=30");
    5. 	system("title 贪吃蛇");
    6. 	HANDLE houtput = NULL;
    7. 	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    8. 	CONSOLE_CURSOR_INFO con;
    9. 	GetConsoleCursorInfo(houtput, &con);
    10. 	con.bVisible = false;
    11. 	SetConsoleCursorInfo(houtput, &con);
    12. }

    1.欢迎界面的打印：

    只需要我们将光标放到合适的位置打印”欢迎进入贪吃蛇小游戏“，如果不进行位置调整 会很难看。大家可以对比一下：

    显然是第二种比较美观，而位置的设置完全可以调用我们前面封装的函数，那么我们的欢迎界面也就完成了。

    代码：

    1. #include
    2.  
    3. //设置光标的坐标 
    4. void SetPos(int x, int y)
    5. {
    6.     COORD pos = { x, y };
    7.     HANDLE hOutput = NULL;
    8.     //获取标准输出的句柄(⽤来标识不同设备的数值) 
    9.     hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    10.     //设置标准输出上光标的位置为pos 
    11.     SetConsoleCursorPosition(hOutput, pos);
    12. }
    13.  
    14. int main()
    15. {
    16.     SetPos(35, 11);
    17.     printf("欢迎来到贪吃蛇小游戏。\n");
    18.     system("pause");
    19.     return 0;
    20. }

    2.规则说明界面的打印：

    操作与欢迎界面的打印一模一样，只需要更换一下打印的内容即可，在这我还是进行一个演示并放置参考代码。

    效果演示：

    代码：

    1. //2.规则说明界面
    2. void Print_rule()
    3. {
    4.     Set_Con(15, 10);
    5.     printf("请用↑. ↓. ←. →控制蛇移动的方向，F3为加速，F4为减速，加速会获得更高的分数。\n\n\n\n\n\n\n");
    6.     system("pause");
    7.     //system("cls");
    8. }

    设想一下，贪吃蛇的速度和方向通过我们的控制在一定的区域内吃食物，蛇头碰到自己或者撞到墙会直接结束游戏。

    根据设想，我们就会有这么一个代码：

    1. //游戏的初始化
    2. void Set_Game(Snake* ppsnake)
    3. {
    4. 	//0.设置窗口的大小并隐藏光标
    5. 	Std_set();
    6. 	//1.欢迎界面
    7. 	Print_wel();
    8. 	//2.规则说明界面
    9. 	Print_rule();
    10. 	//3.绘制地图
    11. 	Print_wall();
    12. 	//4.绘制蛇
    13. 	Print_snake(ppsnake);
    14. 	//5.绘制食物
    15. 	Print_food(ppsnake);
    16. }

    接下来就是地图的绘制

    3.地图的绘制：

    这里地图的大小就由我规定了，如有需要，可以自行更改。

    地图其实也就是我们的墙体，但是墙体我想要用特殊的图案进行绘制，比如效果图是这样的：

     这个图案可以在输入法中寻找，以下是具体步骤：

    那我们进行实操：

    代码：

    1. //3.绘制地图
    2. void Print_wall()
    3. {
    4.     for (int i = 0; i < 29; i++)
    5.     {
    6.         wprintf(L"%lc", L'□');
    7.     }
    8.     Set_Con(0, 26);
    9.     for (int i = 0; i < 29; i++)
    10.     {
    11.         wprintf(L"%lc", L'□');
    12.     }
    13.     for (int i = 1; i < 26; i++)
    14.     {
    15.         Set_Con(0, i);
    16.         wprintf(L"%lc", L'□');
    17.     }
    18.     for (int i = 1; i < 26; i++)
    19.     {
    20.         Set_Con(56, i);
    21.         wprintf(L"%lc", L'□');
    22.     }
    23. }

    效果演示： 

    发现和我们预想的不太一样，这就涉及到另一个知识：

    如果想在屏幕上打印宽字符，怎么打印呢？

    宽字符的字⾯量必须加上前缀“L”，否则C语⾔会把字⾯量当作窄字符类型处理。前缀“L”在单引 号前⾯，表⽰宽字符，对应 wprintf() 的占位符为 %lc ；在双引号前⾯，表⽰宽字符串，对应 wprintf() 的占位符为 %ls 。

    代码：

    1. int main()
    2. {
    3.     //适配到本地
    4.     setlocale(LC_ALL, "");
    5.     wchar_t ch = L'□';
    6.     wprintf(L"%lc", ch);
    7.     return 0;
    8. }

    本地化设置：

    这⾥再简单的讲⼀下C语⾔的国际化特性相关的知识，过去C语⾔并不适合⾮英语国家（地区）使⽤。 C语⾔最初假定字符都是单字节的。但是这些假定并不是在世界的任何地⽅都适⽤。

    C语⾔字符默认是采⽤ASCII编码的，ASCII字符集采⽤的是单字节编码，且只使⽤了单字节中的低7 位，最⾼位是没有使⽤的，可表⽰为0xxxxxxxx；可以看到，ASCII字符集共包含128个字符，在英语 国家中，128个字符是基本够⽤的，但是，在其他国家语⾔中，⽐如，在法语中，字⺟上⽅有注⾳符 号，它就⽆法⽤ASCII码表⽰。于是，⼀些欧洲国家就决定，利⽤字节中闲置的最⾼位编⼊新的符 号。⽐如，法语中的é的编码为130（⼆进制10000010）。这样⼀来，这些欧洲国家使⽤的编码体 系，可以表⽰最多256个符号。但是，这⾥⼜出现了新的问题。不同的国家有不同的字⺟，因此，哪 怕它们都使⽤256个符号的编码⽅式，代表的字⺟却不⼀样。⽐如，130在法语编码中代表了é，在希 伯来语编码中却代表了字⺟Gimel，在俄语编码中⼜会代表另⼀个符号。但是不管怎样，所有这 些编码⽅式中，0--127表⽰的符号是⼀样的，不⼀样的只是128--255的这⼀段。 ⾄于亚洲国家的⽂字，使⽤的符号就更多了，汉字就多达10万左右。⼀个字节只能表⽰256种符号， 肯定是不够的，就必须使⽤多个字节表达⼀个符号。⽐如，简体中⽂常⻅的编码⽅式是GB2312，使 ⽤两个字节表⽰⼀个汉字，所以理论上最多可以表⽰256x256=65536个符号。在俄语编码中⼜会代表另⼀个符号。但是不管怎样，所有这 些编码⽅式中，0--127表⽰的符号是⼀样的，不⼀样的只是128--255的这⼀段。 ⾄于亚洲国家的⽂字，使⽤的符号就更多了，汉字就多达10万左右。⼀个字节只能表⽰256种符号， 肯定是不够的，就必须使⽤多个字节表达⼀个符号。⽐如，简体中⽂常⻅的编码⽅式是GB2312，使 ⽤两个字节表⽰⼀个汉字，所以理论上最多可以表⽰256x256=65536个符号。

    后来为了使C语⾔适应国际化，C语⾔的标准中不断加⼊了国际化的⽀持。⽐如：加⼊了宽字符的类型 wchar_t 和宽字符的输⼊和输出函数，加⼊了头⽂件，其中提供了允许程序员针对特定 地区（通常是国家或者说某种特定语⾔的地理区域）调整程序⾏为的函数。

    在游戏地图上，我们打印墙体使⽤宽字符：□，打印蛇使⽤宽字符●，打印⻝物使⽤宽字符◆ 普通的字符是占⼀个字节的，这类宽字符是占⽤2个字节。

    提供的函数⽤于控制C标准库中对于不同的地区会产⽣不⼀样⾏为的部分。

     在标准中，依赖地区的部分

    有以下⼏项：

    • 数字量的格式

    • 货币量的格式

    • 字符集

    • ⽇期和时间的表⽰形式

    类项:

    通过修改地区，程序可以改变它的⾏为来适应世界的不同区域。但地区的改变可能会影响库的许多部 分，其中⼀部分可能是我们不希望修改的。

    所以C语⾔⽀持针对不同的类项进⾏修改，下⾯的⼀个宏， 指定⼀个类项：

    • LC_COLLATE：影响字符串⽐较函数 strcoll() 和 strxfrm() 。

     • LC_CTYPE：影响字符处理函数的⾏为。

     • LC_MONETARY：影响货币格式。

     • LC_NUMERIC：影响 printf() 的数字格式。

     • LC_TIME：影响时间格式 strftime() 和 wcsftime() 。

     • LC_ALL-针对所有类项修改，将以上所有类别设置为给定的语⾔环境。

    setlocale函数：

    参考链接（setlocale - C++ Reference）

    语法：

    char* setlocale (int category, const char* locale);

    setlocale的第⼀个参数可以是前⾯说明的类项中的⼀个，那么每次只会影响⼀个类项，如果第⼀个参 数是LC_ALL，就会影响所有的类项。

     C标准给第⼆个参数仅定义了2种可能取值："C"（正常模式）和""（本地模式）。

    了解之后就可以直接投入使用了：

    代码：

    1. #include
    2. #include
    3.  
    4.  
    5. //3.绘制地图
    6. void Print_wall()
    7. {
    8.     for (int i = 0; i < 29; i++)
    9.     {
    10.         wprintf(L"%lc", L'□');
    11.     }
    12.     Set_Con(0, 26);
    13.     for (int i = 0; i < 29; i++)
    14.     {
    15.         wprintf(L"%lc", L'□');
    16.     }
    17.     for (int i = 1; i < 26; i++)
    18.     {
    19.         Set_Con(0, i);
    20.         wprintf(L"%lc", L'□');
    21.     }
    22.     for (int i = 1; i < 26; i++)
    23.     {
    24.         Set_Con(56, i);
    25.         wprintf(L"%lc", L'□');
    26.     }
    27. }
    28.  
    29.  
    30. int main()
    31. {
    32.     //适配到本地
    33.     setlocale(LC_ALL, "");
    34.     Print_wall();
    35.     //system("pause");
    36.     return 0;
    37. }

    效果演示：

    观察到最后一行没有打印出来，其实不然，只是下面的文字将其遮挡住了，只需加一个”pause“命令即可看到效果：

     4.绘制蛇：

    这里会涉及到链表的知识，在前面的文章中有讲过，那蛇其实就是一个链表而已，每个结点里面储存着各自结点的x， y坐标，用于蛇身的打印，需要注意的是需要将蛇头的结点储存起来，以便找到整条蛇。

    所以我们需要创建一个蛇的结点类型，代码如下：

    1. //蛇身的结点
    2. typedef struct SnakeNode
    3. {
    4. 	//结点的坐标
    5. 	short x;
    6. 	short y;
    7. 	//指向下一个结点
    8. 	struct SnakeNode* next;
    9. }snakeNode;

    假设我们将蛇身的长度初始为5，增加结点的时候采用尾插的方式，蛇头的坐标为（24，5），

    那么初始化蛇身的代码就可以是如下：

    1. //4.绘制蛇
    2. void Print_snake(Snake* ppsnake) 
    3. {
    4. 	snakeNode* cur = NULL;
    5. 	for (int i = 0; i < 5; i++)
    6. 	{
    7. 		cur = (snakeNode*)malloc(sizeof(snakeNode));
    8. 		if (cur == NULL)
    9. 		{
    10. 			perror("malloc");
    11. 			exit(1);
    12. 		}
    13. 		cur->x = 24 + 2 * i;
    14. 		cur->y = 5;
    15. 		cur->next = NULL;
    16. 		//尾插
    17. 		if (ppsnake->psnake == NULL)
    18. 		{
    19. 			ppsnake->psnake = cur;
    20. 		}
    21. 		else
    22. 		{
    23. 			cur->next = ppsnake->psnake;
    24. 			ppsnake->psnake = cur;
    25. 		}
    26. 	}
    27. 	cur = ppsnake->psnake;
    28. 	//打印蛇身
    29. 	while (cur)
    30. 	{
    31. 		Set_Con(cur->x, cur->y);
    32. 		wprintf(L"%lc", L'●');
    33. 	    cur = cur->next;
    34. 	}
    35. 	
    36.  
    37. }

    当然，我们在绘制蛇的时候可以顺便将整个游戏的数据初始化一下，比如说游戏状态，蛇的初始方向，吃一个食物获得的分数，获得的总分数，蛇的速度（也就是两次打印之间的时间间隔）。这就需要我们写一些枚举和结构体，具体如下：

    1. //蛇的方向
    2. typedef enum DIRECTION {
    3. 	UP = 1,
    4. 	DOWN,
    5. 	LEFT,
    6. 	RIGHT,
    7. }DIRECTION;
    8.  
    9. //游戏状态
    10. typedef enum GAME_STATUS
    11. {
    12. 	//正常运行
    13. 	 REGULAR= 1, 
    14. 	//撞墙
    15. 	OVER_BY_WALL,
    16. 	//撞到自己
    17. 	OVER_BY_SELF,
    18. 	//正常退出
    19. 	OVER_NORMAL
    20. }GAME_STATUS;
    21.  
    22.  
    23. //贪吃蛇
    24. typedef struct Snake
    25. {
    26. 	//蛇的头结点
    27. 	snakeNode* psnake;
    28. 	//食物
    29. 	snakeNode* pfood;
    30. 	//蛇的方向
    31. 	DIRECTION dir;
    32. 	//蛇的速度
    33. 	int sleep_time;//时间和速度成反比
    34. 	//一个食物的分数
    35. 	int foof_weight;
    36. 	//总分数
    37. 	int score;
    38. 	//游戏状态
    39. 	GAME_STATUS status;
    40. }Snake;

    绘制蛇的代码优化：

    1. //4.绘制蛇
    2. void Print_snake(Snake* ppsnake) 
    3. {
    4. 	snakeNode* cur = NULL;
    5. 	for (int i = 0; i < 5; i++)
    6. 	{
    7. 		cur = (snakeNode*)malloc(sizeof(snakeNode));
    8. 		if (cur == NULL)
    9. 		{
    10. 			perror("malloc");
    11. 			exit(1);
    12. 		}
    13. 		cur->x = 24 + 2 * i;
    14. 		cur->y = 5;
    15. 		cur->next = NULL;
    16. 		//尾插
    17. 		if (ppsnake->psnake == NULL)
    18. 		{
    19. 			ppsnake->psnake = cur;
    20. 		}
    21. 		else
    22. 		{
    23. 			cur->next = ppsnake->psnake;
    24. 			ppsnake->psnake = cur;
    25. 		}
    26. 	}
    27. 	cur = ppsnake->psnake;
    28. 	//打印蛇身
    29. 	while (cur)
    30. 	{
    31. 		Set_Con(cur->x, cur->y);
    32. 		wprintf(L"%lc", L'●');
    33. 	    cur = cur->next;
    34. 	}
    35. 	//设置食物分数
    36. 	ppsnake->foof_weight = 10;
    37. 	//总分
    38. 	ppsnake->score = 0;
    39. 	//速度
    40. 	ppsnake->sleep_time = 200;
    41. 	//初始方向
    42. 	ppsnake->dir = RIGHT;
    43. 	//游戏状态
    44. 	ppsnake->status = REGULAR;
    45.  
    46. }

     

    5.绘制食物：

    食物的结点类型与蛇的相同，只不过只有一个结点，但是该结点的坐标不能与蛇身相同并且坐标是随机的，关于产生随机值这个知识在前面扫雷的实现里有讲，所以这里就不细说了。

    代码：

    1. //5.绘制食物
    2. void Print_food(Snake* ppsnake)
    3. {
    4. 	int x = 0;
    5. 	int y = 0;
    6. again:
    7. 	do
    8. 	{
    9. 		x = rand() % 53 + 2;
    10. 		y = rand() % 25 + 1;
    11. 	} while (x % 2 != 0);
    12. 	snakeNode* cur = ppsnake->psnake;
    13. 	while (cur)
    14. 	{
    15. 		if (cur->x == x && cur->y == y)
    16. 		{
    17. 			goto again;
    18. 		}
    19. 		cur = cur->next;
    20. 	}
    21. 	snakeNode*  p = (snakeNode*)malloc(sizeof(snakeNode));
    22. 	if (p == NULL)
    23. 	{
    24. 		perror("malloc");
    25. 		return;
    26. 	}
    27. 	p->x = x;
    28. 	p->y = y;
    29. 	p->next = NULL;
    30. 	Set_Con(x, y);
    31. 	wprintf(L"%lc", L'◆');
    32. 	ppsnake->pfood = p;
    33. }

     游戏运行：

    0.实现按键判断及反应：

    将要判断的按键的虚拟值传入写的宏中即可，判断后进行相应的反应。

    代码：

    1. //暂停游戏
    2. void PAUSE()
    3. {
    4. 	while (1)
    5. 	{
    6. 		Sleep(100);
    7. 		if (KEY_PASS(VK_SPACE))
    8. 		{
    9. 			break;
    10. 		}
    11. 	}
    12. }
    13.  
    14.  
    15. void StartGame(Snake* ppsnake)
    16. {
    17. 	do {
    18. 		if (KEY_PASS(VK_UP) && ppsnake->dir != DOWN)//向上
    19. 		{
    20. 			ppsnake->dir = UP;
    21. 		}
    22. 		else if (KEY_PASS(VK_DOWN) && ppsnake->dir != UP)//向下
    23. 		{
    24. 			ppsnake->dir = DOWN;
    25. 		}
    26. 		else if (KEY_PASS(VK_LEFT) && ppsnake->dir != RIGHT)//向左
    27. 		{
    28. 			ppsnake->dir = LEFT;
    29. 		}
    30. 		else if (KEY_PASS(VK_RIGHT) && ppsnake->dir != LEFT)//向右
    31. 		{
    32. 			ppsnake->dir = RIGHT;
    33. 		}
    34. 		else if (KEY_PASS(VK_SPACE))//暂停，也就是写一个死循环，永远处于休眠状态
    35. 		{
    36. 			PAUSE();
    37. 		}
    38. 		else if (KEY_PASS(VK_ESCAPE))//正常退出游戏
    39. 		{
    40. 			ppsnake->status = OVER_NORMAL;
    41. 		}
    42. 		else if (KEY_PASS(VK_F3))//加速
    43. 		{
    44.             //对加速次数进行限制，防止蛇出现瞬移的情况
    45. 			if (ppsnake->foof_weight < 18)
    46. 			{
    47. 				ppsnake->sleep_time -= 30;
    48. 				ppsnake->foof_weight += 2;
    49. 			}
    50. 		}
    51. 		else if (KEY_PASS(VK_F4))//减速
    52. 		{
    53.             //与加速相同，要做次数限制
    54. 			if (ppsnake->foof_weight > 2)
    55. 			{
    56. 				ppsnake->sleep_time += 30;
    57. 				ppsnake->foof_weight -= 2;
    58. 			}
    59. 		}
    60.         Snakemove(ppsnake);//移动蛇
    61. 		Sleep(ppsnake->sleep_time);//等价于蛇的速度
    62. 	} while (ppsnake->status == REGULAR);
    63. }

    1.帮助信息的打印： 

    想要达到一个这样的效果：

    我们只需要找到 合适的坐标，接着打印一下就可以了，可以把这个函数在游戏运行里调用，因为总分和每个食物的分数是要进行更新的。

    添加此功能后的代码：

    1. //暂停游戏
    2. void PAUSE()
    3. {
    4. 	while (1)
    5. 	{
    6. 		Sleep(100);
    7. 		if (KEY_PASS(VK_SPACE))
    8. 		{
    9. 			break;
    10. 		}
    11. 	}
    12. }
    13.  
    14. //打印帮助信息
    15. void Print_help()
    16. {
    17. 	Set_Con(64, 14);
    18. 	printf("按ESC退出游戏");
    19. 	Set_Con(64, 15);
    20. 	printf("按F3加速，按F4减速");
    21. }
    22.  
    23.  
    24. void StartGame(Snake* ppsnake)
    25. {
    26. 	Print_help();
    27. 	do {
    28.         Set_Con(64, 12);
    29. 		printf("总分数：%d", ppsnake->score);
    30. 		Set_Con(64, 13);
    31. 		printf("当前每个食物的分数：%02d", ppsnake->foof_weight);
    32. 		if (KEY_PASS(VK_UP) && ppsnake->dir != DOWN)//向上
    33. 		{
    34. 			ppsnake->dir = UP;
    35. 		}
    36. 		else if (KEY_PASS(VK_DOWN) && ppsnake->dir != UP)//向下
    37. 		{
    38. 			ppsnake->dir = DOWN;
    39. 		}
    40. 		else if (KEY_PASS(VK_LEFT) && ppsnake->dir != RIGHT)//向左
    41. 		{
    42. 			ppsnake->dir = LEFT;
    43. 		}
    44. 		else if (KEY_PASS(VK_RIGHT) && ppsnake->dir != LEFT)//向右
    45. 		{
    46. 			ppsnake->dir = RIGHT;
    47. 		}
    48. 		else if (KEY_PASS(VK_SPACE))//暂停，也就是写一个死循环，永远处于休眠状态
    49. 		{
    50. 			PAUSE();
    51. 		}
    52. 		else if (KEY_PASS(VK_ESCAPE))//正常退出游戏
    53. 		{
    54. 			ppsnake->status = OVER_NORMAL;
    55. 		}
    56. 		else if (KEY_PASS(VK_F3))//加速
    57. 		{
    58.             //对加速次数进行限制，防止蛇出现瞬移的情况
    59. 			if (ppsnake->foof_weight < 18)
    60. 			{
    61. 				ppsnake->sleep_time -= 30;
    62. 				ppsnake->foof_weight += 2;
    63. 			}
    64. 		}
    65. 		else if (KEY_PASS(VK_F4))//减速
    66. 		{
    67.             //与加速相同，要做次数限制
    68. 			if (ppsnake->foof_weight > 2)
    69. 			{
    70. 				ppsnake->sleep_time += 30;
    71. 				ppsnake->foof_weight -= 2;
    72. 			}
    73. 		}
    74.         Snakemove(ppsnake);//移动蛇
    75. 		Sleep(ppsnake->sleep_time);//等价于蛇的速度
    76. 	} while (ppsnake->status == REGULAR);
    77. }

    接下来实现蛇的移动 ，蛇的移动其实就是每隔一定时间重新打印蛇，只不过这个时间很短，人的肉眼难以分辨罢了，所以我们只需要着力去实现Snakemove函数。

    2.蛇的移动：

    实现该函数的思路大概就是去创建一个新的结点，这个结点储存着蛇头的下一个位置结点，需要注意的一点是，防止蛇头只有一半接触到食物，效果如下，所以我们需要蛇身x坐标一直是2的倍数，接下来开始写代码。

     

    代码：

    1. //蛇的移动
    2. void Snakemove(Snake* pp)
    3. {
    4. 	snakeNode* pnew = (snakeNode*)malloc(sizeof(snakeNode));
    5. 	if (pnew == NULL)
    6. 	{
    7. 		perror("malloc");
    8. 		return;
    9. 	}
    10. 	switch (pp->dir)
    11. 	{
    12. 	case UP:
    13. 		pnew->x = pp->psnake->x;
    14. 		pnew->y = pp->psnake->y - 1;
    15. 		break;
    16. 	case DOWN:
    17. 		pnew->x = pp->psnake->x;
    18. 		pnew->y = pp->psnake->y + 1;
    19. 		break;
    20. 	case LEFT:
    21. 		pnew->x = pp->psnake->x - 2;
    22. 		pnew->y = pp->psnake->y;
    23. 		break;
    24. 	case RIGHT:
    25. 		pnew->x = pp->psnake->x + 2;
    26. 		pnew->y = pp->psnake->y;
    27. 		break;
    28. 	}
    29. 	
    30. }

     

     3.判断下一个位置是否是食物：

    在蛇移动的过程中，下一个结点可能会是食物，所以我们要做出相应的反应，大纲如下：

    1. //蛇的移动
    2. void Snakemove(Snake* pp)
    3. {
    4. 	snakeNode* pnew = (snakeNode*)malloc(sizeof(snakeNode));
    5. 	if (pnew == NULL)
    6. 	{
    7. 		perror("malloc");
    8. 		return;
    9. 	}
    10. 	switch (pp->dir)
    11. 	{
    12. 	case UP:
    13. 		pnew->x = pp->psnake->x;
    14. 		pnew->y = pp->psnake->y - 1;
    15. 		break;
    16. 	case DOWN:
    17. 		pnew->x = pp->psnake->x;
    18. 		pnew->y = pp->psnake->y + 1;
    19. 		break;
    20. 	case LEFT:
    21. 		pnew->x = pp->psnake->x - 2;
    22. 		pnew->y = pp->psnake->y;
    23. 		break;
    24. 	case RIGHT:
    25. 		pnew->x = pp->psnake->x + 2;
    26. 		pnew->y = pp->psnake->y;
    27. 		break;
    28. 	}
    29. 	//判断下一个结点是不是食物
    30. 	if (IF_FOOF(pnew, pp))
    31. 	{
    32. 		//是食物：
    33. 		EatFood(pnew, pp);
    34. 		pnew = NULL;
    35. 	}
    36. 	else
    37. 	{
    38. 		//不是食物：
    39. 		NoFood(pnew, pp);
    40. 	}
    41. 	
    42. }

    接下来我们来实现EatFood和NoFood这两个函数，只需要判断蛇移动的下一个结点的x，y坐标是否相同即可，所以在传参的时候需要将蛇头的下一个结点传过去。

    EatFood函数：

    如果下一个结点是食物，可以直接将其化作新的蛇头，正好蛇的长度加一，重新打印蛇身，在吃掉食物的同时，我们要再创建一个新的食物，并且在总分中加上食物的分数，具体代码如下：

    1. //是食物：
    2. void EatFood(snakeNode* pnew, Snake* pp)
    3. {
    4. 	//把新的结点加到蛇身上
    5. 	pp->pfood->next = pp->psnake;
    6. 	pp->psnake = pp->pfood;
    7. 	snakeNode* cur = pp->psnake;
    8. 	//释放新的结点
    9. 	free(pnew);
    10. 	pnew = NULL;
    11. 	//重新打印蛇身
    12. 	while (cur != NULL)
    13. 	{
    14. 		Set_Con(cur->x, cur->y);
    15. 		wprintf(L"%lc", L'●');
    16. 		cur = cur->next;
    17. 	}
    18. 	pp->score += pp->foof_weight;
    19. 	//创建新的食物：
    20. 	Print_food(pp);
    21. }

     

    NoFood函数：

    如果下一个结点不是食物，我们需要把新的结点加到蛇的身上，让其成为新的蛇头，并且重新打印蛇身，需要注意的是原来蛇的尾巴需要释放掉，不然蛇会越来越长，不过在释放之前需要用到蛇的尾部结点去将原来尾部的位置用两个空格遮盖住，具体代码如下：

    1. //不是食物：
    2. void NoFood(snakeNode* pnew, Snake* pp)
    3. {
    4. 	//把新的结点加到蛇身上
    5. 	pnew->next = pp->psnake;
    6. 	pp->psnake = pnew;
    7. 	snakeNode* cur = pp->psnake;
    8. 	//重新打印蛇身
    9. 	while (cur->next->next != NULL)
    10. 	{
    11. 		Set_Con(cur->x, cur->y);
    12. 		wprintf(L"%lc", L'●');
    13. 		cur = cur->next;
    14. 	}
    15. 	Set_Con(cur->next->x, cur->next->y);
    16. 	printf("  ");
    17. 	//释放尾部结点
    18. 	free(cur->next);
    19. 	cur->next = NULL;
    20. }

     判断完下一个结点是不是食物后还要判断是否撞墙和撞到自己，大纲如下：

    1. //蛇的移动
    2. void Snakemove(Snake* pp)
    3. {
    4. 	snakeNode* pnew = (snakeNode*)malloc(sizeof(snakeNode));
    5. 	if (pnew == NULL)
    6. 	{
    7. 		perror("malloc");
    8. 		return;
    9. 	}
    10. 	switch (pp->dir)
    11. 	{
    12. 	case UP:
    13. 		pnew->x = pp->psnake->x;
    14. 		pnew->y = pp->psnake->y - 1;
    15. 		break;
    16. 	case DOWN:
    17. 		pnew->x = pp->psnake->x;
    18. 		pnew->y = pp->psnake->y + 1;
    19. 		break;
    20. 	case LEFT:
    21. 		pnew->x = pp->psnake->x - 2;
    22. 		pnew->y = pp->psnake->y;
    23. 		break;
    24. 	case RIGHT:
    25. 		pnew->x = pp->psnake->x + 2;
    26. 		pnew->y = pp->psnake->y;
    27. 		break;
    28. 	}
    29. 	//判断下一个结点是不是食物
    30. 	if (IF_FOOF(pnew, pp))
    31. 	{
    32. 		//是食物：
    33. 		EatFood(pnew, pp);
    34. 		pnew = NULL;
    35. 	}
    36. 	else
    37. 	{
    38. 		//不是食物：
    39. 		NoFood(pnew, pp);
    40. 	}
    41. 	//撞到墙
    42. 	KillByWall(pp);
    43. 	//撞到自己
    44. 	KillBySelf(pp);
    45. }

    4.是否撞墙和撞到自己

    接下来我们尝试去实现KillByWall和KillBySelf函数：

    KillByWall函数

    只需判断蛇头是否超出我们前面绘制地图时给出的范围，如果超过了就修改游戏状态即可，具体代码如下：

    1. //撞到墙
    2. void KillByWall(Snake* pp)
    3. {
    4. 	if (pp->psnake->x == 0 || pp->psnake->x == 56 || pp->psnake->y == 0 || pp->psnake->y == 26)
    5. 	{
    6. 		pp->status = OVER_BY_WALL;
    7. 	}
    8. }

     

    KillBySelf函数：

    将除蛇头以外的蛇身的每一个结点与蛇头的x，y坐标进行对比即可，具体代码如下：

    1. //撞到自己
    2. void KillBySelf(Snake* pp)
    3. {
    4. 	snakeNode* cur = pp->psnake->next;
    5. 	while (cur)
    6. 	{
    7. 		if (cur->x == pp->psnake->x && cur->y == pp->psnake->y)
    8. 		{
    9. 			pp->status = OVER_BY_SELF;
    10. 			break;
    11. 		}
    12. 		cur = cur->next;
    13. 	}
    14. }
    15.

    到这里游戏的运行就已经完成了，但是我们还要对游戏结束后进行善后工作。

    5.游戏结束善后工作：

    首先要提示玩家游戏为什么结束，然后释放蛇的结点，具体代码如下：

    1. //结束游戏
    2. void EndGame(Snake* pp)
    3. {
    4. 	switch (pp->status)
    5. 	{
    6. 	case OVER_BY_SELF:  
    7. 		printf("撞到自己了，本局游戏结束！！！");
    8. 		break;
    9. 	case OVER_BY_WALL:
    10. 		printf("撞到墙了，本局游戏结束！！！");
    11. 		break;
    12. 	case OVER_NORMAL:
    13. 		printf("本局游戏已正常退出！！！");
    14. 		break;
    15. 	}
    16. 	//释放结点
    17. 	snakeNode* cur = pp->psnake;
    18. 	while (cur)
    19. 	{
    20. 		snakeNode* del = cur;
    21. 		cur = cur->next;
    22. 		free(del);
    23. 	}
    24. }

     

     细节补充：

    在传参上我们需要注意因为我们在实现功能的时候对结构体中的内容进行了修改，所以要传结构体指针。

    我们还可以在增加一些细节，比如使用文件操作来储存历史最高纪录，这方面的知识在通讯录的实现中讲过，感兴趣可以去看一下。

    游戏所有代码： 

    到这里已经将所有功能都实现了，现在就将他们的合体展示出来，分为三个文件：

    snake.h：

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #define KEY_PASS(vk) ((GetAsyncKeyState(vk)&1)?1:0)
    9.  
    10.  
    11. //蛇身的结点
    12. typedef struct SnakeNode
    13. {
    14. 	//结点的坐标
    15. 	short x;
    16. 	short y;
    17. 	//指向下一个结点
    18. 	struct SnakeNode* next;
    19. }snakeNode;
    20.  
    21. //蛇的方向
    22. typedef enum DIRECTION {
    23. 	UP = 1,
    24. 	DOWN,
    25. 	LEFT,
    26. 	RIGHT,
    27. }DIRECTION;
    28.  
    29. //游戏状态
    30. typedef enum GAME_STATUS
    31. {
    32. 	//正常运行
    33. 	 REGULAR= 1, 
    34. 	//撞墙
    35. 	OVER_BY_WALL,
    36. 	//撞到自己
    37. 	OVER_BY_SELF,
    38. 	//正常退出
    39. 	OVER_NORMAL
    40. }GAME_STATUS;
    41.  
    42.  
    43. //贪吃蛇
    44. typedef struct Snake
    45. {
    46. 	//蛇的头结点
    47. 	snakeNode* psnake;
    48. 	//食物
    49. 	snakeNode* pfood;
    50. 	//蛇的方向
    51. 	DIRECTION dir;
    52. 	//蛇的速度
    53. 	int sleep_time;//时间和速度成反比
    54. 	//一个食物的分数
    55. 	int foof_weight;
    56. 	//总分数
    57. 	int score;
    58. 	//游戏状态
    59. 	GAME_STATUS status;
    60. }Snake;
    61.  
    62.  
    63. //游戏的初始化
    64. void Set_Game(Snake* ppsnake);
    65. //光标位置的设置
    66. void Set_Con(int x, int y);
    67. //0.设置窗口的大小并隐藏光标
    68. void Std_set();
    69. //1.欢迎界面
    70. void Print_wel();
    71. //2.规则说明界面
    72. void Print_rule();
    73. //3.绘制地图
    74. void Print_wall();
    75. //4.绘制蛇
    76. void Print_snake(Snake* ppsnake);
    77. //5.绘制食物
    78. void Print_food(Snake* ppsnake);
    79. //开始游戏
    80. void StartGame(Snake* snake);
    81. //判断下一个结点是不是食物
    82. int IF_FOOF(snakeNode* pnew, Snake* pp);
    83. //是食物：
    84. void EatFood(snakeNode* pnew,Snake* pp);
    85. //不是食物：
    86. void NoFood(snakeNode* pnew, Snake* pp);
    87. //撞到墙
    88. void KillByWall(Snake* pp);
    89. //撞到自己
    90. void KillBySelf(Snake* pp);
    91. //结束游戏
    92. void EndGame(Snake* pp);
    93.  
    94.  
    95.

    snake.c：

    1. #include"snake.h"
    2.  
    3. //游戏的初始化
    4. void Set_Game(Snake* ppsnake)
    5. {
    6. 	//0.设置窗口的大小并隐藏光标
    7. 	Std_set();
    8. 	//1.欢迎界面
    9. 	Print_wel();
    10. 	//2.规则说明界面
    11. 	Print_rule();
    12. 	//3.绘制地图
    13. 	Print_wall();
    14. 	//4.绘制蛇
    15. 	Print_snake(ppsnake);
    16. 	//5.绘制食物
    17. 	Print_food(ppsnake);
    18. }
    19.  
    20. //光标位置的设置
    21. void Set_Con(int x, int y)
    22. {
    23. 	HANDLE output = NULL;
    24. 	output = GetStdHandle(STD_OUTPUT_HANDLE);
    25. 	COORD coor = { x, y };
    26. 	SetConsoleCursorPosition(output, coor);
    27. }
    28.  
    29.  
    30. //0.设置窗口的大小并隐藏光标
    31. void Std_set()
    32. {
    33. 	system("mode con cols=100 lines=30");
    34. 	system("title 贪吃蛇");
    35. 	HANDLE houtput = NULL;
    36. 	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
    37. 	CONSOLE_CURSOR_INFO con;
    38. 	GetConsoleCursorInfo(houtput, &con);
    39. 	con.bVisible = false;
    40. 	SetConsoleCursorInfo(houtput, &con);
    41. }
    42.  
    43. //1.欢迎界面
    44. void Print_wel()
    45. {
    46. 	Set_Con(40, 12);
    47. 	printf("欢迎来到贪吃蛇小游戏！！！\n\n\n\n");
    48. 	system("pause");
    49. 	system("cls");
    50. }
    51.  
    52. //2.规则说明界面
    53. void Print_rule()
    54. {
    55. 	Set_Con(15, 10);
    56. 	printf("请用↑. ↓. ←. →控制蛇移动的方向，F3为加速，F4为减速，加速会获得更高的分数。\n\n\n\n\n\n\n");
    57. 	system("pause");
    58. 	system("cls");
    59. }
    60.  
    61. //3.绘制地图
    62. void Print_wall()
    63. {
    64. 	for (int i = 0; i < 29; i++)
    65. 	{
    66. 		wprintf(L"%lc", L'□');
    67. 	}
    68. 	Set_Con(0, 26);
    69. 	for (int i = 0; i < 29; i++)
    70. 	{
    71. 		wprintf(L"%lc", L'□');
    72. 	}
    73. 	for (int i = 1; i < 26; i++)
    74. 	{
    75. 		Set_Con(0, i);
    76. 		wprintf(L"%lc", L'□');
    77. 	}
    78. 	for (int i = 1; i < 26; i++)
    79. 	{
    80. 		Set_Con(56, i);
    81. 		wprintf(L"%lc", L'□');
    82. 	}
    83. }
    84.  
    85. //4.绘制蛇
    86. void Print_snake(Snake* ppsnake) 
    87. {
    88. 	snakeNode* cur = NULL;
    89. 	for (int i = 0; i < 5; i++)
    90. 	{
    91. 		cur = (snakeNode*)malloc(sizeof(snakeNode));
    92. 		if (cur == NULL)
    93. 		{
    94. 			perror("malloc");
    95. 			exit(1);
    96. 		}
    97. 		cur->x = 24 + 2 * i;
    98. 		cur->y = 5;
    99. 		cur->next = NULL;
    100. 		//尾插
    101. 		if (ppsnake->psnake == NULL)
    102. 		{
    103. 			ppsnake->psnake = cur;
    104. 		}
    105. 		else
    106. 		{
    107. 			cur->next = ppsnake->psnake;
    108. 			ppsnake->psnake = cur;
    109. 		}
    110. 	}
    111. 	cur = ppsnake->psnake;
    112. 	//打印蛇身
    113. 	while (cur)
    114. 	{
    115. 		Set_Con(cur->x, cur->y);
    116. 		wprintf(L"%lc", L'●');
    117. 	    cur = cur->next;
    118. 	}
    119. 	//设置食物分数
    120. 	ppsnake->foof_weight = 10;
    121. 	//总分
    122. 	ppsnake->score = 0;
    123. 	//速度
    124. 	ppsnake->sleep_time = 200;
    125. 	//初始方向
    126. 	ppsnake->dir = RIGHT;
    127. 	//游戏状态
    128. 	ppsnake->status = REGULAR;
    129.  
    130. }
    131.  
    132. //5.绘制食物
    133. void Print_food(Snake* ppsnake)
    134. {
    135. 	int x = 0;
    136. 	int y = 0;
    137. again:
    138. 	do
    139. 	{
    140. 		x = rand() % 53 + 2;
    141. 		y = rand() % 25 + 1;
    142. 	} while (x % 2 != 0);
    143. 	snakeNode* cur = ppsnake->psnake;
    144. 	while (cur)
    145. 	{
    146. 		if (cur->x == x && cur->y == y)
    147. 		{
    148. 			goto again;
    149. 		}
    150. 		cur = cur->next;
    151. 	}
    152. 	snakeNode*  p = (snakeNode*)malloc(sizeof(snakeNode));
    153. 	if (p == NULL)
    154. 	{
    155. 		perror("malloc");
    156. 		return;
    157. 	}
    158. 	p->x = x;
    159. 	p->y = y;
    160. 	p->next = NULL;
    161. 	Set_Con(x, y);
    162. 	wprintf(L"%lc", L'◆');
    163. 	ppsnake->pfood = p;
    164. }
    165.  
    166. //打印帮助信息
    167. void Print_help()
    168. {
    169. 	Set_Con(64, 14);
    170. 	printf("按ESC退出游戏");
    171. 	Set_Con(64, 15);
    172. 	printf("按F3加速，按F4减速");
    173. }
    174.  
    175. //暂停游戏
    176. void PAUSE()
    177. {
    178. 	while (1)
    179. 	{
    180. 		Sleep(100);
    181. 		if (KEY_PASS(VK_SPACE))
    182. 		{
    183. 			break;
    184. 		}
    185. 	}
    186. }
    187.  
    188. //判断下一个结点是不是食物
    189. int IF_FOOF(snakeNode* pnew, Snake* pp)
    190. {
    191. 	return (pp->pfood->x == pnew->x && pp->pfood->y == pnew->y);
    192. }
    193.  
    194. //是食物：
    195. void EatFood(snakeNode* pnew, Snake* pp)
    196. {
    197. 	//把新的结点加到蛇身上
    198. 	pp->pfood->next = pp->psnake;
    199. 	pp->psnake = pp->pfood;
    200. 	snakeNode* cur = pp->psnake;
    201. 	//释放新的结点
    202. 	free(pnew);
    203. 	pnew = NULL;
    204. 	//重新打印蛇身
    205. 	while (cur != NULL)
    206. 	{
    207. 		Set_Con(cur->x, cur->y);
    208. 		wprintf(L"%lc", L'●');
    209. 		cur = cur->next;
    210. 	}
    211. 	pp->score += pp->foof_weight;
    212. 	//创建新的食物：
    213. 	Print_food(pp);
    214. }
    215.  
    216. //不是食物：
    217. void NoFood(snakeNode* pnew, Snake* pp)
    218. {
    219. 	//把新的结点加到蛇身上
    220. 	pnew->next = pp->psnake;
    221. 	pp->psnake = pnew;
    222. 	snakeNode* cur = pp->psnake;
    223. 	//重新打印蛇身
    224. 	while (cur->next->next != NULL)
    225. 	{
    226. 		Set_Con(cur->x, cur->y);
    227. 		wprintf(L"%lc", L'●');
    228. 		cur = cur->next;
    229. 	}
    230. 	Set_Con(cur->next->x, cur->next->y);
    231. 	printf("  ");
    232. 	//释放尾部结点
    233. 	free(cur->next);
    234. 	cur->next = NULL;
    235. }
    236.  
    237. //撞到墙
    238. void KillByWall(Snake* pp)
    239. {
    240. 	if (pp->psnake->x == 0 || pp->psnake->x == 56 || pp->psnake->y == 0 || pp->psnake->y == 26)
    241. 	{
    242. 		pp->status = OVER_BY_WALL;
    243. 	}
    244. }
    245.  
    246. //撞到自己
    247. void KillBySelf(Snake* pp)
    248. {
    249. 	snakeNode* cur = pp->psnake->next;
    250. 	while (cur)
    251. 	{
    252. 		if (cur->x == pp->psnake->x && cur->y == pp->psnake->y)
    253. 		{
    254. 			pp->status = OVER_BY_SELF;
    255. 			break;
    256. 		}
    257. 		cur = cur->next;
    258. 	}
    259. }
    260.  
    261.  
    262. //蛇的移动
    263. void Snakemove(Snake* pp)
    264. {
    265. 	snakeNode* pnew = (snakeNode*)malloc(sizeof(snakeNode));
    266. 	if (pnew == NULL)
    267. 	{
    268. 		perror("malloc");
    269. 		return;
    270. 	}
    271. 	switch (pp->dir)
    272. 	{
    273. 	case UP:
    274. 		pnew->x = pp->psnake->x;
    275. 		pnew->y = pp->psnake->y - 1;
    276. 		break;
    277. 	case DOWN:
    278. 		pnew->x = pp->psnake->x;
    279. 		pnew->y = pp->psnake->y + 1;
    280. 		break;
    281. 	case LEFT:
    282. 		pnew->x = pp->psnake->x - 2;
    283. 		pnew->y = pp->psnake->y;
    284. 		break;
    285. 	case RIGHT:
    286. 		pnew->x = pp->psnake->x + 2;
    287. 		pnew->y = pp->psnake->y;
    288. 		break;
    289. 	}
    290. 	//判断下一个结点是不是食物
    291. 	if (IF_FOOF(pnew, pp))
    292. 	{
    293. 		//是食物：
    294. 		EatFood(pnew, pp);
    295. 		pnew = NULL;
    296. 	}
    297. 	else
    298. 	{
    299. 		//不是食物：
    300. 		NoFood(pnew, pp);
    301. 	}
    302. 	//撞到墙
    303. 	KillByWall(pp);
    304. 	//撞到自己
    305. 	KillBySelf(pp);
    306. }
    307.  
    308.  
    309. //开始游戏
    310. void StartGame(Snake* ppsnake)
    311. {
    312. 	Print_help();
    313. 	do {
    314. 		Set_Con(64, 12);
    315. 		printf("总分数：%d", ppsnake->score);
    316. 		Set_Con(64, 13);
    317. 		printf("当前每个食物的分数：%02d", ppsnake->foof_weight);
    318. 		if (KEY_PASS(VK_UP) && ppsnake->dir != DOWN)//向上
    319. 		{
    320. 			ppsnake->dir = UP;
    321. 		}
    322. 		else if (KEY_PASS(VK_DOWN) && ppsnake->dir != UP)//向下
    323. 		{
    324. 			ppsnake->dir = DOWN;
    325. 		}
    326. 		else if (KEY_PASS(VK_LEFT) && ppsnake->dir != RIGHT)//向左
    327. 		{
    328. 			ppsnake->dir = LEFT;
    329. 		}
    330. 		else if (KEY_PASS(VK_RIGHT) && ppsnake->dir != LEFT)//向右
    331. 		{
    332. 			ppsnake->dir = RIGHT;
    333. 		}
    334. 		else if (KEY_PASS(VK_SPACE))//暂停
    335. 		{
    336. 			PAUSE();
    337. 		}
    338. 		else if (KEY_PASS(VK_ESCAPE))//正常退出游戏
    339. 		{
    340. 			ppsnake->status = OVER_NORMAL;
    341. 		}
    342. 		else if (KEY_PASS(VK_F3))//加速
    343. 		{
    344. 			if (ppsnake->foof_weight < 18)
    345. 			{
    346. 				ppsnake->sleep_time -= 30;
    347. 				ppsnake->foof_weight += 2;
    348. 			}
    349. 		}
    350. 		else if (KEY_PASS(VK_F4))//减速
    351. 		{
    352. 			if (ppsnake->foof_weight > 2)
    353. 			{
    354. 				ppsnake->sleep_time += 30;
    355. 				ppsnake->foof_weight -= 2;
    356. 			}
    357. 		}
    358. 		Snakemove(ppsnake);
    359. 		Sleep(ppsnake->sleep_time);
    360. 	} while (ppsnake->status == REGULAR);
    361. }
    362.  
    363. //结束游戏
    364. void EndGame(Snake* pp)
    365. {
    366. 	switch (pp->status)
    367. 	{
    368. 	case OVER_BY_SELF:  
    369. 		printf("撞到自己了，本局游戏结束！！！");
    370. 		break;
    371. 	case OVER_BY_WALL:
    372. 		printf("撞到墙了，本局游戏结束！！！");
    373. 		break;
    374. 	case OVER_NORMAL:
    375. 		printf("本局游戏已正常退出！！！");
    376. 		break;
    377. 	}
    378. 	//释放结点
    379. 	snakeNode* cur = pp->psnake;
    380. 	while (cur)
    381. 	{
    382. 		snakeNode* del = cur;
    383. 		cur = cur->next;
    384. 		free(del);
    385. 	}
    386. }

    test.c：

    1.  
    2. #include"snake.h"
    3.  
    4. void test1()
    5. {
    6. 	char ch = 0;
    7. 	do {
    8.  
    9. 		system("cls");
    10. 		//创建贪吃蛇
    11. 		Snake snake = { 0 };
    12.  
    13. 		//初始化游戏
    14.  
    15. 		//0.设置窗口的大小并隐藏光标
    16. 		//1.欢迎界面
    17. 		//2.规则说明界面
    18. 		//3.绘制地图
    19. 		//4.绘制蛇
    20. 		//5.绘制食物
    21. 		//6.设置游戏的相关信息
    22. 		Set_Game(&snake);
    23.  
    24. 		//开始游戏
    25. 		StartGame(&snake);
    26. 		//结束游戏
    27. 		EndGame(&snake);
    28. 		Set_Con(20, 15);
    29. 		printf("再来一局？（Y/N）：");
    30. 		ch = getchar();
    31. 		while (getchar() != '\n');
    32. 	} while (ch == 'Y' || ch == 'y');
    33. 	Set_Con(0, 27);
    34. }
    35.  
    36.  
    37. int main()
    38. {
    39. 	//适配到本地
    40. 	setlocale(LC_ALL, "");
    41.  
    42. 	srand((unsigned int)time(NULL));
    43. 	//测试游戏
    44. 	test1();
    45. 	return 0;
    46. }
    47.  
    48.

     

  • 相关阅读:
    opencv
    Clickhouse架构与设计
    第 2 章：FFmpeg简介
    Linux文件系统
    springboot连接rabbitmq报错：Failed to checkredeclare auto-delete queue(s)
    简单使用 MySQL 索引
    K8s(Kubernetes)学习（一）：k8s概念及组件
    某验三代滑块流程分析
    若依前后分离版框架下Springboot java引入Mqtt接受发送消息
    基于Android的地图服务系统设计与实现
  • 原文地址：https://blog.csdn.net/2301_80634989/article/details/138139768