• C语言—贪吃蛇(链表)超详解

    目录

    游戏背景

    游戏展示效果

    需要实现的功能

    贪吃蛇地图绘制：

    蛇吃食物的功能：

    蛇的移动控制：

    蛇撞墙死亡：

    蛇撞自身死亡：

    计算得分：

    蛇身加速、减速：

    暂停游戏：

    技术要点

    win32 API

    控制台程序

    控制台坐标 COORD 

     成员：

    ​编辑

    什么是句柄？

    示例用法：

    GetConsoleCursorInfo 

    CONSOLE_CURSOR_INFO 结构体：

    SetConsoleCursorInfo 

    示例用法：

    SetConsoleCursorPosition 

    示例用法：

    getAsyncKeyState

    示例用法：

    步骤一：获取控制台窗口句柄

    步骤二：获取当前窗口样式

    步骤三：移除允许调整大小的样式

    步骤四：应用新的窗口样式

    贪吃蛇

    宽字符

    setlocale 函数

    宽字符的打印

    地图

    流程图

    main.c（解析全在注释中）

    Game_start

    Game_run

    Game_end

    代码

    main.c

    text.c

    text.h

    游戏背景

            贪吃蛇是久负盛名的游戏，它也和俄罗斯⽅块，扫雷等游戏位列经典游戏的⾏列。 在编程语⾔的教学中，我们以贪吃蛇为例，从设计到代码实现来提升学⽣的编程能⼒和逻辑能⼒。

    注意：本篇只适合有C语言基础的朋友

    游戏展示效果

    需要实现的功能

    1. 贪吃蛇地图绘制：

      • 需求：创建一个二维的游戏界面，显示由方格组成的地图，其中蛇和食物的位置清晰可见。
      • 实现：可以使用图形编程库（如Python的pygame、JavaScript的canvas等）来绘制固定大小的网格地图，用不同颜色或图案表示空地、蛇身、食物等元素。

    2. 蛇吃食物的功能：

      • 需求：当蛇头移动到与食物相同位置时，蛇吃掉食物，长度增加一节，并重新在地图上随机生成新的食物。
      • 实现：在每帧更新时检查蛇头坐标是否与食物坐标重合，若重合则触发进食逻辑，延长蛇身、更新蛇的总长度，并使用随机数生成算法在地图有效区域内产生新的食物位置。

    3. 蛇的移动控制：

      • 需求：通过上、下、左、右方向键（或相应触控/手势）改变蛇的移动方向，使其在下一帧按照新方向前进一格。
      • 实现：监听用户输入事件，识别方向键按下状态，更新蛇的内部“目标方向”变量。在游戏循环中，根据该变量计算蛇头下一位置，并相应更新整个蛇身的位置。

    4. 蛇撞墙死亡：

      • 需求：当蛇头移动到地图边界之外时，游戏结束，显示死亡画面或提示。
      • 实现：在蛇移动逻辑中加入边界检查，如果蛇头的新位置超出地图范围，则触发游戏结束逻辑，停止游戏循环，展示死亡画面及分数。

    5. 蛇撞自身死亡：

      • 需求：当蛇头移动到其身体其他部分所在的位置时，游戏结束，显示死亡画面或提示。
      • 实现：在蛇移动后更新所有身体位置之前，检查蛇头的新位置是否与已有的身体部分重叠，若重叠则触发游戏结束逻辑，同上。

    6. 计算得分：

      • 需求：根据蛇吃到的食物数量累计得分，分数实时显示在游戏中。
      • 实现：每当蛇吃到食物时，将分数变量加一，并在游戏界面上显示当前分数。可以设计简单的计分规则，如每吃一个食物得一分，或者根据食物类型或连续进食次数设定不同的得分规则。

    7. 蛇身加速、减速：

      • 需求：提供机制使蛇在一定条件下（如吃到特殊食物、达到特定分数等）加速或减速，改变蛇移动的速度（即每帧前进的格子数）。
      • 实现：设置蛇的移动速度变量，初始值为基础速度。当满足加速条件时，提高该速度值；满足减速条件时，降低该速度值。游戏循环中蛇的移动距离应基于当前速度值进行计算。

    8. 暂停游戏：

      • 需求：提供暂停按钮或快捷键，使得玩家能在游戏进行中暂时停止游戏进程，恢复时能从暂停点继续游戏。
      • 实现：添加暂停/继续功能的用户输入响应，如点击按钮或按下指定键。在游戏循环中检测暂停状态，暂停时停止更新游戏状态和渲染，继续时恢复游戏循环。

    技术要点

    C语⾔函数、枚举、结构体、动态内存管理、预处理指令、链表、Win32API等

    如果不知道什么是链表的就看：

    数据结构：单链表-CSDN博客文章浏览阅读1.6k次，点赞36次，收藏14次。链表是一种基本的数据结构，它用于存储一系列元素（节点），每个节点不仅包含数据元素，还包含一个指向下一个节点的指针。在链表中，数据并非连续地存储在内存中，而是通过每个节点的指针链接起来形成一个逻辑上的线性序列通过前面我们学习的顺序表我们现在延伸一个链表我们会发现顺序表的一些缺点。https://blog.csdn.net/2302_78381559/article/details/137829309?spm=1001.2014.3001.5502

    其他的知识都是c语言基础的，我们重点讲解一下会用到的几个win32api的函数

    win32 API

    Win32 API（Application Programming Interface）是Microsoft Windows操作系统为软件开发人员提供的一个标准编程接口集。它专为32位（及后来的64位兼容）版本的Windows设计，允许程序员编写能在这些操作系统上运行的应用程序，并能够充分利用Windows的各种系统功能。Win32 API本质上是一组预先定义好的函数、结构、常量、消息和宏，它们封装了与操作系统交互的复杂细节。

    这是文档链接：
    Win32 API 编程参考 - Win32 应用 |Microsoft学习icon-default.png?t=N7T8https://learn.microsoft.com/en-us/windows/win32/api/

    控制台程序

    改变我们的控制台的大小

    mode con cols=200 lines:200

    mode: 这是一个在命令提示符中内置的命令，用于修改各种系统设置和配置。在此处，它用于更改控制台的模式。

    con: 这代表“console”（控制台）设备。它表明您希望修改的是与当前控制台窗口相关的设置。

    cols=200: cols 短语表示“columns”（列）。cols=200 设置控制台窗口的宽度，即将其水平方向上的字符列数设定为200个。这意味着您可以在一行内显示最多200个字符。

    lines=200: lines 表示“lines”（行）。lines=200 设置控制台窗口的高度，即将其垂直方向上的字符行数设定为200行。这意味着您可以看到总共200行的文本输出。

    参考链接mode | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows-server/administration/windows-commands/mode

    也可以通过命令设置控制台窗⼝的名字：
     

    title 贪吃蛇

    title中文意思就是标题

    参考链接title | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows-server/administration/windows-commands/title

    可以通过这个代码去试一下效果

    1. #include
    2. int main() {
    3. 	//system(系统)
    4. 	system("mode con cols=50 lines=20");//cols行 lines列  con->console(控制台)
    5. 	system("title 贪吃蛇");//title(标题)
    6. 	system("pause");//pause(停顿)
    7. 	return 0;
    8. }

    控制台坐标 COORD 

    COORD 结构 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/coord-str结构体是用来表示控制台屏幕缓冲区上一个字符坐标的。它是windows.h头文件中定义的一个数据结构，主要用于与控制台相关的编程操作，如读写屏幕缓冲区、移动光标位置等。以下是对 COORD 结构体的详细介绍：

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

     成员：

    • SHORT X: 表示字符在缓冲区中的水平位置（列数）。X轴的正方向是从左到右，因此X值越大，字符在屏幕上的位置越靠右。

    • SHORT Y: 表示字符在缓冲区中的垂直位置（行数）。Y轴的正方向是从上到下，因此Y值越大，字符在屏幕上的位置越靠下。

    坐标系：

    如您所述，COORD 结构体使用的坐标系以缓冲区的顶部左侧单元格为原点 (0, 0)。这意味着：

    • 当 X = 0 且 Y = 0 时，对应的是缓冲区左上角的第一个单元格。
    • 随着 X 值增大，字符位置沿水平方向向右移动。
    • 随着 Y 值增大，字符位置沿垂直方向向下移动。

    GetStdHandle 

    GetStdHandle 函数 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/getstdhandle

      GetStdHandle 是 Windows API 中的一个函数，用于获取与标准输入、标准输出或标准错误设备关联的句柄。这些标准设备是操作系统为进程预定义的输入（通常是键盘）、输出（通常是显示器）和错误输出（也是显示器，但通常与标准输出区分显示）通道。通过获取这些设备的句柄，程序员可以利用其他 Windows API 函数对这些设备进行读写操作或其他相关控制。

    函数原型：

    1. HANDLE WINAPI GetStdHandle(
    2.   _In_ DWORD nStdHandle
    3. );

    参数：

    • nStdHandle: 一个 DWORD 类型的参数，指定要获取的标准设备句柄。可取以下常量值之一：

      • STD_INPUT_HANDLE (常量值 -10)：获取标准输入设备（通常为键盘）的句柄。
      • STD_OUTPUT_HANDLE (常量值 -11)：获取标准输出设备（通常为显示器）的句柄。
      • STD_ERROR_HANDLE (常量值 -12)：获取标准错误设备（通常为显示器，与标准输出区分显示）的句柄。

    返回值：

    • 如果成功，函数返回与指定标准设备关联的有效句柄。
    • 如果失败，函数返回 INVALID_HANDLE_VALUE。可通过调用 GetLastError() 函数获取具体的错误代码。

    什么是句柄？

    句柄（Handle）是计算机科学中的一个概念，它在Windows操作系统环境中被广泛使用。简单来说，句柄是一种抽象的、唯一的标识符，用于指向并操作系统内特定的对象或资源，如文件、窗口、进程、设备等。为了帮助您更好地理解句柄的概念，我们可以用一个生动的比喻来解释：

    假设您养了一群鸭子，每只鸭子都有一个独特的脚环，上面刻有唯一编号。这些编号就像鸭子的“句柄”，用来标识和区分每一只鸭子：

    1. 唯一标识：每个鸭子脚环上的编号都是独一无二的，就像句柄标识系统内的每一个对象一样。通过这个编号（句柄），您可以快速准确地识别出特定的鸭子（对象）。

    2. 操作鸭子：有了鸭子的编号（句柄），您可以对它进行各种操作，比如喂食、清理、记录生长情况等。同样，程序员通过句柄可以对系统对象进行读取、写入、删除、移动、控制属性等各种操作。例如，您可以使用句柄来读取文件内容、移动窗口位置、发送消息给进程等。

    3. 隐藏复杂性：鸭子脚环上的编号简化了您对鸭群的管理，您不需要深入了解每只鸭子的具体生理特征或生活习性，只需记住编号就能进行操作。同样，句柄隐藏了操作系统内部对象的复杂实现细节，程序员只需要通过句柄与系统交互，无需关心对象在内存中的具体位置、数据结构等底层信息。

    4. 生命周期管理：如果某只鸭子不幸去世或被卖出，它的编号（句柄）就不再有效，无法用来操作任何鸭子。在计算机系统中，当某个对象被删除、关闭或释放后，其对应的句柄也会失效，试图通过无效句柄操作对象会导致错误。因此，程序员需要注意句柄的有效性，适时释放不再使用的句柄，避免资源泄漏。

    示例用法：
    1. //STD_INPUT_HANDLE--输入设备
    2. //STD_OUTPUT_HANDLE--输出设备
    3. //STD_ERROR_HANDLE--错误设备
    4. int main(){
    5. int main() {
    6. 	//获得句柄
    7. 	HANDLE output = NULL;
    8. 	output = GetStdHandle(STD_OUTPUT_HANDLE);
    9. return 0;
    10. }

    GetConsoleCursorInfo 

    GetConsoleCursorInfo 函数 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/getconsolecursorinfo        GetConsoleCursorInfo 是 Windows API 中的一个函数，用于获取与指定控制台屏幕缓冲区关联的光标的可见性状态和大小信息。这个函数对于控制台应用程序而言非常重要，因为它允许程序员查询和可能之后修改控制台光标的行为和外观。以下是 GetConsoleCursorInfo 函数的详细说明：

    函数原型：

    1. BOOL WINAPI GetConsoleCursorInfo(
    2.   _In_     HANDLE hConsoleOutput,
    3.   _Out_    PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
    4. );

    参数：

    • hConsoleOutput: 一个 HANDLE 类型的参数，指定要查询的控制台屏幕缓冲区的句柄。通常通过 GetStdHandle(STD_OUTPUT_HANDLE) 获取标准输出设备的句柄，或者直接使用创建的控制台屏幕缓冲区句柄。

    • lpConsoleCursorInfo: 一个指向 CONSOLE_CURSOR_INFO 结构体的指针。该结构体用于接收光标的属性信息。

    CONSOLE_CURSOR_INFO 结构体：

    1. typedef struct _CONSOLE_CURSOR_INFO {
    2.   DWORD  dwSize;          // 光标的宽度，以百分比形式表示（1%-100%）
    3.   BOOL   bVisible;        // 光标的可见性状态（TRUE/FALSE）
    4. } CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;

    返回值：

    • 如果函数成功，返回非零值（TRUE）。
    • 如果函数失败，返回零值（FALSE）。可以通过调用 GetLastError() 函数获取具体的错误代码。

    用途：

    使用 GetConsoleCursorInfo 函数，您可以：

    • 查询当前控制台光标的可见性状态（是否显示光标）。
    • 查询光标的宽度（以百分比形式表示，影响光标在屏幕上的粗细）。
       

    SetConsoleCursorInfo 

    SetConsoleCursorInfo 函数 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/setconsolecursorinfo  SetConsoleCursorInfo 是 Windows API 中的一个函数，用于设置与指定控制台屏幕缓冲区关联的光标的可见性状态和大小。这个函数与 GetConsoleCursorInfo 相对应，提供了修改控制台光标行为和外观的能力。以下是 SetConsoleCursorInfo 函数的详细说明：

    函数原型：

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

    参数：

    • hConsoleOutput: 一个 HANDLE 类型的参数，指定要设置的控制台屏幕缓冲区的句柄。通常通过 GetStdHandle(STD_OUTPUT_HANDLE) 获取标准输出设备的句柄，或者直接使用创建的控制台屏幕缓冲区句柄。

    • lpConsoleCursorInfo: 一个指向 CONSOLE_CURSOR_INFO 结构体的指针，该结构体包含要设置的光标属性信息。

    示例用法：
    1. int main() {
    2. 	//获得句柄
    3. 	HANDLE output = NULL;
    4. 	output = GetStdHandle(STD_OUTPUT_HANDLE);
    5.  
    6. 	//光标信息
    7. 	CONSOLE_CURSOR_INFO cursor_info = {0};
    8.  
    9. 	//获取output句柄相关的控制台信息，存放在cursor_info里面
    10. 	GetConsoleCursorInfo(output, &cursor_info);
    11. 	cursor_info.dwSize = 100;//修改光标的占比50%(总100%)
    12. 	cursor_info.bVisible = FALSE;//修改光标的可见性(TRUE/FALSE)
    13. 	SetConsoleCursorInfo(output, &cursor_info);//设置修改的信息
    14. 	
    15. 	return 0;
    16. }

    SetConsoleCursorPosition 

    SetConsoleCursorPosition 函数 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/setconsolecursorposition  SetConsoleCursorPosition 是 Windows API 中的一个函数，用于设置与指定控制台屏幕缓冲区关联的光标位置。通过调用此函数，程序员可以精确地控制光标在控制台屏幕上的位置，这对于在控制台上绘制图形、定位文本输出等操作至关重要。以下是 SetConsoleCursorPosition 函数的详细说明：

    函数原型：

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

    参数：

    • hConsoleOutput: 一个 HANDLE 类型的参数，指定要设置光标位置的控制台屏幕缓冲区的句柄。通常通过 GetStdHandle(STD_OUTPUT_HANDLE) 获取标准输出设备的句柄，或者直接使用创建的控制台屏幕缓冲区句柄。

    • dwCursorPosition: 一个 COORD 结构体，表示新的光标位置。COORD 结构体包含两个成员：X 表示水平位置（列数），Y 表示垂直位置（行数）。坐标系原点位于缓冲区的左上角，即 (0, 0)。

    返回值：

    • 如果函数成功，返回非零值（TRUE）。
    • 如果函数失败，返回零值（FALSE）。可以通过调用 GetLastError() 函数获取具体的错误代码。
    示例用法：
    1. #include
    2. void set_pos(int x,int y) {
    3.  
    4. 	//给一个坐标
    5. 	COORD pos = { x,y };
    6. 	//获取句柄
    7. 	HANDLE output = NULL;
    8. 	output = GetStdHandle(STD_OUTPUT_HANDLE);
    9. 	//设置坐标位置
    10. 	SetConsoleCursorPosition(output, pos);//设置控制台光标位置
    11. }
    12. //改变光标位置
    13. int main() {
    14. 	set_pos(5,6);
    15. 	
    16. 	printf("hahah");
    17. 	set_pos(10, 20);
    18.  
    19. 	printf("hahah");
    20. 	return 0;
    21. }

    getAsyncKeyState


    getAsyncKeyState 函数 (winuser.h) - Win32 apps | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-getasynckeystate     GetAsyncKeyState 是 Windows API 提供的一个函数，用于异步检测键盘按键的状态。它允许程序查询某个键在当前或最近一次消息循环中是否被按下，而无需阻塞等待用户的按键事件。这种非阻塞的键盘状态检查对于实时响应用户输入、实现热键功能或其他需要即时了解键盘按键情况的应用场景非常有用。下面是 GetAsyncKeyState 函数的详细说明：

    函数原型：

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

    参数:

    • vKey: 一个整数值，表示要查询的虚拟键码。虚拟键码是系统用来标识键盘上每个键的标准代码，例如 VK_A 表示字母 'A' 键，VK_SPACE 表示空格键，等等。完整的虚拟键码列表可以在 Windows 头文件 winuser.h 中找到，或者查阅 Microsoft 文档。

    返回值:

    GetAsyncKeyState 函数返回一个短整型值（SHORT），其中包含按键状态信息。返回值可以按位分解，具有以下含义：

    • 低16位: 如果该键在当前消息队列中有一个按下消息，或者自从上次调用 GetAsyncKeyState 以来该键被按住，那么最低位（bit 0）被设置为1，表示按键处于按下状态。否则，该位为0，表示按键未被按下。

    • 高16位: 如果该键在当前消息队列中有至少一个按下消息，且该消息尚未被读取，那么高16位被设置为一个非零值。这通常用于区分新按键事件与持续按键状态。对于大多数应用，只需关注低16位即可。

    示例用法：
    1. //检测数字按键
    2.  
    3. #include 
    4. #include 
    5. #define KEY_PRESS(vk)  ((GetAsyncKeyState(vk)&1)?1:0)
    6. int main()
    7. {
    8. 	while (1)
    9. 	{
    10. 		if (KEY_PRESS(0x30))
    11. 		{
    12. 			printf("0\n");
    13. 		}
    14. 		else if (KEY_PRESS(0x31))
    15. 		{
    16. 			printf("1\n");
    17. 		}
    18. 		else if (KEY_PRESS(0x32))
    19. 		{
    20. 			printf("2\n");
    21. 		}
    22. 		else if (KEY_PRESS(0x33))
    23. 		{
    24. 			printf("3\n");
    25. 		}
    26. 		else if (KEY_PRESS(0x34))
    27. 		{
    28. 			printf("4\n");
    29. 		}
    30. 		else if (KEY_PRESS(0x35))
    31. 		{
    32. 			printf("5\n");
    33. 		}
    34. 		else if (KEY_PRESS(0x36)){
    35. 			
    36. 		printf("6\n");
    37. 		}
    38. 		else if (KEY_PRESS(0x37)){
    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. }

    SetConsoleTextAttribute

    SetConsoleTextAttribute 函数 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/setconsoletextattribute

      SetConsoleTextAttribute 是 Windows API 提供的一个函数，用于设置控制台窗口中输出文本的颜色和背景色。通过调用此函数，程序员可以改变控制台窗口中后续输出文本的显示样式，以增强控制台应用程序的可读性或美观度。以下是 SetConsoleTextAttribute 函数的详细说明：

    函数原型：

    1. BOOL WINAPI SetConsoleTextAttribute(
    2.   _In_ HANDLE hConsoleOutput,
    3.   _In_ WORD   wAttributes
    4. );

    参数:

    • hConsoleOutput: 一个 HANDLE 类型的参数，指定要设置文本属性的控制台屏幕缓冲区的句柄。通常通过 GetStdHandle(STD_OUTPUT_HANDLE) 获取标准输出设备的句柄，或者直接使用创建的控制台屏幕缓冲区句柄。

    • wAttributes: 一个 WORD 类型的值，表示要设置的文本颜色和背景色组合。这个值由两个部分组成：低四位表示前景色（文本颜色），高四位表示背景色。每个部分可以是以下预定义的常量之一，这些常量定义在 wincon.h 头文件中：

      • 前景色（文本颜色）常量：

        • FOREGROUND_BLACK
        • FOREGROUND_BLUE
        • FOREGROUND_GREEN
        • FOREGROUND_RED
        • FOREGROUND_INTENSITY （加亮效果，可以与以上颜色常量组合使用）
        • FOREGROUND_YELLOW (FOREGROUND_RED | FOREGROUND_GREEN)
        • FOREGROUND_MAGENTA (FOREGROUND_RED | FOREGROUND_BLUE)
        • FOREGROUND_CYAN (FOREGROUND_BLUE | FOREGROUND_GREEN)
        • FOREGROUND_WHITE (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

      • 背景色常量：

        • BACKGROUND_BLACK
        • BACKGROUND_BLUE
        • BACKGROUND_GREEN
        • BACKGROUND_RED
        • BACKGROUND_INTENSITY （加亮效果，可以与以上颜色常量组合使用）
        • BACKGROUND_YELLOW (BACKGROUND_RED | BACKGROUND_GREEN)
        • BACKGROUND_MAGENTA (BACKGROUND_RED | BACKGROUND_BLUE)
        • BACKGROUND_CYAN (BACKGROUND_BLUE | BACKGROUND_GREEN)
        • BACKGROUND_WHITE (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)

    返回值:

    • 如果函数成功，返回非零值（TRUE）。
    • 如果函数失败，返回零值（FALSE）。可以通过调用 GetLastError() 函数获取具体的错误代码。

    示例用法：

    1. #include 
    2.  
    3. int main() {
    4.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    5.  
    6.     // 设置前景色为红色，背景色为绿色，无加亮效果
    7.     SetConsoleTextAttribute(hConsole, FOREGROUND_RED | BACKGROUND_GREEN);
    8.  
    9.     printf("Hello, colored console!\n");
    10.  
    11.     // 恢复默认颜色
    12.     SetConsoleTextAttribute(hConsole, FOREGROUND_WHITE | BACKGROUND_BLACK);
    13.  
    14.     return 0;
    15. }

    这边在扩展一个固定控制台的几个api函数

    GetConsoleWindow 函数 - Windows Console | Microsoft Learnicon-default.png?t=N7T8https://learn.microsoft.com/zh-cn/windows/console/getconsolewindow

    1. LONG_PTR windowStyle = GetWindowLongPtr(consoleWindow, GWL_STYLE);
    2. // 禁止用户调整窗口大小，移除WS_SIZEBOX、WS_MAXIMIZEBOX、WS_MINIMIZEBOX样式
    3. SetWindowLongPtr(consoleWindow, GWL_STYLE, windowStyle & ~(WS_SIZEBOX | WS_MAXIMIZEBOX | WS_MINIMIZEBOX));//移除按钮和边框这样就不能改变大小
    4. // 应用新的窗口样式
    5. SetWindowPos(consoleWindow, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);

    步骤一：获取控制台窗口句柄

    首先，我们需要获取当前活动的控制台窗口句柄。在Windows API中，每个窗口都由一个唯一的句柄（HWND）标识。通过调用 GetConsoleWindow() 函数，可以轻松获取与当前控制台关联的窗口句柄。

    HWND consoleWindow = GetConsoleWindow();

    步骤二：获取当前窗口样式

    接下来，我们需要了解当前控制台窗口的样式。Windows窗口样式是一组标志，用于定义窗口的外观和行为。这些样式通过调用 GetWindowLongPtr() 函数并传递 GWL_STYLE 参数来获取。

    LONG_PTR windowStyle = GetWindowLongPtr(consoleWindow, GWL_STYLE);

    步骤三：移除允许调整大小的样式

    要禁止用户调整窗口大小，需要移除与窗口大小调整相关的样式标志。这些标志包括：

    • WS_SIZEBOX：表示窗口具有可调整大小的边框。
    • WS_MAXIMIZEBOX：表示窗口具有最大化按钮。
    • WS_MINIMIZEBOX：表示窗口具有最小化按钮。

    通过按位与（&~）操作符，我们可以清除这些样式标志，得到一个新的窗口样式值。

    LONG_PTR fixedWindowStyle = windowStyle & ~(WS_SIZEBOX | WS_MAXIMIZEBOX | WS_MINIMIZEBOX);

    步骤四：应用新的窗口样式

    最后，使用 SetWindowLongPtr() 函数将更新后的窗口样式应用到控制台窗口。然后，调用 SetWindowPos() 函数，指定SWP_FRAMECHANGED标志以强制系统重新绘制窗口框架，从而反映样式更改。

    1. SetWindowLongPtr(consoleWindow, GWL_STYLE, fixedWindowStyle);
    2. SetWindowPos(consoleWindow, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);

    这两行代码分别执行了设置控制台窗口新样式和更新其窗口位置及外观的操作。下面对这两行代码进行详细解析：

    SetWindowLongPtr(consoleWindow, GWL_STYLE, fixedWindowStyle);

    解析：

    • consoleWindow: 这是之前通过 GetConsoleWindow() 函数获取的控制台窗口句柄，表示我们要操作的目标窗口。

    • GWL_STYLE: 这是一个常量，用于指定我们要修改的窗口属性类型。在这里，它表示我们要修改的是窗口的样式（style），而非扩展样式（extended style）或其他类型的属性。

    • fixedWindowStyle: 这是在前一步计算得出的新窗口样式值，其中已移除了允许用户调整窗口大小的样式标志（WS_SIZEBOX、WS_MAXIMIZEBOX 和 WS_MINIMIZEBOX）。将其作为参数传入，意在将控制台窗口的样式更新为不允许用户调整大小的状态。

    这行代码的整体作用是，将经过修改的窗口样式值 fixedWindowStyle 应用到 consoleWindow 所指向的控制台窗口上，从而实现禁止窗口大小调整的功能。

    SetWindowPos(consoleWindow, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);

    解析：

    • consoleWindow: 同样是控制台窗口的句柄，指示本次操作的目标窗口。

    • NULL: 这个参数代表窗口将保持其当前的父窗口或子窗口关系不变。如果需要将窗口置于某个特定窗口之下，这里应传入该父窗口的句柄。

    • (0, 0, 0, 0): 这四个整数分别代表新窗口的位置（X坐标、Y坐标）和尺寸（宽度、高度）。由于我们不希望移动或改变窗口大小，所以这些值都被设为0。实际操作时，Windows会忽略这些值，因为接下来我们将指定特定的标志来控制窗口是否移动或调整大小。

    • SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED: 这些是组合使用的窗口位置和尺寸标志（flags），用来指定此次 SetWindowPos() 调用的具体行为：

      • SWP_NOMOVE: 表示不要移动窗口。即使指定了位置坐标（X, Y），这个标志也会让Windows忽略它们，保持窗口当前位置不变。

      • SWP_NOSIZE: 表示不要改变窗口大小。即使指定了尺寸（宽度、高度），这个标志也会让Windows忽略它们，保持窗口当前大小不变。

      • SWP_NOZORDER: 表示不要改变窗口在Z轴（堆叠顺序）上的位置，即不要改变窗口相对于其他同级窗口的前后顺序。

      • SWP_FRAMECHANGED: 这是关键的标志，它告诉Windows窗口的非客户区（如标题栏、菜单、边框等）已经发生了变化，需要重新绘制。在这里，由于我们刚刚修改了窗口样式以去除调整大小的相关元素，因此需要触发这一重绘操作，使窗口立刻呈现出新的样式效果。

    好了我们现在所有的需要用的API函数全部都介绍完了，接下来进入正题

    贪吃蛇

    宽字符

    为什么会出现宽字符嘞？

    宽字符的来历：从ASCII到Unicode，C语言中的宽字符处理-CSDN博客宽字符作为Unicode在C语言中的具体实现形式，极大地扩展了编程语言对全球多语种字符的支持能力。虽然在实际应用中还需考虑编码转换、平台差异等问题，但宽字符无疑为构建跨语言、跨文化的软件系统奠定了坚实基础。理解并熟练运用宽字符，是现代C程序员必备的技能之一。https://blog.csdn.net/2302_78381559/article/details/138158952?spm=1001.2014.3001.5502请看这篇博客，看完这篇博客我们需要做的是本地化

    1. #include
    2. #include
    3. int main() {
    4. 	char* set;
    5. 	set = setlocale(LC_ALL,"C");//C语言本来的模式
    6. 	printf("%s\n", set);
    7. 	set = setlocale(LC_ALL, "");//本地模式:Chinese (Simplified)_China.936
    8. 	printf("%s", set);
    9. 	return 0;
    10. }
    setlocale 函数
    char *setlocale(int category, const char *locale);

    • 功能：设置或查询程序的本地化类别。category 参数指定要设置或查询的类别（如LC_ALL、LC_CTYPE、LC_NUMERIC等），locale 参数指定新的本地化设置（如"en_US.UTF-8"、"zh_CN.GBK"等）或传入空指针以查询当前设置。

    • 返回值：若成功设置新的本地化，返回指向新设置的字符串指针；若查询当前设置，返回指向当前设置的字符串指针；若失败，返回空指针。

    本地化类别常量

    • LC_ALL：影响所有本地化类别。
    • LC_COLLATE：影响字符排序规则。
    • LC_CTYPE：影响字符分类（如字母、数字、空白等）和转换（如大小写转换）。
    • LC_MONETARY：影响货币格式化。
    • LC_NUMERIC：影响数字、小数点和千位分隔符的格式。
    • LC_TIME：影响日期和时间的格式化。
    宽字符的打印
    1. int main() {
    2. 	setlocale(LC_ALL, "");
    3. 	//窄字符
    4. 	char a = 'a';
    5. 	char b = 'b';
    6. 	printf("%c %c\n", a, b);
    7. 	//宽字符
    8. 	wchar_t c = L'●';
    9. 	wchar_t d = L'▲';
    10. 	wprintf(L"%lc\n", c);
    11. 	wprintf(L"%lc\n", d);
    12. }

    地图

    数据结构设计

    链表结构

    1. //创建蛇身节点类型
    2. typedef struct snakeNode {
    3. 	//坐标
    4. 	int x;
    5. 	int y;
    6. 	//指向下一个节点的指针
    7. 	struct snakeNode* next;
    8. }snakeNode,*psnakeNode_Hand;

    要管理整条贪吃蛇，我们再封装⼀个Snake的结构来维护整条贪吃蛇：

    1. /贪吃蛇 
    2. typedef struct Snake
    3. {
    4. 	psnakeNode_Hand Head;//指向蛇头的指针
    5. 	psnakeNode_Hand food;//指向食物的指针
    6. 	enum Direction dir;//蛇的方向
    7. 	enum Game_State state;//游戏状态
    8. 	int food_scores;//一个食物的分数
    9. 	int sum;//总分
    10. 	int sleep_time;//蛇的速度:休息时间(时间越短，速度越快; 时间越长，速度越慢)
    11. }Snake, * psnake;

    蛇的方向

    1. //蛇的方向
    2. enum Direction
    3. {
    4. 	UP = 1,//向上
    5. 	DOWN,//向下
    6. 	LEFT,//向左
    7. 	RIGHT//向右
    8. };

    游戏状态

    1. //游戏状态
    2. enum Game_State
    3. {
    4. 	OK,//正常
    5. 	WALL,//撞墙
    6. 	TOUCH_YOURSELF,//触碰到自己
    7. 	END//结束
    8. };

    流程图

    接下来就是我们的手撕代码环节

    main.c（解析全在注释中）

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"text.h"
    3. void text() {
    4. 	int ch = 0;
    5. 	do
    6. 	{
    7. 		system("cls");
    8. 		//创建贪吃蛇
    9. 		Snake snake = { 0 };
    10. 		//初始化
    11. 		Game_start(&snake);
    12. 		//运行
    13. 		Game_run(&snake);
    14. 		//结束
    15. 		Game_end(&snake);
    16. 		set_pos(20,15);
    17. 		printf("再来一局吗？(Y/N):");
    18. 		ch = getchar();
    19. 		while (getchar() != '\n');
    20. 		//getchar();
    21. 		
    22. 	} while (ch == 'Y' || ch =='y');
    23. 	set_pos(0, 27);
    24. }
    25. int main() {
    26. 	//适配本地环境
    27. 	setlocale(LC_ALL, "");
    28. 	text();
    29. 	
    30. 	return 0;
    31. }

    Game_start

    1. //隐藏光标+控制台大小
    2. static void set_window() {
    3. 	system("mode con cols=100 lines=30");
    4. 	system("title 贪吃蛇");
    5. 	//获取句柄
    6. 	HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
    7. 	//定义光标结构体来存储当前句柄的光标信息
    8. 	CONSOLE_CURSOR_INFO cursor_info = { 0 };
    9. 	//获取句柄光标信息
    10. 	GetConsoleCursorInfo(output, &cursor_info);
    11. 	//隐藏光标
    12. 	cursor_info.bVisible = FALSE;
    13. 	SetConsoleCursorInfo(output, &cursor_info);
    14. 	//设置窗口固定大小
    15. 	// 获取当前控制台窗口的句柄
    16. 	HWND consoleWindow = GetConsoleWindow();
    17. 	// 获取当前窗口的样式
    18. 	LONG_PTR windowStyle = GetWindowLongPtr(consoleWindow, GWL_STYLE);
    19. 	// 禁止用户调整窗口大小，移除WS_SIZEBOX、WS_MAXIMIZEBOX、WS_MINIMIZEBOX样式
    20. 	SetWindowLongPtr(consoleWindow, GWL_STYLE, windowStyle & ~(WS_SIZEBOX | WS_MAXIMIZEBOX | WS_MINIMIZEBOX));//移除按钮和边框这样就不能改变大小
    21. 	// 应用新的窗口样式
    22. 	SetWindowPos(consoleWindow, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
    23. }
    24. //定位光标
    25. void set_pos(int x,int y) {
    26.  
    27. 	//给一个坐标
    28. 	COORD pos = { x,y };
    29. 	//获取句柄
    30. 	HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
    31. 	//设置坐标位置
    32. 	SetConsoleCursorPosition(output, pos);//设置控制台光标位置
    33. }
    34. //欢迎开始界面
    35. static void wecometogame() {
    36. 	set_pos(36, 10);
    37. 	wprintf(L"欢迎来到贪吃蛇游戏\n");
    38. 	set_pos(36, 25);
    39. 	system("pause");
    40. 	system("cls");
    41. 	set_pos(40, 10);
    42. 	wprintf(L"游戏介绍\n");
    43. 	set_pos(32, 12);
    44. 	wprintf(L"用↑ ↓ ← →键位控制方向，F3(加速) F4(减速)\n");
    45. 	set_pos(32, 14);
    46. 	wprintf(L"加速可得到更高的分数\n");
    47. 	set_pos(36, 25);
    48. 	system("pause");
    49. 	system("cls");
    50.  
    51. }
    52. //修改控制台字符颜色
    53. static void Textcolor(WORD   wAttributes) {
    54. 	//获取句柄
    55. 	HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
    56. 	SetConsoleTextAttribute(output, wAttributes);
    57.  
    58. }
    59. void Drawmap()
    60. {
    61.     // 设置文本颜色为红色
    62.     Textcolor(FOREGROUND_RED);
    63.  
    64.     int i = 0;
    65.  
    66.     // 打印顶部墙壁（一行）
    67.     for (i = 0; i < 29; i++)
    68.     {
    69.         // 输出代表墙壁的字符 'WALL_l'，假设它是某种墙的图形符号
    70.         wprintf(L"%lc", WALL_l);
    71.     }
    72.  
    73.     // 设置光标位置到屏幕左下角（第0列，第26行）
    74.     set_pos(0, 26);
    75.  
    76.     // 打印底部墙壁（一行）
    77.     for (i = 0; i < 29; i++)
    78.     {
    79.         // 同样输出墙壁字符 'WALL_l'
    80.         wprintf(L"%lc", WALL_l);
    81.     }
    82.  
    83.     // 遍历从第0行至第25行（包含两端），打印左侧墙壁
    84.     for (i = 0; i <= 25; i++)
    85.     {
    86.         // 设置光标位置到指定行（i）的起始列（0）
    87.         set_pos(0, i);
    88.  
    89.         // 输出墙壁字符 'WALL_l'
    90.         wprintf(L"%lc", WALL_l);
    91.     }
    92.  
    93.     // 遍历同样的行数（0至25），打印右侧墙壁
    94.     for (i = 0; i <= 25; i++)
    95.     {
    96.         // 设置光标位置到指定行（i）的末尾列（56）
    97.         set_pos(56, i);
    98.  
    99.         // 输出墙壁字符 'WALL_l'
    100.         wprintf(L"%lc", WALL_l);
    101.     }
    102. }
    103. //创建蛇
    104. void Create_snake(psnake ps)
    105. {
    106.     // 初始化当前处理的节点指针为空
    107.     psnakeNode_Hand cur = NULL;
    108.  
    109.     // 循环3次，为蛇创建3个初始节点（即长度为3的身体）
    110.     for (int i = 0; i < 3; i++)
    111.     {
    112.         // 动态申请内存空间创建一个新的蛇节点
    113.         cur = (psnakeNode_Hand)malloc(sizeof(snakeNode));
    114.         if (cur == NULL)
    115.         {
    116.             // 如果内存分配失败，输出错误信息并退出函数
    117.             perror("Create_snake::malloc");
    118.             return;
    119.         }
    120.  
    121.         // 设置新节点坐标，根据宽度调整间隔，确保身体不重叠
    122.         cur->next = NULL;
    123.         cur->x = pos_x + i * 2; // 每增加一个节点，横坐标向右移动两格
    124.         cur->y = pos_y;
    125.  
    126.         // 头插法将新节点添加到蛇链表头部
    127.         if (ps->Head == NULL)
    128.         {
    129.             // 当链表为空时，将新节点作为链表头
    130.             ps->Head = cur;
    131.         }
    132.         else
    133.         {
    134.             // 当链表非空时，将新节点指向原链表头，然后更新链表头为新节点
    135.             cur->next = ps->Head;
    136.             ps->Head = cur;
    137.         }
    138.     }
    139.  
    140.     // 设置贪吃蛇的身体部分为蓝色，并打印在控制台上
    141.     Textcolor(FOREGROUND_BLUE);
    142.     cur = ps->Head;
    143.     while (cur != NULL)
    144.     {
    145.         // 根据节点坐标设置光标位置并打印蛇身字符BODY
    146.         set_pos(cur->x, cur->y);
    147.         wprintf(L"%c", BODY);
    148.  
    149.         // 移动到下一个节点
    150.         cur = cur->next;
    151.     }
    152.  
    153.     // 初始化贪吃蛇其他属性
    154.     ps->dir = RIGHT;         // 初始方向为向右
    155.     ps->food_scores = 10;    // 每吃到一颗食物得10分
    156.     ps->sleep_time = 200;    // 初始移动间隔时间
    157.     ps->state = OK;          // 蛇的状态设为正常
    158.     ps->sum = 0;             // 初始化得分或者其他累计值为0
    159. }
    160.  
    161. //创建食物
    162. void Create_food(psnake ps)
    163. {
    164.     int x, y; // 声明随机生成的食物坐标变量
    165.  
    166. retry_generation:
    167.     // 生成随机坐标，限定在有效范围内，并确保x坐标为偶数
    168.     do
    169.     {
    170.         x = rand() % 53 + 2; // x坐标范围：2至54，取模保证不会超出边界
    171.         y = rand() % 25 + 1; // y坐标范围：1至25
    172.     } while (x % 2 != 0); // 确保x坐标是偶数，符合屏幕布局要求
    173.  
    174.     // 遍历蛇的所有节点，检查新生成的坐标是否与蛇体坐标冲突
    175.     psnakeNode_Hand cur = ps->Head;
    176.     while (cur)
    177.     {
    178.         if (cur->x == x && cur->y == y) // 发现坐标重合
    179.         {
    180.             goto retry_generation; // 重新生成新的坐标，避免与蛇体重叠
    181.         }
    182.         cur = cur->next; // 移动到下一个节点
    183.     }
    184.  
    185.     // 分配内存空间创建食物节点
    186.     psnakeNode_Hand pfood = (psnakeNode_Hand)malloc(sizeof(snakeNode));
    187.     if (pfood == NULL)
    188.     {
    189.         // 如果内存分配失败，输出错误信息并结束函数
    190.         perror("Create_food::malloc");
    191.         return;
    192.     }
    193.     else
    194.     {
    195.         // 设置食物的颜色为绿色
    196.         Textcolor(FOREGROUND_GREEN);
    197.  
    198.         // 将随机生成的坐标赋值给食物节点
    199.         pfood->x = x;
    200.         pfood->y = y;
    201.  
    202.         // 设置光标位置并在相应坐标上打印食物符号
    203.         set_pos(pfood->x, pfood->y);
    204.         wprintf(L"%lc", FOOD);
    205.  
    206.         // 将新生成的食物节点赋值给全局的游戏食物指针
    207.         ps->food = pfood;
    208.     }
    209. }
    210. //初始化
    211. void Game_start(psnake ps) {
    212. 	//时间戳
    213. 	srand((unsigned int)time(NULL));
    214. //--隐藏光标+控制台大小--
    215. 	set_window();
    216. //--打印开始界面+功能介绍--
    217. 	wecometogame();
    218. //--绘制地图--
    219. 	Drawmap();
    220. //--创建蛇--//--设置游戏相关信息--
    221. 	Create_snake(ps);
    222. //--创建食物--
    223. 	Create_food(ps);
    224. }

    Game_run

    1. //游戏提示
    2. void Game_prompt() {
    3. 	set_pos(75, 7);
    4. 	wprintf(L"%ls", L"《游戏提示》\n");
    5. 	set_pos(64, 10);
    6. 	wprintf(L"%ls", L"<不能穿墙，不能咬到自己>\n");
    7. 	set_pos(64, 12);
    8. 	wprintf(L"%ls", L"<用↑.↓.←.→分别控制蛇的移动>\n");
    9. 	set_pos(64, 14);
    10. 	wprintf(L"%ls", L"\n");
    11. 	set_pos(64, 16);
    12. 	wprintf(L"%ls", L"\n");
    13. 	set_pos(80, 18);
    14. 	wprintf(L"%ls",L"--普通小青年\n");
    15. 	
    16. }
    17.  
    18. //判断是否遇到食物
    19. int Nextfood(psnakeNode_Hand pn, psnake ps) {
    20. 	
    21. 	return (pn->x == ps->food->x && pn->y == ps->food->y);//都满足就返回1，否者返回0
    22. }
    23.  
    24. //吃掉食物
    25. void Eatfood(psnakeNode_Hand pn, psnake ps) {
    26. 	//头插
    27. 	pn->next = ps->Head;
    28. 	ps->Head = pn;
    29. 	
    30. 	psnakeNode_Hand cur = ps->Head;
    31. 	while (cur)
    32. 	{
    33. 		Textcolor(FOREGROUND_BLUE);
    34. 		set_pos(cur->x, cur->y);
    35. 		wprintf(L"%lc", BODY);
    36. 		cur = cur->next;
    37. 	}
    38. 	ps->sum += ps->food_scores;//吃掉一个食物加分
    39. 	free(ps->food);//销毁食物
    40. 	Create_food(ps);//再次生成一个食物
    41. }
    42.  
    43. //没有食物
    44. void Nofood(psnakeNode_Hand pn, psnake ps) {
    45. 	//psnakeNode_Hand pn -- 下一个节点地址
    46. 	//psnake ps 维护蛇的指针
    47. 	
    48. 	//头插
    49. 	pn->next = ps->Head;
    50. 	ps->Head = pn;
    51.  
    52. 	psnakeNode_Hand cur = ps->Head;
    53. 	
    54. 	//找到倒数第二个节点地址
    55. 	while (cur->next->next)
    56. 	{
    57. 		set_pos(cur->x,cur->y);
    58. 		Textcolor(FOREGROUND_BLUE);
    59. 		wprintf(L"%lc", BODY);
    60. 		cur = cur->next;
    61. 	}
    62. 	Textcolor(FOREGROUND_GREEN);
    63. 	set_pos(cur->next->x,cur->next->y);
    64. 	printf("  ");
    65. 	free(cur->next);
    66. 	cur->next = NULL;
    67.  
    68. }
    69.  
    70. //判断撞墙
    71. void KillByWall(psnake ps) {
    72. 	//判断头部是否和我们的墙的坐标一样
    73. 	if (
    74. 		(ps->Head->x == 0) ||
    75. 		(ps->Head->x == 56)||
    76. 		(ps->Head->y == 0)||
    77. 		(ps->Head->y == 26)
    78. 		)
    79. 	{
    80. 		//游戏状态
    81. 		ps->state = WALL;
    82. 		return 1;
    83.  
    84. 	}
    85. 	return 0;
    86. }
    87.  
    88. //判断撞到自己
    89. void KillBySelf(psnake ps) {
    90. 	//遍历坐标如果有自己子节点的坐标
    91. 	psnakeNode_Hand cur = ps->Head->next;//遍历除了头节点的其他节点所以我们要ps->Head->next,也就是第二个节点开始遍历
    92. 	while (cur)
    93. 	{
    94. 		if (
    95. 			(ps->Head->x == cur->x)
    96. 			&&(ps->Head->y == cur->y)
    97. 			) {
    98.  
    99. 			ps->state = TOUCH_YOURSELF;
    100. 			return 1;
    101. 		}
    102. 		cur = cur->next;
    103. 	}
    104. 	return 0;
    105. }
    106.  
    107. void SnakeMove(psnake ps)
    108. {
    109.     // 动态分配内存创建一个新的蛇节点
    110.     psnakeNode_Hand pNextNode = (psnakeNode_Hand)malloc(sizeof(snakeNode));
    111.     if (pNextNode == NULL)
    112.     {
    113.         // 内存分配失败时，输出错误信息并返回
    114.         perror("SnakeMove::malloc");
    115.         return;
    116.     }
    117.  
    118.     // 根据蛇的移动方向确定下一个节点的坐标
    119.     switch (ps->dir)
    120.     {
    121.         case UP:
    122.             pNextNode->x = ps->Head->x;
    123.             pNextNode->y = ps->Head->y - 1; // 向上移动
    124.             break;
    125.         case DOWN:
    126.             pNextNode->x = ps->Head->x;
    127.             pNextNode->y = ps->Head->y + 1; // 向下移动
    128.             break;
    129.         case LEFT:
    130.             pNextNode->x = ps->Head->x - 2; // 左移两个单位，以适应宽字符
    131.             pNextNode->y = ps->Head->y;
    132.             break;
    133.         case RIGHT:
    134.             pNextNode->x = ps->Head->x + 2; // 右移两个单位，以适应宽字符
    135.             pNextNode->y = ps->Head->y;
    136.             break;
    137.     }
    138.  
    139.     // 判断蛇的下一个节点位置是否为食物
    140.     if (Nextfood(pNextNode, ps)) // 自定义函数，判断下一个节点是否为食物
    141.     {
    142.         Eatfood(pNextNode, ps);   // 自定义函数，处理蛇吃到食物的情况
    143.     }
    144.     else
    145.     {
    146.         Nofood(pNextNode, ps);    // 自定义函数，处理蛇未吃到食物的情况
    147.     }
    148.  
    149.     // 判断蛇是否撞到墙壁
    150.     KillByWall(ps);
    151.  
    152.     // 判断蛇是否撞到自己的身体
    153.     KillBySelf(ps);
    154. }
    155.  
    156. //游戏暂停
    157. void Game_stop() {
    158. 	
    159. 	while (1)
    160. 	{
    161. 		if (KEY_PRESS(VK_SPACE)) {
    162. 			break;
    163. 		}
    164. 		Sleep(200);
    165. 	}
    166. }
    167.  
    168. void Game_run(psnake ps)
    169. {
    170.     // 显示游戏提示信息
    171.     Game_prompt();
    172.  
    173.     // 主循环
    174.     do
    175.     {
    176.         // 打印当前得分和食物的分值
    177.         set_pos(64, 9);
    178.         printf("总分：%2d ", ps->sum);
    179.         printf("食物分值：%2d\n", ps->food_scores);
    180.  
    181.         // 处理玩家按键操作
    182.         if (KEY_PRESS(VK_UP) && ps->dir != DOWN)
    183.         {
    184.             ps->dir = UP; // 设置蛇向上移动
    185.         }
    186.         else if (KEY_PRESS(VK_DOWN) && ps->dir != UP)
    187.         {
    188.             ps->dir = DOWN; // 设置蛇向下移动
    189.         }
    190.         else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT)
    191.         {
    192.             ps->dir = LEFT; // 设置蛇向左移动
    193.         }
    194.         else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT)
    195.         {
    196.             ps->dir = RIGHT; // 设置蛇向右移动
    197.         }
    198.         else if (KEY_PRESS(VK_SPACE))
    199.         {
    200.             // 暂停游戏
    201.             Game_stop();
    202.         }
    203.         else if (KEY_PRESS(VK_ESCAPE))
    204.         {
    205.             // 结束游戏
    206.             ps->state = END;
    207.         }
    208.         else if (KEY_PRESS(VK_F3))
    209.         {
    210.             // 加速游戏
    211.             if (ps->sleep_time >= 80)
    212.             {
    213.                 ps->sleep_time -= 30; // 减少延迟时间，加快游戏速度
    214.                 ps->food_scores += 2; // 提高食物分值
    215.             }
    216.         }
    217.         else if (KEY_PRESS(VK_F4))
    218.         {
    219.             // 减速游戏
    220.             if (ps->food_scores > 2)
    221.             {
    222.                 ps->sleep_time += 30; // 增加延迟时间，减慢游戏速度
    223.                 ps->food_scores -= 2; // 降低食物分值
    224.             }
    225.         }
    226.  
    227.         // 暂停一段时间（根据游戏速度）
    228.         Sleep(ps->sleep_time);
    229.  
    230.         // 蛇的实际移动处理
    231.         SnakeMove(ps);
    232.  
    233.     } while (ps->state == OK); // 若游戏状态为正常，则继续循环
    234.  
    235.     // 当游戏状态不是OK时，意味着游戏已结束或者暂停
    236. }

    Game_end

    1. // 定义函数Game_end，参数为指向蛇结构体的指针ps
    2. void Game_end(psnake ps) 
    3. {
    4.     // 获取蛇头节点的指针
    5.     psnakeNode_Hand cur = ps->Head;
    6.  
    7.     // 设置光标位置到屏幕（24行，12列）
    8.     set_pos(24, 12);
    9.  
    10.     // 根据蛇的状态输出相应的结束信息
    11.     if (ps->state == END) 
    12.     {
    13.         printf("你主动退出游戏\n");
    14.     }
    15.     else if (ps->state == WALL)
    16.     {
    17.         printf("撞到墙了\n");
    18.     }
    19.     else if (ps->state == TOUCH_YOURSELF)
    20.     {
    21.         printf("咬到自己了\n");
    22.     }
    23.  
    24.     // 遍历并释放蛇身所有节点占用的内存资源
    25.     while (cur != NULL) 
    26.     {
    27.         // 创建临时指针指向当前节点
    28.         psnakeNode_Hand del = cur;
    29.         
    30.         // 移动当前节点指针至下一个节点
    31.         cur = cur->next;
    32.  
    33.         // 使用free函数释放del指向的节点内存
    34.         free(del);
    35.     }
    36. }

    好了给个全部代码

    代码

    main.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"text.h"
    3. void text() {
    4. 	int ch = 0;
    5. 	do
    6. 	{
    7. 		system("cls");
    8. 		//创建贪吃蛇
    9. 		Snake snake = { 0 };
    10. 		//初始化
    11. 		Game_start(&snake);
    12. 		//运行
    13. 		Game_run(&snake);
    14. 		//结束
    15. 		Game_end(&snake);
    16. 		set_pos(20,15);
    17. 		printf("再来一局吗？(Y/N):");
    18. 		ch = getchar();
    19. 		while (getchar() != '\n');
    20. 		//getchar();
    21. 		
    22. 	} while (ch == 'Y' || ch =='y');
    23. 	set_pos(0, 27);
    24. }
    25. int main() {
    26. 	//适配本地环境
    27. 	setlocale(LC_ALL, "");
    28. 	text();
    29. 	
    30. 	return 0;
    31. }

    text.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"text.h"
    3.  
    4. //隐藏光标+控制台大小
    5. static void set_window() {
    6. 	system("mode con cols=100 lines=30");
    7. 	system("title 贪吃蛇");
    8. 	//获取句柄
    9. 	HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
    10. 	//定义光标结构体来存储当前句柄的光标信息
    11. 	CONSOLE_CURSOR_INFO cursor_info = { 0 };
    12. 	//获取句柄光标信息
    13. 	GetConsoleCursorInfo(output, &cursor_info);
    14. 	//隐藏光标
    15. 	cursor_info.bVisible = FALSE;
    16. 	SetConsoleCursorInfo(output, &cursor_info);
    17. 	//设置窗口固定大小
    18. 	// 获取当前控制台窗口的句柄
    19. 	HWND consoleWindow = GetConsoleWindow();
    20. 	// 获取当前窗口的样式
    21. 	LONG_PTR windowStyle = GetWindowLongPtr(consoleWindow, GWL_STYLE);
    22. 	// 禁止用户调整窗口大小，移除WS_SIZEBOX、WS_MAXIMIZEBOX、WS_MINIMIZEBOX样式
    23. 	SetWindowLongPtr(consoleWindow, GWL_STYLE, windowStyle & ~(WS_SIZEBOX | WS_MAXIMIZEBOX | WS_MINIMIZEBOX));//移除按钮和边框这样就不能改变大小
    24. 	// 应用新的窗口样式
    25. 	SetWindowPos(consoleWindow, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
    26. }
    27. //定位光标
    28. void set_pos(int x,int y) {
    29.  
    30. 	//给一个坐标
    31. 	COORD pos = { x,y };
    32. 	//获取句柄
    33. 	HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
    34. 	//设置坐标位置
    35. 	SetConsoleCursorPosition(output, pos);//设置控制台光标位置
    36. }
    37. //欢迎开始界面
    38. static void wecometogame() {
    39. 	set_pos(36, 10);
    40. 	wprintf(L"欢迎来到贪吃蛇游戏\n");
    41. 	set_pos(36, 25);
    42. 	system("pause");
    43. 	system("cls");
    44. 	set_pos(40, 10);
    45. 	wprintf(L"游戏介绍\n");
    46. 	set_pos(32, 12);
    47. 	wprintf(L"用↑ ↓ ← →键位控制方向，F3(加速) F4(减速)\n");
    48. 	set_pos(32, 14);
    49. 	wprintf(L"加速可得到更高的分数\n");
    50. 	set_pos(36, 25);
    51. 	system("pause");
    52. 	system("cls");
    53.  
    54. }
    55. //修改控制台字符颜色
    56. static void Textcolor(WORD   wAttributes) {
    57. 	//获取句柄
    58. 	HANDLE output = GetStdHandle(STD_OUTPUT_HANDLE);
    59. 	SetConsoleTextAttribute(output, wAttributes);
    60.  
    61. }
    62. //地图打印
    63. void Drawmap() {
    64. 	Textcolor(FOREGROUND_RED);
    65. 	int i = 0;
    66. 	for (i = 0 ; i < 29; i++)
    67. 	{
    68. 		wprintf(L"%lc", WALL_l);
    69. 	}
    70.  
    71. 	set_pos(0, 26);
    72. 	for (i =0; i < 29; i++)
    73. 	{
    74. 		wprintf(L"%lc", WALL_l);
    75. 	}
    76.  
    77. 	for ( i = 0; i <= 25; i++)
    78. 	{
    79. 		set_pos(0, i);
    80. 		wprintf(L"%lc", WALL_l);
    81. 	}
    82.  
    83. 	for (i = 0; i <= 25; i++)
    84. 	{
    85. 		set_pos(56, i);
    86. 		wprintf(L"%lc", WALL_l);
    87. 	}
    88. }
    89. //创建蛇
    90. void Create_snake(psnake ps) {
    91. 	psnakeNode_Hand cur = NULL;
    92. 	for (int i = 0; i < 3; i++)
    93. 	{
    94. 		//申请节点
    95. 		cur = (psnakeNode_Hand)malloc(sizeof(snakeNode));
    96. 		if (cur == NULL)
    97. 		{
    98. 			perror("Create_snake::malloc");
    99. 			return;
    100. 		}
    101. 		//设置坐标
    102. 		cur->next = NULL;
    103. 		cur->x = pos_x + i * 2;//*2是移动两格，避免重叠(宽字符)
    104. 		cur->y = pos_y;
    105. 		
    106. 		//利用头插将每个节点串在一起
    107. 		if (ps->Head == NULL)
    108. 		{
    109. 			ps->Head = cur;//将节点直接给到head的位置
    110. 		}
    111. 		else
    112. 		{
    113. 			cur->next = ps->Head;
    114. 			ps->Head = cur;
    115. 		}
    116. 	}
    117. 	//打印蛇的身体
    118. 	Textcolor(FOREGROUND_BLUE);
    119. 	cur = ps->Head;
    120. 	while (cur)
    121. 	{
    122. 		set_pos(cur->x, cur->y);
    123. 		wprintf(L"%c", BODY);
    124. 		cur = cur->next;
    125. 	}
    126.  
    127. 	//初始化贪吃蛇的数据
    128. 	ps->dir = RIGHT;
    129. 	ps->food_scores = 10;
    130. 	ps->sleep_time = 200;
    131. 	ps->state = OK;
    132. 	ps->sum = 0;
    133. 	
    134. }
    135. //创建食物
    136. void Create_food(psnake ps) {
    137. 	int x, y;
    138. again:
    139. 	//生成随机坐标
    140. 	do
    141. 	{
    142. 		x = rand() % 53 + 2;
    143. 		y = rand() % 25 + 1;
    144. 	} while (x % 2 != 0);//x坐标必须是2的倍数(偶数)
    145.  
    146. 	//判断x,y的坐标和蛇是否冲突
    147. 	psnakeNode_Hand cur = ps->Head;
    148. 	while (cur)
    149. 	{
    150. 		if ((cur->x == x) && (cur->y == y)) {//将他们的坐标比较
    151. 			goto again;//相等直接重新生成坐标
    152. 		}
    153. 		cur = cur->next;//每一个节点
    154. 	}
    155.  
    156. 	psnakeNode_Hand pfood = (psnakeNode_Hand)malloc(sizeof(snakeNode));
    157. 	if (pfood == NULL)
    158. 	{
    159. 		perror("Create_food::malloc");
    160. 		return;
    161. 	}
    162. 	else
    163. 	{
    164. 		//设置食物颜色
    165. 		Textcolor(FOREGROUND_GREEN);
    166. 		//赋值随机生成的坐标
    167. 		pfood->x = x;
    168. 		pfood->y = y;
    169. 		set_pos(pfood->x, pfood->y);
    170. 		wprintf(L"%lc", FOOD);//打印
    171. 		ps->food = pfood;
    172. 	}
    173. 	
    174.  
    175. }
    176. //初始化
    177. void Game_start(psnake ps) {
    178. 	//时间戳
    179. 	srand((unsigned int)time(NULL));
    180. //--隐藏光标+控制台大小--
    181. 	set_window();
    182. //--打印开始界面+功能介绍--
    183. 	wecometogame();
    184. //--绘制地图--
    185. 	Drawmap();
    186. //--创建蛇--//--设置游戏相关信息--
    187. 	Create_snake(ps);
    188. //--创建食物--
    189. 	Create_food(ps);
    190. }
    191.  
    192. //====================================================
    193. //游戏提示
    194. void Game_prompt() {
    195. 	set_pos(75, 7);
    196. 	wprintf(L"%ls", L"《游戏提示》\n");
    197. 	set_pos(64, 10);
    198. 	wprintf(L"%ls", L"<不能穿墙，不能咬到自己>\n");
    199. 	set_pos(64, 12);
    200. 	wprintf(L"%ls", L"<用↑.↓.←.→分别控制蛇的移动>\n");
    201. 	set_pos(64, 14);
    202. 	wprintf(L"%ls", L"\n");
    203. 	set_pos(64, 16);
    204. 	wprintf(L"%ls", L"\n");
    205. 	set_pos(80, 18);
    206. 	wprintf(L"%ls",L"--普通小青年\n");
    207. 	
    208. }
    209.  
    210. //判断是否遇到食物
    211. int Nextfood(psnakeNode_Hand pn, psnake ps) {
    212. 	
    213. 	return (pn->x == ps->food->x && pn->y == ps->food->y);//都满足就返回1，否者返回0
    214. }
    215.  
    216. //吃掉食物
    217. void Eatfood(psnakeNode_Hand pn, psnake ps) {
    218. 	//头插
    219. 	pn->next = ps->Head;
    220. 	ps->Head = pn;
    221. 	
    222. 	psnakeNode_Hand cur = ps->Head;
    223. 	while (cur)
    224. 	{
    225. 		Textcolor(FOREGROUND_BLUE);
    226. 		set_pos(cur->x, cur->y);
    227. 		wprintf(L"%lc", BODY);
    228. 		cur = cur->next;
    229. 	}
    230. 	ps->sum += ps->food_scores;//吃掉一个食物加分
    231. 	free(ps->food);//销毁食物
    232. 	Create_food(ps);//再次生成一个食物
    233. }
    234.  
    235. //没有食物
    236. void Nofood(psnakeNode_Hand pn, psnake ps) {
    237. 	//psnakeNode_Hand pn -- 下一个节点地址
    238. 	//psnake ps 维护蛇的指针
    239. 	
    240. 	//头插
    241. 	pn->next = ps->Head;
    242. 	ps->Head = pn;
    243.  
    244. 	psnakeNode_Hand cur = ps->Head;
    245. 	
    246. 	//找到倒数第二个节点地址
    247. 	while (cur->next->next)
    248. 	{
    249. 		set_pos(cur->x,cur->y);
    250. 		Textcolor(FOREGROUND_BLUE);
    251. 		wprintf(L"%lc", BODY);
    252. 		cur = cur->next;
    253. 	}
    254. 	Textcolor(FOREGROUND_GREEN);
    255. 	set_pos(cur->next->x,cur->next->y);
    256. 	printf("  ");
    257. 	free(cur->next);
    258. 	cur->next = NULL;
    259.  
    260. }
    261.  
    262. //判断撞墙
    263. void KillByWall(psnake ps) {
    264. 	//判断头部是否和我们的墙的坐标一样
    265. 	if (
    266. 		(ps->Head->x == 0) ||
    267. 		(ps->Head->x == 56)||
    268. 		(ps->Head->y == 0)||
    269. 		(ps->Head->y == 26)
    270. 		)
    271. 	{
    272. 		//游戏状态
    273. 		ps->state = WALL;
    274. 		return 1;
    275.  
    276. 	}
    277. 	return 0;
    278. }
    279.  
    280. //判断撞到自己
    281. void KillBySelf(psnake ps) {
    282. 	//遍历坐标如果有自己子节点的坐标
    283. 	psnakeNode_Hand cur = ps->Head->next;//遍历除了头节点的其他节点所以我们要ps->Head->next,也就是第二个节点开始遍历
    284. 	while (cur)
    285. 	{
    286. 		if (
    287. 			(ps->Head->x == cur->x)
    288. 			&&(ps->Head->y == cur->y)
    289. 			) {
    290.  
    291. 			ps->state = TOUCH_YOURSELF;
    292. 			return 1;
    293. 		}
    294. 		cur = cur->next;
    295. 	}
    296. 	return 0;
    297. }
    298.  
    299. //蛇的移动
    300. void SnakeMove(psnake ps) {
    301. 	//创建下一个位置的节点
    302. 	psnakeNode_Hand pNextNode = (psnakeNode_Hand)malloc(sizeof(snakeNode));
    303. 	if (pNextNode ==NULL)
    304. 	{
    305. 		perror("SnakeMove::malloc");
    306. 		return;
    307. 	}
    308. 	//确定下一个节点的坐标
    309. 	switch (ps->dir) {
    310. 	case UP:
    311. 		pNextNode->x = ps->Head->x;
    312. 		pNextNode->y = ps->Head->y - 1;
    313. 		break;
    314. 	case DOWN:
    315. 		pNextNode->x = ps->Head->x;
    316. 		pNextNode->y = ps->Head->y + 1;
    317. 		break;
    318. 	case LEFT:
    319. 		pNextNode->x = ps->Head->x - 2;
    320. 		pNextNode->y = ps->Head->y;
    321. 		break;
    322. 	case RIGHT:
    323. 		pNextNode->x = ps->Head->x + 2;
    324. 		pNextNode->y = ps->Head->y;
    325. 		break;
    326. 	}
    327. 	//判断我们要走的下一个节点是不是食物
    328. 	if (Nextfood(pNextNode,ps))//写一个判断下一个节点是不是食物
    329. 	{
    330. 		Eatfood(pNextNode,ps);
    331. 	}
    332. 	else
    333. 	{
    334. 		Nofood(pNextNode, ps);
    335. 	}
    336. 	
    337.  
    338. 	//判断撞墙
    339. 	KillByWall(ps);    
    340. 	//判断撞到自己
    341. 	KillBySelf(ps);
    342. }
    343.  
    344. //游戏暂停
    345. void Game_stop() {
    346. 	
    347. 	while (1)
    348. 	{
    349. 		if (KEY_PRESS(VK_SPACE)) {
    350. 			break;
    351. 		}
    352. 		Sleep(200);
    353. 	}
    354. }
    355.  
    356. void Game_run(psnake ps) {
    357. 	//游戏提示
    358. 	Game_prompt();
    359. 	do
    360. 	{
    361. 		//打印分数和食物分值
    362. 		set_pos(64, 9);
    363. 		printf("总分：%2d ", ps->sum);
    364. 		printf("食物分值：%2d\n", ps->food_scores);
    365. 		
    366. 		if (KEY_PRESS(VK_UP) && ps->dir != DOWN) {
    367. 			ps->dir = UP;
    368. 		}
    369. 		else if(KEY_PRESS(VK_DOWN) && ps->dir != UP)
    370. 		{
    371. 			ps->dir = DOWN;
    372. 		}
    373. 		else if (KEY_PRESS(VK_LEFT) && ps->dir != RIGHT)
    374. 		{
    375. 			ps->dir = LEFT;
    376. 		}
    377. 		else if (KEY_PRESS(VK_RIGHT) && ps->dir != LEFT)
    378. 		{
    379. 			ps->dir = RIGHT;
    380. 		}
    381. 		else if (KEY_PRESS(VK_SPACE) )
    382. 		{
    383. 			//游戏暂停
    384. 			Game_stop();
    385. 		}
    386. 		else if (KEY_PRESS(VK_ESCAPE) )
    387. 		{
    388. 			//退出游戏
    389. 			ps->state = END;
    390. 		}
    391. 		else if (KEY_PRESS(VK_F3))
    392. 		{
    393. 			//加速
    394. 			if (ps->sleep_time>=80) {
    395. 				ps->sleep_time -= 30;//时间越短数度越快
    396. 				ps->food_scores += 2;
    397. 			}
    398. 		}
    399. 		else if (KEY_PRESS(VK_F4))
    400. 		{
    401. 			//减速
    402. 			if (ps->food_scores>2) {
    403. 				ps->sleep_time += 30;//时间越大数度越慢
    404. 				ps->food_scores -= 2;
    405. 			}
    406. 		}
    407.  
    408. 		Sleep(ps->sleep_time);
    409. 		//蛇的移动	
    410. 		SnakeMove(ps);
    411.  
    412. 	} while (ps->state == OK);//游戏状态
    413. }
    414.  
    415. //结束游戏
    416. void Game_end(psnake ps) {
    417. 	psnakeNode_Hand cur = ps->Head;
    418.  
    419. 	set_pos(24,12);
    420. 	if (ps->state == END) {
    421. 		printf("你主动退出游戏\n");
    422. 	}
    423. 	else if( ps->state == WALL)
    424. 	{
    425. 		printf("撞到墙了\n");
    426. 	}
    427. 	else if(ps->state == TOUCH_YOURSELF)
    428. 	{
    429. 		printf("咬到自己了\n");
    430. 	}
    431.  
    432. 	//释放蛇身的节点
    433. 	while (cur)
    434. 	{
    435. 		psnakeNode_Hand del = cur;
    436. 		cur = cur->next;
    437. 		free(del);
    438. 	}
    439.  
    440. }

    text.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9.  
    10. #define WALL_l L'墙'
    11. //#define BODY L'头'
    12. #define BODY L'●'
    13. //#define FOOD L'头'
    14. #define FOOD L'▲'
    15. #define pos_x 24
    16. #define pos_y 5
    17.  
    18. #define KEY_PRESS(vk)  ((GetAsyncKeyState(vk)&1)?1:0)
    19. //蛇的方向
    20. enum Direction
    21. {
    22. 	UP = 1,//向上
    23. 	DOWN,//向下
    24. 	LEFT,//向左
    25. 	RIGHT//向右
    26. };
    27.  
    28. //游戏状态
    29. enum Game_State
    30. {
    31. 	OK,//正常
    32. 	WALL,//撞墙
    33. 	TOUCH_YOURSELF,//触碰到自己
    34. 	END//结束
    35. };
    36.  
    37. //创建蛇身节点类型
    38. typedef struct snakeNode {
    39. 	//坐标
    40. 	int x;
    41. 	int y;
    42. 	//指向下一个节点的指针
    43. 	struct snakeNode* next;
    44. }snakeNode,*psnakeNode_Hand;
    45.  
    46.  
    47. //贪吃蛇 
    48. typedef struct Snake
    49. {
    50. 	psnakeNode_Hand Head;//指向蛇头的指针
    51. 	psnakeNode_Hand food;//指向食物的指针
    52. 	enum Direction dir;//蛇的方向
    53. 	enum Game_State state;//游戏状态
    54. 	int food_scores;//一个食物的分数
    55. 	int sum;//总分
    56. 	int sleep_time;//蛇的速度:休息时间(时间越短，速度越快; 时间越长，速度越慢)
    57. }Snake, * psnake;
    58.  
    59.  
    60. //初始化
    61. void Game_start(psnake ps);
    62. //定位(x,y)
    63. void set_pos(int x, int y);
    64.  
    65. //隐藏光标+控制台大小
    66. static void set_window();
    67.  
    68. //欢迎开始界面
    69. static void wecometogame();
    70.  
    71. //地图打印
    72. void Drawmap();
    73.  
    74. //创建蛇
    75. void Create_snake(psnake ps);
    76.  
    77. //创建食物
    78. void Create_food(psnake ps);
    79.  
    80. //==============================================
    81.  
    82.  
    83. //游戏运行
    84. void Game_run(psnake ps);
    85.  
    86. //蛇的移动
    87. void SnakeMove(psnake ps);
    88.  
    89. //判断是否遇到食物
    90. int Nextfood(psnakeNode_Hand pn, psnake ps);
    91.  
    92. //吃掉食物
    93. void Eatfood(psnakeNode_Hand pn, psnake ps);
    94.  
    95. //没有食物
    96. void Nofood(psnakeNode_Hand pn,psnake ps);
    97.  
    98.  
    99. //判断撞墙
    100. void KillByWall(psnake ps);
    101. //判断撞到自己
    102. void KillBySelf(psnake ps);
    103.  
    104. //==============================================
    105.  
    106. //结束游戏
    107. void Game_end(psnake ps);

  • 相关阅读:
    扯下@EventListener这个注解的神秘面纱。
    git总结
    河北吉力宝以步力宝健康鞋引发的全新生活生态商
    用全域安全防范美国NSA对西工大的网络攻击
    架构学习之通用定时器
    毕业设计之基于Spring+SpringMVC+Mybatis分布式敏捷开发系统架构
    Linux命令
    我们能做出来数据库吗？
    电脑怎么录制视频，录制的视频怎么剪辑？
    【slowfast 损失函数改进】深度学习网络通用改进方案：slowfast的损失函数（使用focal loss解决不平衡数据）改进
  • 原文地址：https://blog.csdn.net/2302_78381559/article/details/138156386