• C语言实现双人贪吃蛇项目（基于控制台界面）

    一.贪吃蛇

    贪吃蛇是一款简单而富有乐趣的游戏，它的规则易于理解，但挑战性也很高。它已经成为经典的游戏之一，并且在不同的平台上一直受到人们的喜爱和回忆。

    二.贪吃蛇的功能

    1. 游戏控制：玩家可以使用键盘输入设备来控制蛇的移动方向。

    2. 蛇的移动：蛇头会根据玩家的输入方向进行移动，而蛇身会随着蛇头的移动而延长，形成一条越来越长的蛇。

    3. 食物生成：游戏界面会随机生成食物，玩家控制的蛇头需要吃掉这些食物，每吃到一块食物，蛇的身体就会增长一节。

    4. 碰撞检测：游戏会检测蛇头是否与自身的身体或者墙壁碰撞，如果碰撞则游戏结束。

    5. 分数计算：游戏会记录玩家吃到的食物数量，并根据数量进行得分计算，通常吃到的食物越多，得分越高。

    6. 难度递增：随着蛇身越来越长，游戏的难度也会逐渐增加，因为玩家需要更小心地避免碰撞

    7. 双人游戏：贪吃蛇支持双人游玩，两位玩家可以相互竞争。

    三.贪吃蛇项目的实现

    1.游戏前的准备

    1.1游戏的状态

    • enum state 枚举类型定义了游戏的状态，包括以下常量：
      • ok：正常状态，表示游戏进行中。
      • by_wall：撞墙状态，表示蛇撞到了地图的边界。
      • by_body：撞到蛇的身体状态，表示蛇头撞到了蛇身。
      • by_self：蛇咬到自己状态，表示蛇头咬到了自己的身体。
      • by_end：游戏结束状态。
      • by_headpush：蛇头相互碰撞状态，表示两个玩家的蛇头相互碰撞。
    1. enum state
    2. {
    3.     ok = 1,         // 游戏状态：正常状态
    4.     by_wall,        // 游戏状态：撞墙
    5.     by_body,        // 游戏状态：撞到蛇的身体
    6.     by_self,        // 游戏状态：蛇咬到自己
    7.     by_end,         // 游戏状态：游戏结束
    8.     by_headpush     // 游戏状态：蛇头相互碰撞
    9. };

    1.2蛇的移动方向

    • enum direction 枚举类型定义了蛇的移动方向，包括以下常量：
      • up：表示向上移动。
      • down：表示向下移动。
      • left：表示向左移动。
      • right：表示向右移动。
    1. enum direction
    2. {
    3.     up = 1,         // 方向：上
    4.     down,           // 方向：下
    5.     left,           // 方向：左
    6.     right           // 方向：右
    7. };

    1.3蛇的节点

    • struct SnakeNode 结构体用于表示蛇的一个节点，包括以下成员：
      • x：节点的横坐标。
      • y：节点的纵坐标。
      • next：指向下一个节点的指针。
    1. typedef struct SnakeNode
    2. {
    3.     int x;                  // 蛇节点的横坐标
    4.     int y;                  // 蛇节点的纵坐标
    5.     struct SnakeNode* next; // 指向下一个蛇节点的指针
    6. } SnakeNode, * pSnakeNode;

    1.4食物的位置

    • struct Food 结构体用于表示食物的位置，包括以下成员：
      • x：食物的横坐标。
      • y：食物的纵坐标。
    1. typedef struct Food
    2. {
    3.     int x;                  // 食物的横坐标
    4.     int y;                  // 食物的纵坐标
    5. } Food, * pFood;

    1.5整个贪吃蛇游戏

    • struct Snake 结构体用于表示蛇，包括以下成员：
      • _snake：蛇的头节点指针。
      • _food：食物指针。
      • _score：蛇的得分。
      • dir：蛇的移动方向。
      • sta：当前游戏状态。
      • _weight：奖励。
      • _sleeptime：游戏循环每次暂停的时间间隔。
    1. typedef struct Snake
    2. {
    3.     pSnakeNode _snake;      // 蛇的头节点指针
    4.     pFood _food;            // 食物指针
    5.     int _score;             // 蛇的得分
    6.     enum direction dir;     // 蛇的移动方向
    7.     enum state sta;         // 当前游戏状态
    8.     int _weight;            // 奖励
    9.     int _sleeptime;         // 游戏循环每次暂停的时间间隔
    10. } Snake, * pSnake;

    2.游戏开始

    2.1本地化设置

    使用setlocale函数设置本地化环境为当前系统默认的环境。因为环境的差异，导致我们的中文的宽字符无法被识别，所以要本地化设置。

    1. int main()
    2. {
    3.     setlocale(LC_ALL, "");  // 设置本地化环境为当前系统默认的环境
    4.  
    5.     test();  // 调用test函数进行测试
    6.  
    7.     return 0;  // 返回0表示程序正常结束
    8. }

    2.2 实现贪吃蛇的基本流程

    test函数中，通过srand函数将当前时间作为随机数种子。然后使用do-while循环进行游戏的测试和循环控制。在循环内部，首先使用malloc动态分配了两个Snake结构体的内存，并将其指针赋值给snake1和snake2。接着调用gamestart函数开始游戏，传入snake1和snake2作为参数；然后调用gamerun函数进行游戏运行，同样传入snake1和snake2作为参数；最后调用gameend函数结束游戏并释放内存，同样传入snake1和snake2作为参数。之后，使用system("cls")清空控制台屏幕，然后在指定位置打印提示信息。接下来，使用getchar函数获取一个字符并赋值给变量ch，再使用getchar读取多余的换行符。最后，判断ch是否为字符'y'或'Y'，如果是则继续进行下一轮游戏。

    1. #include "snake.h"  // 引入自定义的头文件snake.h
    2.  
    3. void test()
    4. {
    5.     srand((unsigned int)time(NULL));  // 使用当前时间作为随机数种子
    6.  
    7.     int ch;
    8.     do {
    9.         pSnake snake1 = (pSnake)malloc(sizeof(Snake));  // 动态分配一个Snake结构体的内存，并将其指针赋给snake1
    10.         pSnake snake2 = (pSnake)malloc(sizeof(Snake));  // 动态分配一个Snake结构体的内存，并将其指针赋给snake2
    11.  
    12.         gamestart(snake1, snake2);  // 调用gamestart函数开始游戏，传入snake1和snake2作为参数
    13.         gamerun(snake1, snake2);    // 调用gamerun函数进行游戏运行，传入snake1和snake2作为参数
    14.         gameend(snake1, snake2);    // 调用gameend函数结束游戏，释放内存，传入snake1和snake2作为参数
    15.  
    16.         system("cls");  // 清空控制台屏幕
    17.  
    18.         setpos(46, 15);  // 设置光标位置为(46, 15)
    19.         printf("选择Y/N");
    20.  
    21.         setpos(50, 16);  // 设置光标位置为(50, 16)
    22.         ch = getchar();  // 从标准输入中获取一个字符，赋值给ch
    23.         getchar();       // 读取多余的换行符
    24.  
    25.     } while (ch == 'y' || ch == 'Y');  // 如果输入的字符是'y'或'Y'，则继续进行下一轮游戏
    26.  
    27. }

    2.3设置光标

    该函数接受两个整型参数x和y，分别表示光标的横坐标和纵坐标。在函数内部，首先调用GetStdHandle函数获取标准输出句柄，该句柄用于操作控制台窗口。然后创建一个COORD结构体变量coord，并将x赋值给coord.X，将y赋值给coord.Y，即设置光标的位置。最后，调用SetConsoleCursorPosition函数将控制台光标位置设置为指定的坐标。这样，在调用setpos函数时，控制台光标会移动到指定的位置。

    1. void setpos(int x, int y)
    2. {
    3.     HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);  // 获取标准输出句柄
    4.     COORD coord;
    5.     coord.X = x;  // 设置光标的横坐标为x
    6.     coord.Y = y;  // 设置光标的纵坐标为y
    7.     SetConsoleCursorPosition(handle, coord);  // 设置控制台光标位置为指定的坐标
    8. }

     2.4游戏的初始化

    该函数接受两个参数，snake1和snake2，分别表示两条蛇的指针。函数开始使用断言assert，确保snake1和snake2不为NULL，以保证后续操作的正确性。然后依次调用以下函数：

    • welcome：显示游戏欢迎信息，可能是在控制台输出一些欢迎文本。
    • creatmap：创建游戏地图，可能是在控制台上绘制一个游戏地图的界面。
    • initsnake：初始化蛇的身体，可能是将蛇的初始位置和长度设置为默认值。
    • creatsnake：生成两条蛇的初始位置，可能是将两条蛇放置在地图的指定位置。
    • creatfood：生成食物的位置，以供两条蛇争夺，可能是将食物随机放置在地图的空闲位置。
    • gameinfo：显示游戏信息，可能是在控制台上显示当前游戏的状态、得分等信息。
    1. void gamestart(pSnake snake1, pSnake snake2)
    2. {
    3.     assert(snake1 && snake2);  // 使用断言确保snake1和snake2不为NULL
    4.  
    5.     welcome();                // 调用welcome函数，显示游戏欢迎信息
    6.     creatmap();               // 调用creatmap函数，创建游戏地图
    7.     initsnake(snake1);        // 调用initsnake函数，初始化snake1蛇身
    8.     initsnake(snake2);        // 调用initsnake函数，初始化snake2蛇身
    9.     creatsnake(snake1, snake2);// 调用creatsnake函数，生成snake1和snake2的初始位置
    10.     creatfood(snake1, snake2);// 调用creatfood函数，生成食物的位置，以供snake1和snake2争夺
    11.     creatfood(snake2, snake1);// 调用creatfood函数，生成食物的位置，以供snake2和snake1争夺
    12.     gameinfo(snake1, snake2); // 调用gameinfo函数，显示游戏信息
    13. }
    2.4.1欢迎信息

    首先调用system函数设置控制台窗口的大小为100列，30行，使用命令mode con cols=100 lines=30实现。然后调用system函数设置控制台窗口的标题为"贪吃蛇"，使用命令title 贪吃蛇实现。接下来，获取标准输出句柄，并获取控制台光标信息。将光标的可见性设置为false，即不可见，然后再将修改后的光标信息设置回控制台。然后使用setpos函数设置光标位置为(40, 10)，在该位置打印欢迎信息。接着，使用setpos函数设置光标位置为(40, 20)，调用system("pause")暂停程序的执行，等待用户按下任意键。然后使用system("cls")清空控制台屏幕。接下来，使用setpos函数设置光标位置为(38, 10)，然后依次打印游戏规则的内容。再次使用setpos函数设置光标位置为(40, 20)，使用system("pause")暂停程序的执行，等待用户按下任意键。最后，使用system("cls")清空控制台屏幕。

    1. void welcome()
    2. {
    3.     system("mode con cols=100 lines=30");  // 设置控制台窗口的大小为100列，30行
    4.     system("title 贪吃蛇");                // 设置控制台窗口的标题为"贪吃蛇"
    5.  
    6.     HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);  // 获取标准输出句柄
    7.     CONSOLE_CURSOR_INFO cursor;
    8.     GetConsoleCursorInfo(handle, &cursor);  // 获取控制台光标信息
    9.     cursor.bVisible = false;                // 将光标设置为不可见
    10.     SetConsoleCursorInfo(handle, &cursor);  // 设置控制台光标信息
    11.  
    12.     setpos(40, 10);                          // 设置光标位置为(40, 10)
    13.     printf("欢迎来到贪吃蛇游戏！");
    14.  
    15.     setpos(40, 20);                          // 设置光标位置为(40, 20)
    16.     system("pause");                         // 暂停程序的执行，等待用户按下任意键
    17.  
    18.     system("cls");                           // 清空控制台屏幕
    19.  
    20.     setpos(38, 10);                          // 设置光标位置为(38, 10)
    21.     printf("游戏规则如下:\n");
    22.     setpos(38, 11);                          // 设置光标位置为(38, 11)
    23.     printf("1.用← → ↑ ↓或a  d  w  s进行操作");
    24.     setpos(38, 12);                          // 设置光标位置为(38, 12)
    25.     printf("2.用f1进行加速，用进行f2减速");
    26.     setpos(38, 13);                          // 设置光标位置为(38, 13)
    27.     printf("3.空格键暂停游戏");
    28.     setpos(38, 14);                          // 设置光标位置为(38, 14)
    29.     printf("4.esc退出游戏");
    30.  
    31.     setpos(40, 20);                          // 设置光标位置为(40, 20)
    32.     system("pause");                         // 暂停程序的执行，等待用户按下任意键
    33.  
    34.     system("cls");                           // 清空控制台屏幕
    35. }
    2.4.2创建地图

    首先使用setpos函数将光标位置设置为(0, 0)。然后使用循环，每次递增2，打印墙的字符。接着，使用setpos函数将光标位置设置为(0, 25)，再次使用循环，每次递增2，打印墙的字符。然后使用循环，从1到24，每次递增1，使用setpos函数将光标位置设置为(0, i)，打印墙的字符。最后，使用循环，从1到24，每次递增1，使用setpos函数将光标位置设置为(56, i)，打印墙的字符。这样，通过在控制台上打印一系列墙的字符，创建了游戏地图的界面。

    1. void creatmap()
    2. {
    3.     setpos(0, 0);
    4.     for (int i = 0; i < 58; i += 2)
    5.     {
    6.         wprintf(L"%c", Wall);
    7.     }
    8.     setpos(0, 25);
    9.     for (int i = 0; i < 58; i += 2)
    10.     {
    11.         wprintf(L"%c", Wall);
    12.     }
    13.     for (int i = 1; i < 25; i++)
    14.     {
    15.         setpos(0, i);
    16.         wprintf(L"%c", Wall);
    17.     }
    18.     for (int i = 1; i < 25; i++)
    19.     {
    20.         setpos(56, i);
    21.         wprintf(L"%c", Wall);
    22.     }
    23. }
    2.4.3初始化整个贪吃蛇游戏

    在函数内部，将蛇的链表指针_snake和食物的指针_food都设置为NULL，表示蛇链表和食物尚未创建。将分数_score初始化为0，表示初始分数为0。将蛇的初始移动方向dir设置为left，表示初始方向为向左移动。将蛇的状态sta设置为ok，表示蛇的初始状态为正常状态。将蛇的初始长度_weight设置为10，表示蛇的初始长度为10。将蛇的初始移动速度_sleeptime设置为200毫秒，表示蛇的初始移动速度为每200毫秒移动一次。通过这些初始化操作，为蛇游戏的相关数据设置了初始值，以便游戏开始时使用。

    1. void initsnake(pSnake snake)
    2. {
    3.     snake->_snake = NULL;    // 将蛇的链表指针设置为NULL
    4.     snake->_food = NULL;     // 将食物的指针设置为NULL
    5.     snake->_score = 0;       // 将分数初始化为0
    6.     snake->dir = left;       // 将蛇的初始移动方向设置为左侧
    7.     snake->sta = ok;         // 将蛇的初始状态设置为正常状态
    8.     snake->_weight = 10;     // 将蛇的初始长度设置为10
    9.     snake->_sleeptime = 200; // 将蛇的初始移动速度设置为200毫秒
    10. }
    2.4.4创建蛇的初始状态

    首先创建蛇1的头结点p1，并将其位置设置为(24, 5)。然后将蛇1的链表指针_snake指向头结点p1，表示蛇1的链表的起始节点为头结点。然后在控制台上打印头结点的字符表示。接着使用循环，从1到4，每次递增1，创建蛇1的身体节点j，并将其位置设置为(24 + i * 2, 5)。然后在控制台上打印身体节点的字符表示。将头结点的next指针指向身体节点j，表示蛇1的头结点连接到身体节点。然后更新头结点为身体节点，为下一个身体节点的创建做准备。接下来，按照类似的方式，创建蛇2的头结点和身体节点。蛇2的头结点位置为(24, 22)，蛇2的身体节点位置从(26, 22)开始递增。在控制台上打印蛇2的头结点和身体节点的字符表示。通过这些操作，创建了两条蛇的初始状态，每条蛇由一个头结点和四个身体节点组成。

    1. void creatsnake(pSnake snake1, pSnake snake2)
    2. {
    3.     pSnakeNode p1 = (pSnakeNode)malloc(sizeof(SnakeNode)); // 创建蛇1的头结点
    4.     assert(p1);
    5.     p1->next = NULL;
    6.     p1->x = 24;
    7.     p1->y = 5;
    8.     snake1->_snake = p1;
    9.     setpos(p1->x, p1->y);
    10.     wprintf(L"%c", Body);
    11.     for (int i = 1; i < 5; i++)
    12.     {
    13.         pSnakeNode j = (pSnakeNode)malloc(sizeof(SnakeNode)); // 创建蛇1的身体节点
    14.         assert(j);
    15.         j->x = 24 + i * 2;
    16.         j->y = 5;
    17.         j->next = NULL;
    18.         setpos(j->x, j->y);
    19.         wprintf(L"%c", Body);
    20.         p1->next = j;
    21.         p1 = p1->next;
    22.     }
    23.  
    24.     pSnakeNode p2 = (pSnakeNode)malloc(sizeof(SnakeNode)); // 创建蛇2的头结点
    25.     assert(p2);
    26.     p2->next = NULL;
    27.     p2->x = 24;
    28.     p2->y = 22;
    29.     snake2->_snake = p2;
    30.     setpos(p2->x, p2->y);
    31.     wprintf(L"%c", Body);
    32.     for (int i = 1; i < 5; i++)
    33.     {
    34.         pSnakeNode j = (pSnakeNode)malloc(sizeof(SnakeNode)); // 创建蛇2的身体节点
    35.         assert(j);
    36.         j->x = 24 + i * 2;
    37.         j->y = 22;
    38.         j->next = NULL;
    39.         setpos(j->x, j->y);
    40.         wprintf(L"%c", Body);
    41.         p2->next = j;
    42.         p2 = p2->next;
    43.     }
    44. }
    2.4.5创建食物（较重点）

    首先，我们分配内存以存储食物结构，并使用assert函数确保内存分配成功。进入无限循环，用于生成随机坐标。x的取值范围为2到54（包含2和54），y的取值范围为1到25（包含1和25）。我们希望食物的x坐标为偶数，因此我们检查x是否可以被2整除。如果不满足这个条件，则继续生成随机坐标，直到满足条件为止。在满足条件的情况下，我们遍历蛇1和蛇2的身体节点，检查食物坐标是否与任何节点的坐标冲突。如果存在冲突，我们将conflict标志设置为1。此外，我们还检查食物坐标是否与蛇2的当前食物坐标冲突。如果存在冲突，也将conflict标志设置为1。如果没有冲突，则跳出循环。设置食物的坐标为生成的随机坐标。在游戏地图上显示食物，通过setpos函数将光标移动到正确的位置，并使用wprintf函数打印食物字符。最后，将食物分配给蛇1的food1指针，完成食物的放置。

    1. // 创建食物并放置在游戏地图上
    2. void creatfood(pSnake snake1, pSnake snake2) {
    3. 	int x, y;
    4.  
    5. 	// 分配内存以存储食物结构
    6. 	pFood food1 = (pFood)malloc(sizeof(Food));
    7. 	assert(food1 != NULL);
    8.  
    9. 	while (1) {
    10. 		// 生成随机坐标
    11. 		x = rand() % 53 + 2;
    12. 		y = rand() % 24 + 1;
    13.  
    14. 		// 确保食物的 x 坐标为偶数
    15. 		if (x % 2 == 0) {
    16. 			pSnakeNode p1 = snake1->_snake;
    17. 			pSnakeNode p2 = snake2->_snake;
    18. 			int conflict = 0;
    19.  
    20. 			// 检查食物坐标是否与蛇1的身体节点冲突
    21. 			while (p1 != NULL) {
    22. 				if (p1->x == x && p1->y == y) {
    23. 					conflict = 1;
    24. 					break;
    25. 				}
    26. 				p1 = p1->next;
    27. 			}
    28.  
    29. 			// 检查食物坐标是否与蛇2的身体节点冲突
    30. 			while (!conflict && p2 != NULL) {
    31. 				if (p2->x == x && p2->y == y) {
    32. 					conflict = 1;
    33. 					break;
    34. 				}
    35. 				p2 = p2->next;
    36. 			}
    37.  
    38. 			// 检查食物坐标是否与蛇2的当前食物坐标冲突
    39. 			if (!conflict && snake2->_food != NULL && snake2->_food->x == x && snake2->_food->y == y) {
    40. 				conflict = 1;
    41. 			}
    42.  
    43. 			// 如果没有冲突，则跳出循环
    44. 			if (!conflict) {
    45. 				break;
    46. 			}
    47. 		}
    48. 	}
    49.  
    50. 	// 设置食物的坐标
    51. 	food1->x = x;
    52. 	food1->y = y;
    53.  
    54. 	// 在屏幕上显示食物
    55. 	setpos(food1->x, food1->y);
    56. 	wprintf(L"%c", FOOD);
    57.  
    58. 	// 将食物分配给蛇1
    59. 	snake1->_food = food1;
    60. }
    2.4.6显示游戏的规则

    该函数接受两个指向Snake结构体的指针snake1和snake2作为参数。在函数内部，使用setpos函数将光标定位到相应的位置，然后使用printf函数将相关信息打印在控制台上。首先打印蛇1的分数和奖励信息，分别位于(70, 6)和(70, 7)的位置。接着打印蛇2的分数和奖励信息，分别位于(70, 10)和(70, 11)的位置。然后打印游戏规则，分别位于(62, 15)到(62, 20)的位置。通过这些操作，在控制台上显示了游戏的相关信息和规则。

    1. void gameinfo(pSnake snake1, pSnake snake2)
    2. {
    3.     setpos(70, 6);
    4.     printf("分数:%d ", snake1->_score); // 打印蛇1的分数
    5.     setpos(70, 7);
    6.     printf("奖励:%d ", snake1->_weight); // 打印蛇1的奖励
    7.     setpos(70, 10);
    8.     printf("分数:%d ", snake2->_score); // 打印蛇2的分数
    9.     setpos(70, 11);
    10.     printf("奖励:%d ", snake2->_weight); // 打印蛇2的奖励
    11.     setpos(62, 15);
    12.     printf("游戏规则如下:");
    13.     setpos(62, 16);
    14.     printf("1.用← → ↑ ↓或a  d  w  s进行操作");
    15.     setpos(62, 17);
    16.     printf("2.用f1进行加速，用进行f2减速");
    17.     setpos(62, 18);
    18.     printf("3.空格键暂停游戏");
    19.     setpos(62, 19);
    20.     printf("4.esc退出游戏");
    21.     setpos(62, 20);
    22.     printf("5.咬到蛇身或撞墙都会死");
    23. }

    3.游戏进行中

    3.1控制游戏的运行逻辑

    该函数接受两个指向Snake结构体的指针snake1和snake2作为参数。在函数内部，使用do-while循环来控制游戏的逻辑。在循环内部，根据按键的状态来判断玩家的操作，例如W、S、A、D键用于控制蛇1的移动方向，空格键用于暂停游戏，ESC键用于结束游戏。同时，F1和F2键用于加速和减速蛇的移动速度，上下左右箭头键用于控制蛇2的移动方向。接着调用snakemove函数来移动蛇1和蛇2的位置。然后更新显示蛇1和蛇2的分数和奖励信息。最后根据蛇1的睡眠时间进行延时，然后继续下一轮循环，直到蛇1或蛇2的状态不再为正常（游戏结束）。

    1. void gamerun(pSnake snake1, pSnake snake2)
    2. {
    3.     do {
    4.         if (Key_state(0x57) && snake1->dir != down)
    5.         {
    6.             snake1->dir = up; // 如果按下W键且蛇1不朝下移动，则将蛇1的方向设置为上
    7.         }
    8.         else if (Key_state(0x53) && snake1->dir != up)
    9.         {
    10.             snake1->dir = down; // 如果按下S键且蛇1不朝上移动，则将蛇1的方向设置为下
    11.         }
    12.         else if (Key_state(0x41) && snake1->dir != right)
    13.         {
    14.             snake1->dir = left; // 如果按下A键且蛇1不朝右移动，则将蛇1的方向设置为左
    15.         }
    16.         else if (Key_state(0x44) && snake1->dir != left)
    17.         {
    18.             snake1->dir = right; // 如果按下D键且蛇1不朝左移动，则将蛇1的方向设置为右
    19.         }
    20.         else if (Key_state(VK_SPACE))
    21.         {
    22.             pause(); // 如果按下空格键，则暂停游戏
    23.         }
    24.         else if (Key_state(VK_ESCAPE))
    25.         {
    26.             snake1->sta = by_end; // 如果按下ESC键，则将蛇1的状态设置为结束
    27.             snake2->sta = by_end; // 将蛇2的状态设置为结束
    28.         }
    29.         else if (Key_state(VK_F1))
    30.         {
    31.             if (snake1->_sleeptime >= 80)
    32.             {
    33.                 (snake1->_sleeptime) -= 20; // 如果按下F1键且蛇1的睡眠时间大于等于80，则减少蛇1的睡眠时间
    34.                 (snake1->_weight) += 2; // 增加蛇1的奖励
    35.             }
    36.             setpos(70, 7);
    37.             printf("奖励:%d ", snake1->_weight); // 更新蛇1的奖励显示
    38.             if (snake2->_sleeptime >= 80)
    39.             {
    40.                 (snake2->_sleeptime) -= 20; // 如果按下F1键且蛇2的睡眠时间大于等于80，则减少蛇2的睡眠时间
    41.                 (snake2->_weight) += 2; // 增加蛇2的奖励
    42.             }
    43.             setpos(70, 11);
    44.             printf("奖励:%d ", snake2->_weight); // 更新蛇2的奖励显示
    45.         }
    46.         else if (Key_state(VK_F2))
    47.         {
    48.             if (snake1->_sleeptime <= 280)
    49.             {
    50.                 (snake1->_sleeptime) += 20; // 如果按下F2键且蛇1的睡眠时间小于等于280，则增加蛇1的睡眠时间
    51.                 (snake1->_weight) -= 2; // 减少蛇1的奖励
    52.             }
    53.             setpos(70, 7);
    54.             printf("奖励:%d ", snake1->_weight); // 更新蛇1的奖励显示
    55.             if (snake2->_sleeptime <= 280)
    56.             {
    57.                 (snake2->_sleeptime) += 20; // 如果按下F2键且蛇2的睡眠时间小于等于280，则增加蛇2的睡眠时间
    58.                 (snake2->_weight) -= 2; // 减少蛇2的奖励
    59.             }
    60.             setpos(70, 11);
    61.             printf("奖励:%d ", snake2->_weight); // 更新蛇2的奖励显示
    62.         }
    63.         else if (Key_state(VK_UP) && snake2->dir != down)
    64.         {
    65.             snake2->dir = up; // 如果按下上箭头键且蛇2不朝下移动，则将蛇2的方向设置为上
    66.         }
    67.         else if (Key_state(VK_DOWN) && snake2续：
    68.  
    69.         .dir != up)
    70.         {
    71.             snake2->dir = down; // 如果按下下箭头键且蛇2不朝上移动，则将蛇2的方向设置为下
    72.         }
    73.         else if (Key_state(VK_LEFT) && snake2->dir != right)
    74.         {
    75.             snake2->dir = left; // 如果按下左箭头键且蛇2不朝右移动，则将蛇2的方向设置为左
    76.         }
    77.         else if (Key_state(VK_RIGHT) && snake2->dir != left)
    78.         {
    79.             snake2->dir = right; // 如果按下右箭头键且蛇2不朝左移动，则将蛇2的方向设置为右
    80.         }
    81.         snakemove(snake1, snake2); // 移动蛇1
    82.         snakemove(snake2, snake1); // 移动蛇2
    83.         setpos(70, 6);
    84.         printf("分数:%d ", snake1->_score); // 更新蛇1的分数显示
    85.         setpos(70, 7);
    86.         printf("奖励:%d ", snake1->_weight); // 更新蛇1的奖励显示
    87.         setpos(70, 10);
    88.         printf("分数:%d ", snake2->_score); // 更新蛇2的分数显示
    89.         setpos(70, 11);
    90.         printf("奖励:%d ", snake2->_weight); // 更新蛇2的奖励显示
    91.         Sleep(snake1->_sleeptime); // 根据蛇1的睡眠时间进行延时
    92.     } while (snake1->sta == ok && snake2->sta == ok); // 当蛇1和蛇2的状态都为正常时继续循环
    93. }

    3.2 游戏的暂停

    在函数内部，使用一个无限循环while (1)来检测空格键的状态。如果空格键被按下（Key_state(VK_SPACE)返回true），则函数使用return语句立即返回，从而退出循环并继续游戏的执行。如果空格键未被按下，函数会通过Sleep(1000)函数让程序休眠1秒钟，然后再次检测空格键的状态。这样循环会一直执行，直到空格键被按下并函数返回。这样就实现了游戏的暂停功能。

    1. void pause()
    2. {
    3.     while (1)
    4.     {
    5.         if (Key_state(VK_SPACE))
    6.             return;
    7.         Sleep(1000);
    8.     }
    9. }

    3.3 蛇的移动及一系列的判断（重点）

    • 创建一个新的蛇头节点 i，并将其插入到蛇身链表的头部。
    • 根据贪吃蛇的方向更新蛇头的位置。
    • 如果贪吃蛇吃到了食物，增加贪吃蛇的得分并生成新的食物。
    • 如果贪吃蛇没有吃到食物，移动蛇尾，即删除蛇身链表的最后一个节点，并在屏幕上擦除该节点的位置。
    • 检查贪吃蛇是否撞墙，如果是则设置状态为 by_wall 并返回。
    • 检查贪吃蛇是否自噬，即蛇头是否碰到了蛇身的其他部分。
    • 绘制贪吃蛇的身体，即在屏幕上打印出每个节点的位置。
    1. void snakemove(pSnake snake1, pSnake snake2)
    2. {
    3.     pSnakeNode i = (pSnakeNode)malloc(sizeof(SnakeNode));  // 分配一个新的SnakeNode节点，并将其赋值给变量i
    4.     assert(i);  // 检查内存分配是否成功
    5.  
    6.     i->next = snake1->_snake;  // 将i节点的下一个节点指向snake1的当前头节点
    7.  
    8.     // 根据snake1的方向更新i节点的坐标
    9.     if (snake1->dir == up)
    10.     {
    11.         i->x = snake1->_snake->x;
    12.         i->y = snake1->_snake->y - 1;
    13.     }
    14.     else if (snake1->dir == down)
    15.     {
    16.         i->x = snake1->_snake->x;
    17.         i->y = snake1->_snake->y + 1;
    18.     }
    19.     else if (snake1->dir == left)
    20.     {
    21.         i->x = snake1->_snake->x - 2;
    22.         i->y = snake1->_snake->y;
    23.     }
    24.     else if (snake1->dir == right)
    25.     {
    26.         i->x = snake1->_snake->x + 2;
    27.         i->y = snake1->_snake->y;
    28.     }
    29.     else if (snake1->sta == by_end)
    30.     {
    31.         return;  // 如果snake1的状态为by_end，则直接返回
    32.     }
    33.  
    34.     snake1->_snake = i;  // 更新snake1的头节点为i
    35.  
    36.     pSnakeNode p = snake1->_snake;
    37.  
    38.     // 检查i节点的坐标是否与snake1或snake2的食物坐标匹配
    39.     if ((i->x == snake1->_food->x) && (i->y == snake1->_food->y) || (i->x == snake2->_food->x) && (i->y == snake2->_food->y))
    40.     {
    41.         if ((i->x == snake1->_food->x) && (i->y == snake1->_food->y))
    42.         {
    43.             (snake1->_score) += snake1->_weight;  // 增加snake1的分数
    44.             free(snake1->_food);  // 释放snake1的食物节点
    45.             creatfood(snake1, snake2);  // 创建新的snake1食物
    46.         }
    47.         else
    48.         {
    49.             (snake1->_score) += snake1->_weight;  // 增加snake1的分数
    50.             free(snake2->_food);  // 释放snake2的食物节点
    51.             creatfood(snake2, snake1);  // 创建新的snake2食物
    52.         }
    53.     }
    54.     else
    55.     {
    56.         pSnakeNode pre = NULL;
    57.         while (p->next != NULL)
    58.         {
    59.             pre = p;
    60.             p = p->next;
    61.         }
    62.         pre->next = NULL;
    63.         setpos(p->x, p->y);
    64.         printf("  ");
    65.         free(p);
    66.     }
    67.  
    68.     // 检查snake1的头节点是否触碰到边界
    69.     if (snake1->_snake->x == 0 || snake1->_snake->x == 56 || snake1->_snake->y == 0 || snake1->_snake->y == 25)
    70.     {
    71.         snake1->sta = by_wall;  // 设置snake1的状态为by_wall
    72.         return;
    73.     }
    74.  
    75.     kill_self(snake1, snake2);  // 检查snake1是否与snake2相撞
    76.  
    77.     p = i;
    78.     while (p)
    79.     {
    80.         setpos(p->x, p->y);
    81.         wprintf(L"%c", Body);
    82.         p = p->next;
    83.     }
    84. }
    3.3.1 判断贪吃蛇是否自噬或者与另一个贪吃相撞

    该函数包含了以下功能：

    • 初始化两个指针 p1 和 p2 分别指向贪吃蛇1和贪吃蛇2的蛇身链表的第二个节点（跳过蛇头）。
    • 检测贪吃蛇1的蛇头是否与贪吃蛇2的蛇头位置重叠，如果是，则将两个贪吃蛇的状态都设置为 by_headpush 表示头部碰撞，并立即返回。
    • 遍历贪吃蛇1和贪吃蛇2的蛇身链表，检测贪吃蛇1的蛇头是否与贪吃蛇2的蛇身节点或贪吃蛇1自身的蛇身节点位置重叠，如果是，则将贪吃蛇1的状态设置为相应的自噬状态（by_body 或 by_self），并立即返回。

    这个函数的作用是在每次贪吃蛇移动后检测是否发生自噬或者与其他贪吃蛇相撞的情况，以便在后续的游戏逻辑中处理相应的情况。

    1. void kill_self(pSnake snake1, pSnake snake2)
    2. {
    3.     pSnakeNode p1 = snake1->_snake->next;
    4.     pSnakeNode p2 = snake2->_snake->next;
    5.  
    6.     // 检测蛇头是否碰撞
    7.     if (snake1->_snake->x == snake2->_snake->x && snake1->_snake->y == snake2->_snake->y)
    8.     {
    9.         snake1->sta = by_headpush;
    10.         snake2->sta = by_headpush;
    11.         return;
    12.     }
    13.  
    14.     // 检测蛇头是否与蛇身碰撞
    15.     while (p1 && p2)
    16.     {
    17.         if (snake1->_snake->x == p2->x && snake1->_snake->y == p2->y)
    18.         {
    19.             snake1->sta = by_body;
    20.             return;
    21.         }
    22.         if (snake1->_snake->x == p1->x && snake1->_snake->y == p1->y)
    23.         {
    24.             snake1->sta = by_self;
    25.             return;
    26.         }
    27.         p1 = p1->next;
    28.         p2 = p2->next;
    29.     }
    30. }

    4.游戏结束

    该函数包含以下功能：

    • 检查贪吃蛇的状态，根据不同的情况显示相应的游戏结束提示信息。
    • 释放贪吃蛇1和贪吃蛇2所占用的内存。

    具体逻辑如下：

    首先，函数检查两条蛇的状态是否相同。如果状态不同，根据不同的状态显示相应的游戏结束提示信息。

    • 如果蛇1的状态是by_body，表示蛇1咬到了蛇2的身体，显示"玩家1咬到对方蛇身了，游戏结束！"的提示信息。
    • 如果蛇1的状态是by_wall，表示蛇1撞到了墙壁，显示"玩家1撞到墙了，游戏结束！"的提示信息。
    • 如果蛇2的状态是by_body，表示蛇2咬到了蛇1的身体，显示"玩家2咬到对方蛇身了，游戏结束！"的提示信息。
    • 如果蛇2的状态是by_wall，表示蛇2撞到了墙壁，显示"玩家2撞到墙了，游戏结束！"的提示信息。
    • 如果蛇1的状态是by_self，表示蛇1咬到了自己的身体，显示"玩家1咬到自己蛇身了，游戏结束！"的提示信息。
    • 如果蛇2的状态是by_self，表示蛇2咬到了自己的身体，显示"玩家2咬到自己蛇身了，游戏结束！"的提示信息。

    如果两条蛇的状态相同，继续检查状态。

    • 如果蛇1的状态是by_end，表示蛇1到达了游戏结束状态，显示"游戏结束！"的提示信息。
    • 如果蛇1的状态是by_body，表示蛇1和蛇2都咬到了对方的身体，显示"玩家1和玩家2都咬到对方蛇身了，游戏结束！"的提示信息。
    • 如果蛇1的状态是by_wall，表示蛇1和蛇2都撞到了墙壁，显示"玩家1和玩家2撞到墙了，游戏结束！"的提示信息。
    • 如果蛇1的状态是by_headpush，表示蛇1和蛇2相互碰撞，显示"两位玩家相撞了，游戏结束！"的提示信息。
    • 如果蛇1的状态是by_self，表示蛇1和蛇2都咬到了自己的身体，显示"玩家1和玩家2都咬到自己蛇身了，游戏结束！"的提示信息。

    接下来，函数释放贪吃蛇1所占用的内存。首先释放蛇1的食物（_food），然后依次释放蛇1的节点（_snake）所占用的内存。最后，函数释放贪吃蛇2所占用的内存。首先释放蛇2的食物（_food），然后依次释放蛇2的节点（_snake）所占用的内存。

    1. void gameend(pSnake snake1, pSnake snake2)
    2. {
    3.     // 检查贪吃蛇状态，显示相应的游戏结束提示信息并释放内存
    4.  
    5.     if (snake1->sta != snake2->sta)
    6.     {
    7.         if (snake1->sta == by_body)
    8.         {
    9.             system("cls");
    10.             setpos(42, 15);
    11.             printf("玩家1咬到对方蛇身了，游戏结束！");
    12.             setpos(40, 22);
    13.             system("pause");
    14.         }
    15.         else if (snake1->sta == by_wall)
    16.         {
    17.             system("cls");
    18.             setpos(38, 15);
    19.             printf("玩家1撞到墙了，游戏结束！");
    20.             setpos(40, 22);
    21.             system("pause");
    22.         }
    23.         else if (snake2->sta == by_body)
    24.         {
    25.             system("cls");
    26.             setpos(34, 15);
    27.             printf("玩家2咬到对方蛇身了，游戏结束！");
    28.             setpos(40, 22);
    29.             system("pause");
    30.         }
    31.         else if (snake2->sta == by_wall)
    32.         {
    33.             system("cls");
    34.             setpos(34, 15);
    35.             printf("玩家2撞到墙了，游戏结束！");
    36.             setpos(40, 22);
    37.             system("pause");
    38.         }
    39.         else if (snake1->sta == by_self)
    40.         {
    41.             system("cls");
    42.             setpos(34, 15);
    43.             printf("玩家1咬到自己蛇身了，游戏结束！");
    44.             setpos(40, 22);
    45.             system("pause");
    46.         }
    47.         else if (snake2->sta == by_self)
    48.         {
    49.             system("cls");
    50.             setpos(34, 15);
    51.             printf("玩家2咬到自己蛇身了，游戏结束！");
    52.             setpos(40, 22);
    53.             system("pause");
    54.         }
    55.     }
    56.     else
    57.     {
    58.         if (snake1->sta == by_end)
    59.         {
    60.             system("cls");
    61.             setpos(48, 15);
    62.             printf("游戏结束！");
    63.             setpos(42, 22);
    64.             system("pause");
    65.         }
    66.         else if (snake1->sta == by_body)
    67.         {
    68.             system("cls");
    69.             setpos(34, 15);
    70.             printf("玩家1和玩家2都咬到对方蛇身了，游戏结束！");
    71.             setpos(40, 22);
    72.             system("pause");
    73.         }
    74.         else if (snake1->sta == by_wall)
    75.         {
    76.             system("cls");
    77.             setpos(34, 15);
    78.             printf("玩家1和玩家2撞到墙了，游戏结束！");
    79.             setpos(40, 22);
    80.             system("pause");
    81.         }
    82.         else if (snake1->sta == by_headpush)
    83.         {
    84.             system("cls");
    85.             setpos(34, 15);
    86.             printf("两位玩家相撞了，游戏结束！");
    87.             setpos(40, 22);
    88.             system("pause");
    89.         }
    90.         else if (snake1->sta == by_self)
    91.         {
    92.             system("cls");
    93.             setpos(34, 15);
    94.             printf("玩家1和玩家2都咬到自己蛇身了，游戏结束！");
    95.             setpos(40, 22);
    96.             system("pause");
    97.         }
    98.     }
    99.  
    100.     // 释放贪吃蛇1的内存
    101.     free(snake1->_food);
    102.     pSnakeNode p = snake1->_snake;
    103.     pSnakeNode pre = NULL;
    104.     while (p)
    105.     {
    106.         pre = p;
    107.         p = p->next;
    108.         pre->next = NULL;
    109.         free(pre);
    110.     }
    111.     free(snake1);
    112.  
    113.     // 释放贪吃蛇2的内存
    114.     free(snake2->_food);
    115.     p = snake2->_snake;
    116.     pre = NULL;
    117.     while (p)
    118.     {
    119.         pre = p;
    120.         p = p->next;
    121.         pre->next = NULL;
    122.         free(pre);
    123.     }
    124.     free(snake2);
    125. }

    四.贪吃蛇的测试

    五.贪吃蛇的源码呈现

    1.snake.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #define Wall L'□'
    10. #define Body L'●'
    11. #define FOOD L'★'
    12. #define Key_state(KEY) ((GetAsyncKeyState(KEY)&(0x1))?1:0)
    13. enum state
    14. {
    15. 	ok = 1,
    16. 	by_wall,
    17. 	by_body,
    18. 	by_self,
    19. 	by_end,
    20. 	by_headpush
    21. };
    22. enum direction
    23. {
    24. 	up = 1,
    25. 	down,
    26. 	left,
    27. 	right
    28. };
    29. typedef struct SnakeNode
    30. {
    31. 	int x;
    32. 	int y;
    33. 	struct SnakeNode* next;
    34. }SnakeNode, * pSnakeNode;
    35. typedef struct Food
    36. {
    37. 	int x;
    38. 	int y;
    39. }Food, * pFood;
    40. typedef struct Snake
    41. {
    42. 	pSnakeNode _snake;
    43. 	pFood _food;
    44. 	int _score;
    45. 	enum direction dir;
    46. 	enum state sta;
    47. 	int _weight;
    48. 	int _sleeptime;
    49. }Snake, * pSnake;
    50. void gamestart(pSnake snake1,pSnake snake2);
    51. void setpos(int x, int y);
    52. void welcome();
    53. void creatmap();
    54. void creatfood(pSnake snake1,pSnake snake2);
    55. void initsnake(pSnake snake1);
    56. void creatsnake(pSnake snake1, pSnake snake2);
    57. void gameinfo(pSnake snake1, pSnake snake2);
    58. void gamerun(pSnake snake1, pSnake snake2);
    59. void pause();
    60. void snakemove(pSnake snake1,pSnake snake2);
    61. void kill_self(pSnake snake);
    62. void gameend(pSnake snake);

    2.test.c

    1. #include"snake.h"
    2. void test()
    3. {
    4. 	srand((unsigned int)time(NULL));
    5. 	int ch;
    6. 	do {
    7. 		pSnake snake1 = (pSnake)malloc(sizeof(Snake));
    8. 		pSnake snake2 = (pSnake)malloc(sizeof(Snake));
    9. 		gamestart(snake1,snake2);
    10. 		gamerun(snake1,snake2);
    11. 		gameend(snake1,snake2);
    12. 		system("cls");
    13. 		setpos(46, 15);
    14. 		printf("选择Y/N");
    15. 		setpos(50, 16);
    16. 		ch = getchar();
    17. 		getchar();
    18. 	} while (ch == 'y' || ch == 'Y');
    19. }
    20. int main()
    21. {
    22. 	setlocale(LC_ALL, "");
    23. 	test();
    24. 	return 0;
    25. }

    3.snake.c

    1. #include"snake.h"
    2. void setpos(int x, int y)
    3. {
    4. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    5. 	COORD coord;
    6. 	coord.X = x;
    7. 	coord.Y = y;
    8. 	SetConsoleCursorPosition(handle, coord);
    9. }
    10. void welcome()
    11. {
    12. 	system("mode con cols=100 lines=30");
    13. 	system("title 贪吃蛇");
    14. 	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    15. 	CONSOLE_CURSOR_INFO cursor;
    16. 	GetConsoleCursorInfo(handle, &cursor);
    17. 	cursor.bVisible = false;
    18. 	SetConsoleCursorInfo(handle, &cursor);
    19. 	setpos(40, 10);
    20. 	printf("欢迎来到贪吃蛇游戏！");
    21. 	setpos(40, 20);
    22. 	system("pause");
    23. 	system("cls");
    24. 	setpos(38, 10);
    25. 	printf("游戏规则如下:\n");
    26. 	setpos(38, 11);
    27. 	printf("1.用← → ↑ ↓或a  d  w  s进行操作");
    28. 	setpos(38, 12);
    29. 	printf("2.用f1进行加速，用进行f2减速");
    30. 	setpos(38, 13);
    31. 	printf("3.空格键暂停游戏");
    32. 	setpos(38, 14);
    33. 	printf("4.esc退出游戏");
    34. 	setpos(40, 20);
    35. 	system("pause");
    36. 	system("cls");
    37. }
    38. void creatmap()
    39. {
    40. 	setpos(0, 0);
    41. 	for (int i = 0; i < 58; i += 2)
    42. 	{
    43. 		wprintf(L"%c", Wall);
    44. 	}
    45. 	setpos(0, 25);
    46. 	for (int i = 0; i < 58; i += 2)
    47. 	{
    48. 		wprintf(L"%c", Wall);
    49. 	}
    50. 	for (int i = 1; i < 25; i++)
    51. 	{
    52. 		setpos(0, i);
    53. 		wprintf(L"%c", Wall);
    54. 	}
    55. 	for (int i = 1; i < 25; i++)
    56. 	{
    57. 		setpos(56, i);
    58. 		wprintf(L"%c", Wall);
    59. 	}
    60. }
    61. void initsnake(pSnake snake)
    62. {
    63. 	snake->_snake = NULL;
    64. 	snake->_food = NULL;
    65. 	snake->_score = 0;
    66. 	snake->dir = left;
    67. 	snake->sta = ok;
    68. 	snake->_weight = 10;
    69. 	snake->_sleeptime = 200;
    70. }
    71. void creatsnake(pSnake snake1,pSnake snake2)
    72. {
    73. 	pSnakeNode p1 = (pSnakeNode)malloc(sizeof(SnakeNode));
    74. 	assert(p1);
    75. 	p1->next = NULL;
    76. 	p1->x = 24;
    77. 	p1->y = 5;
    78. 	snake1->_snake = p1;
    79. 	setpos(p1->x, p1->y);
    80. 	wprintf(L"%c", Body);
    81. 	for (int i = 1; i < 5; i++)
    82. 	{
    83. 		pSnakeNode j = (pSnakeNode)malloc(sizeof(SnakeNode));
    84. 		assert(j);
    85. 		j->x = 24 + i * 2;
    86. 		j->y = 5;
    87. 		j->next = NULL;
    88. 		setpos(j->x, j->y);
    89. 		wprintf(L"%c", Body);
    90. 		p1->next = j;
    91. 		p1 = p1->next;
    92. 	}
    93. 	pSnakeNode p2 = (pSnakeNode)malloc(sizeof(SnakeNode));
    94. 	assert(p2);
    95. 	p2->next = NULL;
    96. 	p2->x = 24;
    97. 	p2->y = 22;
    98. 	snake2->_snake = p2;
    99. 	setpos(p2->x, p2->y);
    100. 	wprintf(L"%c", Body);
    101. 	for (int i = 1; i < 5; i++)
    102. 	{
    103. 		pSnakeNode j = (pSnakeNode)malloc(sizeof(SnakeNode));
    104. 		assert(j);
    105. 		j->x = 24 + i * 2;
    106. 		j->y = 22;
    107. 		j->next = NULL;
    108. 		setpos(j->x, j->y);
    109. 		wprintf(L"%c", Body);
    110. 		p2->next = j;
    111. 		p2 = p2->next;
    112. 	}
    113. }
    114. void creatfood(pSnake snake1, pSnake snake2) {
    115. 	int x, y;
    116. 	pFood food1 = (pFood)malloc(sizeof(Food));
    117. 	assert(food1 != NULL);
    118. 	while (1) {
    119. 		x = rand() % 53 + 2;
    120. 		y = rand() % 24 + 1;
    121. 		if (x % 2 == 0) {
    122. 			pSnakeNode p1 = snake1->_snake;
    123. 			pSnakeNode p2 = snake2->_snake;
    124. 			int conflict = 0;
    125. 			while (p1 != NULL) {
    126. 				if (p1->x == x && p1->y == y) {
    127. 					conflict = 1;
    128. 					break;
    129. 				}
    130. 				p1 = p1->next;
    131. 			}
    132. 			while (!conflict && p2 != NULL) {
    133. 				if (p2->x == x && p2->y == y) {
    134. 					conflict = 1;
    135. 					break;
    136. 				}
    137. 				p2 = p2->next;
    138. 			}
    139. 			if (!conflict && snake2->_food != NULL && snake2->_food->x == x && snake2->_food->y == y) {
    140. 				conflict = 1;
    141. 			}
    142. 			if (!conflict) {
    143. 				break;
    144. 			}
    145. 		}
    146. 	}
    147. 	food1->x = x;
    148. 	food1->y = y;
    149. 	snake1->_food = food1;
    150. 	setpos(food1->x, food1->y);
    151. 	wprintf(L"%c", FOOD);
    152. }
    153. void gameinfo(pSnake snake1,pSnake snake2)
    154. {
    155. 	setpos(70, 6);
    156. 	printf("分数:%d ", snake1->_score);
    157. 	setpos(70, 7);
    158. 	printf("奖励:%d ", snake1->_weight);
    159. 	setpos(70, 10);
    160. 	printf("分数:%d ", snake2->_score);
    161. 	setpos(70, 11);
    162. 	printf("奖励:%d ", snake2->_weight);
    163. 	setpos(62, 15);
    164. 	printf("游戏规则如下:");
    165. 	setpos(62, 16);
    166. 	printf("1.用← → ↑ ↓或a  d  w  s进行操作");
    167. 	setpos(62, 17);
    168. 	printf("2.用f1进行加速，用进行f2减速");
    169. 	setpos(62, 18);
    170. 	printf("3.空格键暂停游戏");
    171. 	setpos(62, 19);
    172. 	printf("4.esc退出游戏");
    173. 	setpos(62, 20);
    174. 	printf("5.咬到蛇身或撞墙都会死");
    175. }
    176. void pause()
    177. {
    178. 	while (1)
    179. 	{
    180. 		if (Key_state(VK_SPACE))
    181. 			return;
    182. 		Sleep(1000);
    183. 	}
    184. }
    185. void kill_self(pSnake snake1,pSnake snake2)
    186. {
    187. 	pSnakeNode p1 = snake1->_snake->next;
    188. 	pSnakeNode p2 = snake2->_snake->next;
    189. 	if (snake1->_snake->x == snake2->_snake->x && snake1->_snake->y == snake2->_snake->y)
    190. 	{
    191. 		snake1->sta = by_headpush;
    192. 		snake2->sta = by_headpush;
    193. 		return;
    194. 	}
    195. 	while (p1&&p2)
    196. 	{
    197. 		if (snake1->_snake->x == p2->x && snake1->_snake->y == p2->y)
    198. 		{
    199. 			snake1->sta = by_body;
    200. 			return;
    201. 		}
    202. 		if (snake1->_snake->x == p1->x && snake1->_snake->y == p1->y)
    203. 		{
    204. 			snake1->sta = by_self;
    205. 			return;
    206. 		}
    207. 		p1 = p1->next;
    208. 		p2 = p2->next;
    209. 	}
    210. }
    211. void snakemove(pSnake snake1,pSnake snake2)
    212. {
    213. 	pSnakeNode i = (pSnakeNode)malloc(sizeof(SnakeNode));
    214. 	assert(i);
    215. 	i->next = snake1->_snake;
    216. 	if (snake1->dir == up)
    217. 	{
    218. 		i->x = snake1->_snake->x;
    219. 		i->y = snake1->_snake->y - 1;
    220. 	}
    221. 	else if (snake1->dir == down)
    222. 	{
    223. 		i->x = snake1->_snake->x;
    224. 		i->y = snake1->_snake->y + 1;
    225. 	}
    226. 	else if (snake1->dir == left)
    227. 	{
    228. 		i->x = snake1->_snake->x - 2;
    229. 		i->y = snake1->_snake->y;
    230. 	}
    231. 	else if (snake1->dir == right)
    232. 	{
    233. 		i->x = snake1->_snake->x + 2;
    234. 		i->y = snake1->_snake->y;
    235. 	}
    236. 	else if (snake1->sta == by_end)
    237. 	{
    238. 		return;
    239. 	}
    240. 	snake1->_snake = i;
    241. 	pSnakeNode p = snake1->_snake;
    242. 	if ((i->x == snake1->_food->x) &&( i->y == snake1->_food->y)|| (i->x == snake2->_food->x )&& (i->y == snake2->_food->y))
    243. 	{
    244. 		if ((i->x == snake1->_food->x) && (i->y == snake1->_food->y))
    245. 		{
    246. 			(snake1->_score) += snake1->_weight;
    247. 			free(snake1->_food);
    248. 			creatfood(snake1, snake2);
    249. 		}
    250. 		else 
    251. 		{
    252. 			(snake1->_score) += snake1->_weight;
    253. 			free(snake2->_food);
    254. 			creatfood(snake2, snake1);
    255. 		}
    256. 	}
    257. 	else
    258. 	{
    259. 		pSnakeNode pre = NULL;
    260. 		while (p->next != NULL)
    261. 		{
    262. 			pre = p;
    263. 			p = p->next;
    264. 		}
    265. 		pre->next = NULL;
    266. 		setpos(p->x, p->y);
    267. 		printf("  ");
    268. 		free(p);
    269. 	}
    270. 	if (snake1->_snake->x == 0 || snake1->_snake->x == 56 || snake1->_snake->y == 0 || snake1->_snake->y == 25)
    271. 	{
    272. 		snake1->sta = by_wall;
    273. 		return;
    274. 	}
    275. 	kill_self(snake1,snake2);
    276. 	p = i;
    277. 	while (p)
    278. 	{
    279. 		setpos(p->x, p->y);
    280. 		wprintf(L"%c", Body);
    281. 		p = p->next;
    282. 	}
    283. }
    284. void gamestart(pSnake snake1,pSnake snake2)
    285. {
    286. 	assert(snake1&&snake2);
    287. 	welcome();
    288. 	creatmap();
    289. 	initsnake(snake1);
    290. 	initsnake(snake2);
    291. 	creatsnake(snake1,snake2);
    292. 	creatfood(snake1,snake2);
    293. 	creatfood(snake2, snake1);
    294. 	gameinfo(snake1,snake2);
    295. }
    296. void gamerun(pSnake snake1,pSnake snake2)
    297. {
    298. 	do {
    299. 		if (Key_state(0x57) && snake1->dir != down)
    300. 		{
    301. 			snake1->dir = up;
    302. 		}
    303. 		else if (Key_state(0x53) && snake1->dir != up)
    304. 		{
    305. 			snake1->dir = down;
    306. 		}
    307. 		else if (Key_state(0x41) && snake1->dir != right)
    308. 		{
    309. 			snake1->dir = left;
    310. 		}
    311. 		else if (Key_state(0x44) && snake1->dir != left)
    312. 		{
    313. 			snake1->dir = right;
    314. 		}
    315. 		else if (Key_state(VK_SPACE))
    316. 		{
    317. 			pause();
    318. 		}
    319. 		else if (Key_state(VK_ESCAPE))
    320. 		{
    321. 			snake1->sta = by_end;
    322. 			snake2->sta = by_end;
    323. 		}
    324. 		else if (Key_state(VK_F1))
    325. 		{
    326. 			if (snake1->_sleeptime >= 80)
    327. 			{
    328. 				(snake1->_sleeptime) -= 20;
    329. 				(snake1->_weight) += 2;
    330. 			}
    331. 			setpos(70, 7);
    332. 			printf("奖励:%d ", snake1->_weight);
    333. 			if (snake2->_sleeptime >= 80)
    334. 			{
    335. 				(snake2->_sleeptime) -= 20;
    336. 				(snake2->_weight) += 2;
    337. 			}
    338. 			setpos(70, 11);
    339. 			printf("奖励:%d ", snake2->_weight);
    340. 		}
    341. 		else if (Key_state(VK_F2))
    342. 		{
    343. 			if (snake1->_sleeptime <= 280)
    344. 			{
    345. 				(snake1->_sleeptime) += 20;
    346. 				(snake1->_weight) -= 2;
    347. 			}
    348. 			setpos(70, 7);
    349. 			printf("奖励:%d ", snake1->_weight);
    350. 			if (snake2->_sleeptime <= 280)
    351. 			{
    352. 				(snake2->_sleeptime) += 20;
    353. 				(snake2->_weight) -= 2;
    354. 			}
    355. 			setpos(70, 11);
    356. 			printf("奖励:%d ", snake2->_weight);
    357. 		}else if (Key_state(VK_UP) && snake2->dir != down)
    358. 		{
    359. 			snake2->dir = up;
    360. 		}
    361. 		else if (Key_state(VK_DOWN) && snake2->dir != up)
    362. 		{
    363. 			snake2->dir = down;
    364. 		}
    365. 		else if (Key_state(VK_LEFT) && snake2->dir != right)
    366. 		{
    367. 			snake2->dir = left;
    368. 		}
    369. 		else if (Key_state(VK_RIGHT) && snake2->dir != left)
    370. 		{
    371. 			snake2->dir = right;
    372. 		}
    373. 		snakemove(snake1,snake2);
    374. 		snakemove(snake2,snake1);
    375. 		setpos(70, 6);
    376. 		printf("分数:%d ", snake1->_score);
    377. 		setpos(70, 7);
    378. 		printf("奖励:%d ", snake1->_weight);
    379. 		setpos(70, 10);
    380. 		printf("分数:%d ", snake2->_score);
    381. 		setpos(70, 11);
    382. 		printf("奖励:%d ", snake2->_weight);
    383. 		Sleep(snake1->_sleeptime);
    384. 	} while (snake1->sta == ok&&snake2->sta==ok);
    385. }
    386. void gameend(pSnake snake1,pSnake snake2)
    387. {
    388. 	/*if (snake1->sta == by_end)
    389. 	{
    390. 		system("cls");
    391. 		setpos(48, 15);
    392. 		printf("游戏结束！");
    393. 		setpos(42, 22);
    394. 		system("pause");
    395. 	}
    396. 	else*/
    397. 	if (snake1->sta != snake2->sta)
    398. 	{
    399. 		if (snake1->sta == by_body)
    400. 		{
    401. 			system("cls");
    402. 			setpos(42, 15);
    403. 			printf("玩家1咬到对方蛇身了，游戏结束！");
    404. 			setpos(40, 22);
    405. 			system("pause");
    406. 		}
    407. 		else if (snake1->sta == by_wall)
    408. 		{
    409. 			system("cls");
    410. 			setpos(38, 15);
    411. 			printf("玩家1撞到墙了，游戏结束！");
    412. 			setpos(40, 22);
    413. 			system("pause");
    414. 		}/*else if (snake2->sta == by_end)
    415. 		{
    416. 			system("cls");
    417. 			setpos(48, 15);
    418. 			printf("游戏结束！");
    419. 			setpos(42, 22);
    420. 			system("pause");
    421. 		}*/
    422. 		else if (snake2->sta == by_body)
    423. 		{
    424. 			system("cls");
    425. 			setpos(34, 15);
    426. 			printf("玩家2咬到对方蛇身了，游戏结束！");
    427. 			setpos(40, 22);
    428. 			system("pause");
    429. 		}
    430. 		else if (snake2->sta == by_wall)
    431. 		{
    432. 			system("cls");
    433. 			setpos(34, 15);
    434. 			printf("玩家2撞到墙了，游戏结束！");
    435. 			setpos(40, 22);
    436. 			system("pause");
    437. 		}
    438. 		else if (snake1->sta == by_self)
    439. 		{
    440. 			system("cls");
    441. 			setpos(34, 15);
    442. 			printf("玩家1咬到自己蛇身了，游戏结束！");
    443. 			setpos(40, 22);
    444. 			system("pause");
    445. 		}
    446. 		else if (snake2->sta == by_self)
    447. 		{
    448. 			system("cls");
    449. 			setpos(34, 15);
    450. 			printf("玩家2咬到自己蛇身了，游戏结束！");
    451. 			setpos(40, 22);
    452. 			system("pause");
    453. 		}
    454. 	}
    455. 	else
    456. 	{
    457. 		if (snake1->sta == by_end)
    458. 		{
    459. 			system("cls");
    460. 			setpos(48, 15);
    461. 			printf("游戏结束！");
    462. 			setpos(42, 22);
    463. 			system("pause");
    464. 		}
    465. 		else if (snake1->sta == by_body)
    466. 		{
    467. 			system("cls");
    468. 			setpos(34, 15);
    469. 			printf("玩家1和玩家2都咬到对方蛇身了，游戏结束！");
    470. 			setpos(40, 22);
    471. 			system("pause");
    472. 		}
    473. 		else if (snake1->sta == by_wall)
    474. 		{
    475. 			system("cls");
    476. 			setpos(34, 15);
    477. 			printf("玩家1和玩家2撞到墙了，游戏结束！");
    478. 			setpos(40, 22);
    479. 			system("pause");
    480. 		}
    481. 		else if (snake1->sta == by_headpush)
    482. 		{
    483. 			system("cls");
    484. 			setpos(34, 15);
    485. 			printf("两位玩家相撞了，游戏结束！");
    486. 			setpos(40, 22);
    487. 			system("pause");
    488. 		}
    489. 		else if (snake1->sta == by_self)
    490. 		{
    491. 			system("cls");
    492. 			setpos(34, 15);
    493. 			printf("玩家1和玩家2都咬到自己蛇身了，游戏结束！");
    494. 			setpos(40, 22);
    495. 			system("pause");
    496. 		}
    497. 	}
    498. 	free(snake1->_food);
    499. 	pSnakeNode p = snake1->_snake;
    500. 	pSnakeNode pre = NULL;
    501. 	while (p)
    502. 	{
    503. 		pre = p;
    504. 		p = p->next;
    505. 		pre->next = NULL;
    506. 		free(pre);
    507. 	}
    508. 	free(snake1);
    509. 	free(snake2->_food);
    510. 	p = snake2->_snake;
    511. 	pre = NULL;
    512. 	while (p)
    513. 	{
    514. 		pre = p;
    515. 		p = p->next;
    516. 		pre->next = NULL;
    517. 		free(pre);
    518. 	}
    519. 	free(snake2);
    520. }

  • 相关阅读:
    【最全最详细索引失效】索引失效的10种场景，数据库优化
    MySQL作业1
    2023年中国鸡蛋市场供需现状、市场规模及产品价格走势分析[图]
    【Java并发编程】——线程池
    计算机保研er历程分享（浙软、厦大、华师、东南网安、东北、西电、中南......）
    加州法案提议在州一级监管人工智能
    解决git中出现的“fatal ‘xxxx‘ does not appear to be a git repository”错误的方法
    mysql 一对多查询 合并为一行数据
    STM32通用定时器产生PWM信号
    map和set的应用
  • 原文地址：https://blog.csdn.net/z6665454/article/details/138148851