实现贪吃蛇小游戏【简单版】

鳄鱼皮坡2024-06-20 3:09

1. 贪吃蛇游戏设计与分析

1.1 地图

我们最终的贪吃蛇大纲要是这个样子，那我们的地图如何布置呢？


这里不得不讲⼀下控制台窗口的⼀些知识，如果想在控制台的窗口中指定位置输出信息，我们得知道该位置的坐标，所以首先介绍⼀下控制台窗⼝的坐标知识。
控制台窗口的坐标如下所示，横向的是X轴，从左向右依次增长，纵向是Y轴，从上到下依次增长。

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

1.1.1 <locale.h>本地化

<locale.h>提供的函数⽤于控制C标准库中对于不同的地区会产生不⼀样行为的部分。
在标准中，依赖地区的部分有以下几项：
• 数字量的格式
• 货币量的格式
• 字符集
• 日期和时间的表示形式

1.1.2 类项

通过修改地区，程序可以改变它的⾏为来适应世界的不同区域。但地区的改变可能会影响库的许多部分，其中⼀部分可能是我们不希望修改的。所以C语⾔⽀持针对不同的类项进⾏修改，下⾯的⼀个宏，指定⼀个类项 ：
• LC_COLLATE：影响字符串比较函数 strcoll() 和 strxfrm() 。
• LC_CTYPE：影响字符处理函数的行为。
• LC_MONETARY：影响货币格式。
• LC_NUMERIC：影响 printf() 的数字格式。
• LC_TIME：影响时间格式 strftime() 和 wcsftime() 。
• LC_ALL - 针对所有类项修改，将以上所有类别设置为给定的语言环境。

1.1.3 setlocale函数

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

setlocale 函数用于修改当前地区，可以针对⼀个类项修改，也可以针对所有类项。
setlocale 的第⼀个参数可以是前面说明的类项中的⼀个，那么每次只会影响⼀个类项，如果第⼀个参数是LC_ALL，就会影响所有的类项。
C标准给第⼆个参数仅定义了2种可能取值： "C" （正常模式）和 "" （本地模式）。
在任意程序执行开始，都会隐藏式执行调用:

setlocale(LC_ALL, "C");

当地区设置为"C"时，设置为C语言默认的模式，这时库函数按正常方式执行。
当程序运行起来后想改变地区，就只能显示调用setlocale函数。用" "作为第2个参数，调用setlocale 函数就可以切换到本地模式，这种模式下程序会适应本地环境。
比如：切换到我们的本地模式后就⽀持宽字符（汉字）的输出等。

setlocale(LC_ALL, "");//切换到本地环境

setlocale 的返回值是⼀个字符串指针，表示已经设置好的格式。如果调用失败，则返回空指针
NULL 。
setlocale() 可以用来查询当前地区，这时第⼆个参数设为 NULL 就可以了。

#include <locale.h>
int main()
{
     char* loc;
     loc = setlocale(LC_ALL, NULL);
     printf("默认的本地信息：%s\n", loc);

     loc = setlocale(LC_ALL, "");
     printf("设置后的本地信息: %s\n", loc);
     return 0;
}

1.1.4 宽字符的打印

那如果想在屏幕上打印宽字符，怎么打印呢？
宽字符的字面量必须加上前缀 L ，否则 C 语⾔会把字⾯量当作窄字符类型处理。前缀 L 在单引号前面，表示宽字符，宽字符的打印使⽤ wprintf ，对应 wprintf() 的占位符为 %lc ；在双引号前面，表示宽字符串，对应 wprintf() 的占位符为 %ls 。

#include <stdio.h>
#include<locale.h>
int main() 
{
     setlocale(LC_ALL, "");
     wchar_t ch1 = L'●';
     wchar_t ch2 = L'⽐';
     wchar_t ch3 = L'特';
     wchar_t ch4 = L'★';
     printf("%c%c\n", 'a', 'b');
     wprintf(L"%lc\n", ch1);
     wprintf(L"%lc\n", ch2);
     wprintf(L"%lc\n", ch3);
     wprintf(L"%lc\n", ch4);
     return 0;
}

输出结果：

从输出的结果来看，我们发现⼀个普通字符占⼀个字符的位置但是打印⼀个汉字字符，占⽤2个字符的位置，那么我们如果要在贪吃蛇中使⽤宽字符，就得处理好地图上坐标的计算。
普通字符和宽字符打印出宽度的展示如下：

1.1.5 地图坐标

我们假设实现⼀个棋盘27行，58列的棋盘（行和列可以根据自己的情况修改），再围绕地图画出墙， 如下：

1.2 蛇身和食物

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

1.3 数据结构设计

在游戏运行的过程中，蛇每次吃⼀个食物，蛇的身体就会变长⼀节，如果我们使用链表存储蛇的信
息，那么蛇的每⼀节其实就是链表的每个节点。每个节点只要记录好蛇身节点在地图上的坐标就行，所以蛇节点结构如下：

 typedef struct SnakeNode
 {
     int x;
     int y;
     struct SnakeNode* next;
 }SnakeNode, * pSnakeNode;

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

typedef struct Snake
{
     pSnakeNode _pSnake;//维护整条蛇的指针
     pSnakeNode _pFood;//维护⻝物的指针
     enum DIRECTION _Dir;//蛇头的⽅向,默认是向右
     enum GAME_STATUS _Status;//游戏状态
     int _Socre;//游戏当前获得分数
     int _foodWeight;//默认每个⻝物10分
     int _SleepTime;//每⾛⼀步休眠时间
}Snake, * pSnake;

蛇的方向，可以⼀⼀列举，使用枚举

//⽅向
enum DIRECTION
{
     UP = 1,
     DOWN,
     LEFT,
     RIGHT
};

游戏状态，可以⼀⼀列举，使用枚举

//游戏状态
enum GAME_STATUS
{
     OK,//正常运⾏
     KILL_BY_WALL,//撞墙
     KILL_BY_SELF,//咬到⾃⼰
     END_NOMAL//正常结束
};

1.4 游戏流程设计

2. 核心逻辑实现分析

2.1 游戏主逻辑

程序开始就设置程序支持本地模式，然后进入游戏的主逻辑。
主逻辑分为3个过程：
• 游戏开始（GameStart）完成游戏的初始化
• 游戏运行（GameRun）完成游戏运行逻辑的实现
• 游戏结束（GameEnd）完成游戏结束的说明，实现资源释放

#include <locale.h>
void test()
{
     int ch = 0;
     srand((unsigned int)time(NULL));
     do
     {
         Snake snake = { 0 };
         GameStart(&snake);
         GameRun(&snake);
         GameEnd(&snake);
         SetPos(20, 15);
         printf("再来⼀局吗？(Y/N):");
         ch = getchar();
         getchar();//清理\n
     } while (ch == 'Y');
     SetPos(0, 27);
}

int main()
{
     //修改当前地区为本地模式，为了⽀持中⽂宽字符的打印
     setlocale(LC_ALL, "");
     //测试逻辑
     test();
     return 0;
}

2.2 游戏开始（GameStart）

这个模块完成游戏的初始化任务：
• 控制台窗口大小的设置
• 控制台窗口名字的设置
• ⿏标光标的隐藏
• 打印欢迎界⾯
• 创建地图
• 初始化蛇
• 创建第⼀个食物

void GameStart(pSnake ps)
{
     //设置控制台窗⼝的⼤⼩，30⾏，100列
     //mode 为DOS命令
     system("mode con cols=100 lines=30");
     //设置cmd窗⼝名称
     system("title 贪吃蛇"); 
     //获取标准输出的句柄(⽤来标识不同设备的数值)
     HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
     //影藏光标操作
     CONSOLE_CURSOR_INFO CursorInfo;
     GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
     CursorInfo.bVisible = false; //隐藏控制台光标
     SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
     //打印欢迎界⾯
     WelcomeToGame();
     //打印地图
     CreateMap();
     //初始化蛇
     InitSnake(ps);
     //创造第⼀个⻝物
     CreateFood(ps);
}

2.2.1 打印欢迎界面

在游戏正式开始之前，做⼀些功能提醒

void WelcomeToGame()
{
     SetPos(40, 15);
     printf("欢迎来到贪吃蛇⼩游戏");
     SetPos(40, 25);//让按任意键继续的出现的位置好看点
     system("pause");
     system("cls");
     SetPos(25, 12);
     printf("⽤ ↑ . ↓ . ← . → 分别控制蛇的移动， F3为加速，F4为减速\n");
     SetPos(25, 13);
     printf("加速将能得到更⾼的分数。\n");
     SetPos(40, 25);//让按任意键继续的出现的位置好看点
     system("pause");
     system("cls");
}

2.2.2 创建地图

创建地图就是将墙打印出来，因为是宽字符打印，所有使用wprintf函数，打印格式串前使用L
打印地图的关键是要算好坐标，才能在想要的位置打印墙体。
墙体打印的宽字符：

#define WALL L'□'

++易错点：++ 就是坐标的计算
上：（0,0）到（56,0）
下：（0,26）到（56,26）
左：（0,1）到（0,25）
右：（56,1）到（56,25）
创建地图函数CreateMap

void CreateMap()
{
     int i = 0;
     //上(0,0)-(56, 0)
     SetPos(0, 0);
     for (i = 0; i < 58; i += 2)
     {
         wprintf(L"%c", WALL);
     }
     //下(0,26)-(56, 26)
     SetPos(0, 26);
     for (i = 0; i < 58; i += 2)
     {
         wprintf(L"%c", WALL);
     }
     //左
     //x是0，y从1开始增⻓
     for (i = 1; i < 26; i++)
     {
         SetPos(0, i);
         wprintf(L"%c", WALL);
     }
     //x是56，y从1开始增⻓
     for (i = 1; i < 26; i++)
     {
         SetPos(56, i);
         wprintf(L"%c", WALL);
     }
}

2.2.3 初始化蛇身

蛇最开始大度为5节，每节对应链表的⼀个节点，蛇⾝的每⼀个节点都有自己的坐标。
创建5个节点，然后将每个节点存放在链表中进行管理。创建完蛇身后，将蛇的每⼀节打印在屏幕上。
• 蛇的初始位置从 (24,5) 开始。
再设置当前游戏的状态，蛇移动的速度，默认的方向，初始成绩，每个食物的分数。
• 游戏状态是：OK
• 蛇的移动速度：200毫秒
• 蛇的默认⽅向：RIGHT
• 初始成绩：0
• 每个食物的分数：10
蛇身打印的宽字符：

#define BODY L'●'

初始化蛇⾝函数：InitSnake

void InitSnake(pSnake ps)
{
     pSnakeNode cur = NULL;
     int i = 0;
     //创建蛇⾝节点，并初始化坐标
     //头插法
     for (i = 0; i < 5; i++)
     {
         //创建蛇⾝的节点
         cur = (pSnakeNode)malloc(sizeof(SnakeNode));
         if (cur == NULL)
         {
             perror("InitSnake()::malloc()");
             return;
         }
         //设置坐标
         cur->next = NULL;
         cur->x = POS_X + i * 2;
         cur->y = POS_Y;
         //头插法
         if (ps->_pSnake == NULL)
         {
             ps->_pSnake = cur;
         }
         else
         {
             cur->next = ps->_pSnake;
             ps->_pSnake = cur;
         }
     }
     //打印蛇的⾝体
     cur = ps->_pSnake;
     while (cur)
     {
         SetPos(cur->x, cur->y);
         wprintf(L"%lc", BODY);
         cur = cur->next;
     }
     //初始化贪吃蛇数据
     ps->_SleepTime = 200;
     ps->_Socre = 0;
     ps->_Status = OK;
     ps->_Dir = RIGHT;
     ps->_foodWeight = 10;
}

2.2.4 创建第⼀个食物

• 先随机生成⻝物的坐标
◦ x坐标必须是2的倍数
◦ ⻝物的坐标得在墙体内部
◦ ⻝物的坐标不能和蛇身每个节点的坐标重复
• 创建⻝物节点，打印⻝物
⻝物打印的宽字符:

#define FOOD L'★'

创建食物的函数：CreateFood

void CreateFood(pSnake ps)
{
     int x = 0;
     int y = 0;
     again:
     //产⽣的x坐标应该是2的倍数，这样才可能和蛇头坐标对⻬。
     do
     {
         x = rand() % 53 + 2;
         y = rand() % 25 + 1;
     } while (x % 2 != 0);
     pSnakeNode cur = ps->_pSnake;//获取指向蛇头的指针
     //⻝物不能和蛇⾝冲突
     while (cur)
     {
         if (cur->x == x && cur->y == y)
         {
             goto again;
         }
         cur = cur->next;
     }
     pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode)); //创建⻝物
     if (pFood == NULL)
     {
         perror("CreateFood::malloc()");
         return;
     }
     else
     {
         pFood->x = x;
         pFood->y = y;
         SetPos(pFood->x, pFood->y);
         wprintf(L"%c", FOOD);
         ps->_pFood = pFood;
     }
}

2.3 游戏运行（GameRun）

游戏运行期间，右侧打印帮助信息，提示玩家，坐标开始位置(64, 15)
根据游戏状态检查游戏是否继续，如果是状态是OK，游戏继续，否则游戏结束。
如果游戏继续，就是检测按键情况，确定蛇下⼀步的方向，或者是否加速减速，是否暂停或者退出游戏。
需要的虚拟按键的罗列：
• 上： VK_UP
• 下： VK_DOWN
• 左： VK_LEFT
• 右： VK_RIGHT
• 空格： VK_SPACE
• ESC： VK_ESCAPE
• F3： VK_F3
• F4： VK_F4
确定了蛇的方向和速度，蛇就可以移动了。

void GameRun(pSnake ps)
{
 //打印右侧帮助信息
 PrintHelpInfo();
 do
 {
 SetPos(64, 10);
 printf("得分：%d ", ps->_Socre);
 printf("每个⻝物得分：%d分", ps->_foodWeight);
 if (KEY_PRESS(VK_UP) && ps->_Dir != DOWN)
 {
 ps->_Dir = UP;
 }
 else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP)
 {
 ps->_Dir = DOWN;
 }
 else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT)
 {
 ps->_Dir = LEFT;
 }
 else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT)
 {
 ps->_Dir = RIGHT;
 }
 else if (KEY_PRESS(VK_SPACE))
 {
 pause();
 }
 else if (KEY_PRESS(VK_ESCAPE))
 {
 ps->_Status = END_NOMAL;
 break;
 }
 else if (KEY_PRESS(VK_F3))
 {
 if (ps->_SleepTime >= 80)
 {
 ps->_SleepTime -= 30;
 ps->_foodWeight += 2;//⼀个⻝物分数最⾼是20分
 }
 }
 else if (KEY_PRESS(VK_F4))
 {
 if (ps->_SleepTime < 320)
 {
 ps->_SleepTime += 30;
 ps->_foodWeight -= 2;//⼀个⻝物分数最低是2分
 }
 }
 //蛇每次⼀定之间要休眠的时间，时间短，蛇移动速度就快
 Sleep(ps->_SleepTime);
 SnakeMove(ps);
 } while (ps->_Status == OK);
}

2.3.1 KEY_PRESS

检测按键状态，我们封装了⼀个宏

#define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1) ? 1 : 0)

2.3.2 PrintHelpInfo

void PrintHelpInfo()
{
     //打印提⽰信息
     SetPos(64, 15);
     printf("不能穿墙，不能咬到⾃⼰\n");
     SetPos(64, 16);
     printf("⽤↑.↓.←.→分别控制蛇的移动.");
     SetPos(64, 17);
     printf("F3 为加速，F4 为减速\n");
     SetPos(64, 18);
     printf("ESC ：退出游戏.space：暂停游戏.");
     SetPos(64, 20);
     printf("⽐特就业课@版权");
}

2.3.3 蛇身移动（SnakeMove）

先创建下⼀个节点，根据移动方向和蛇头的坐标，蛇移动到下⼀个位置的坐标。
确定了下⼀个位置后，看下⼀个位置是否是⻝物（NextIsFood），是食物就做吃⻝物处理（EatFood），如果不是⻝物则做前进⼀步的处理（NoFood）。
蛇⾝移动后，判断此次移动是否会造成撞墙（KillByWall）或者撞上自己蛇⾝（KillBySelf），从而影响游戏的状态。

void SnakeMove(pSnake ps)
{
     //创建下⼀个节点
     pSnakeNode pNextNode = (pSnakeNode)malloc(sizeof(SnakeNode));
     if (pNextNode == NULL)
     {
         perror("SnakeMove()::malloc()");
         return;
     }
     //确定下⼀个节点的坐标，下⼀个节点的坐标根据，蛇头的坐标和⽅向确定
     switch (ps->_Dir)
     {
         case UP:
         {
               pNextNode->x = ps->_pSnake->x;
               pNextNode->y = ps->_pSnake->y - 1;
         }
         break;
         case DOWN:
         {
               pNextNode->x = ps->_pSnake->x;
               pNextNode->y = ps->_pSnake->y + 1;
         }
         break;
         case LEFT:
         {
             pNextNode->x = ps->_pSnake->x - 2;
             pNextNode->y = ps->_pSnake->y;
         }
         break;
         case RIGHT:
         {
             pNextNode->x = ps->_pSnake->x + 2;
             pNextNode->y = ps->_pSnake->y;
         }
         break;
     }
     //如果下⼀个位置就是⻝物
     if (NextIsFood(pNextNode, ps))
     {
         EatFood(pNextNode, ps);
     }
     else//如果没有⻝物
     {
         NoFood(pNextNode, ps);
     }
     KillByWall(ps);
     KillBySelf(ps);
}
2.3.3.1 NextIsFood
//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnakeNode psn, pSnake ps)
{
     return (psn->x == ps->_pFood->x) && (psn->y == ps->_pFood->y);
}
2.3.3.2 EatFood
//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
void EatFood(pSnakeNode psn, pSnake ps)
{
     //头插法
     psn->next = ps->_pSnake;
     ps->_pSnake = psn;
 
     //打印蛇
     pSnakeNode cur = ps->_pSnake;
     while (cur)
     {
         SetPos(cur->x, cur->y);
         wprintf(L"%c", BODY);
         cur = cur->next;
     }
     ps->_Socre += ps->_foodWeight;
 
     //释放⻝物节点
     free(ps->_pFood);
     //创建新的⻝物
     CreateFood(ps);
}
2.3.3.3 NoFood

将下⼀个节点头插⼊蛇的⾝体，并将之前蛇⾝最后⼀个节点打印为空格，释放掉蛇⾝的最后⼀个节
点。
易错点： 这里最容易错误的是，释放最后⼀个结点后，还得将指向在最后⼀个结点的指针改为NULL，
保证蛇尾打印可以正常结束，不会越界访问。

 //pSnakeNode psn 是下⼀个节点的地址
 //pSnake ps 维护蛇的指针
 void NoFood(pSnakeNode psn, pSnake ps)
 {
     //头插法
     psn->next = ps->_pSnake;
     ps->_pSnake = psn;
     
     //打印蛇
     pSnakeNode cur = ps->_pSnake;
     while (cur->next->next)
     {
         SetPos(cur->x, cur->y);
         wprintf(L"%c", BODY);
         cur = cur->next;
     }

     //最后⼀个位置打印空格，然后释放节点
     SetPos(cur->next->x, cur->next->y);
     printf(" ");
     free(cur->next);
     cur->next = NULL;
 }
2.3.3.4 KillByWall

判断蛇头的坐标是否和墙的坐标冲突

//pSnake ps 维护蛇的指针

 int KillByWall(pSnake ps)
 {
     if ((ps->_pSnake->x == 0)|| (ps->_pSnake->x == 56)|| (ps->_pSnake->y == 0)|| (ps->_pSnake->y == 26))
     {
         ps->_Status = KILL_BY_WALL;
         return 1;
     }
     return 0;
 }
2.3.3.5 KillBySelf

判断蛇头的坐标是否和蛇⾝体的坐标冲突

//pSnake ps 维护蛇的指针
 int KillBySelf(pSnake ps)
 {
     pSnakeNode cur = ps->_pSnake->next;
     while (cur)
     {
         if ((ps->_pSnake->x == cur->x)
         && (ps->_pSnake->y == cur->y))
         {
             ps->_Status = KILL_BY_SELF;
             return 1;
         }
     cur = cur->next;
     }
     return 0;
 }

2.4 游戏结束

游戏状态不再是OK（游戏继续）的时候，要告知游戏结束的原因，并且释放蛇⾝节点。

void GameEnd(pSnake ps)
{
     pSnakeNode cur = ps->_pSnake;
     SetPos(24, 12);
     switch (ps->_Status)
     {
         case END_NOMAL:
         printf("您主动退出游戏\n");
         break;
         case KILL_BY_SELF:
         printf("您撞上⾃⼰了 ,游戏结束!\n");
         break;
         case KILL_BY_WALL:
         printf("您撞墙了,游戏结束!\n");
         break;
     }
     //释放蛇⾝的节点
     while (cur)
     {
         pSnakeNode del = cur;
         cur = cur->next;
         free(del);
     }
}

3. 参考代码

完整代码实现，分3个⽂件实现
test.cpp

#include "Snake.h"
#include <locale.h>
void test()
{
     int ch = 0;
     srand((unsigned int)time(NULL));
     do
     {
         Snake snake = { 0 };
         GameStart(&snake);
         GameRun(&snake);
         GameEnd(&snake);
         SetPos(20, 15);
         printf("再来⼀局吗？(Y/N):");
         ch = getchar();
         getchar();//清理\n
     } while (ch == 'Y' || ch == 'y');
     SetPos(0, 27);
}

int main()
{
     //修改当前地区为本地模式，为了⽀持中⽂宽字符的打印
     setlocale(LC_ALL, "");
     //测试逻辑
     test();
     return 0;
}

snake.h

#pragma once
#include <windows.h>
#include <time.h>
#include <stdio.h>
#define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1) ? 1 : 0)
//⽅向
enum DIRECTION
{
 UP = 1,
 DOWN,
 LEFT,
 RIGHT
};
//游戏状态
enum GAME_STATUS
{
 OK,//正常运⾏
 KILL_BY_WALL,//撞墙
 KILL_BY_SELF,//咬到⾃⼰
 END_NOMAL//正常结束
};
#define WALL L'□'
#define BODY L'●' //★○●◇◆□■
#define FOOD L'★' //★○●◇◆□■
//蛇的初始位置
#define POS_X 24
#define POS_Y 5
//蛇⾝节点
typedef struct SnakeNode
{
 int x;
 int y;
 struct SnakeNode* next;
}SnakeNode, * pSnakeNode;
typedef struct Snake
{
 pSnakeNode _pSnake;//维护整条蛇的指针
 pSnakeNode _pFood;//维护⻝物的指针
 enum DIRECTION _Dir;//蛇头的⽅向默认是向右
 enum GAME_STATUS _Status;//游戏状态
 int _Socre;//当前获得分数
 int _foodWeight;//默认每个⻝物10分
 int _SleepTime;//每⾛⼀步休眠时间
}Snake, * pSnake;
//游戏开始前的初始化
void GameStart(pSnake ps);
//游戏运⾏过程
void GameRun(pSnake ps);
//游戏结束
void GameEnd(pSnake ps);
//设置光标的坐标
void SetPos(short x, short y);
//欢迎界⾯
void WelcomeToGame();
//打印帮助信息
void PrintHelpInfo();
//创建地图
void CreateMap();
//初始化蛇
void InitSnake(pSnake ps);
//创建⻝物
void CreateFood(pSnake ps);
//暂停响应
void pause();
//下⼀个节点是⻝物
int NextIsFood(pSnakeNode psn, pSnake ps);
//吃⻝物
void EatFood(pSnakeNode psn, pSnake ps);
//不吃⻝物
void NoFood(pSnakeNode psn, pSnake ps);
//撞墙检测
int KillByWall(pSnake ps);
//撞⾃⾝检测
int KillBySelf(pSnake ps);
//蛇的移动
void SnakeMove(pSnake ps);
//游戏初始化
void GameStart(pSnake ps);
//游戏运⾏
void GameRun(pSnake ps);
//游戏结束
void GameEnd(pSnake ps);

snake.cpp

#include "Snake.h"
//设置光标的坐标
void SetPos(short x, short y)
{
 COORD pos = { x, y };
 HANDLE hOutput = NULL;
 //获取标准输出的句柄(⽤来标识不同设备的数值)
 hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
 //设置标准输出上光标的位置为pos
 SetConsoleCursorPosition(hOutput, pos);
}
void WelcomeToGame()
{
 SetPos(40, 15);
 printf("欢迎来到贪吃蛇⼩游戏");
 SetPos(40, 25);//让按任意键继续的出现的位置好看点
 system("pause");
 system("cls");
 SetPos(25, 12);
 printf("⽤ ↑ . ↓ . ← . → 分别控制蛇的移动， F3为加速，F4为减速\n");
 SetPos(25, 13);
 printf("加速将能得到更⾼的分数。\n");
 SetPos(40, 25);//让按任意键继续的出现的位置好看点
 system("pause");
 system("cls");
}
void CreateMap()
{
 int i = 0;
 //上(0,0)-(56, 0)
 SetPos(0, 0);
 for (i = 0; i < 58; i += 2)
 {
 wprintf(L"%c", WALL);
 }
 //下(0,26)-(56, 26)
 SetPos(0, 26);
 for (i = 0; i < 58; i += 2)
 {
 wprintf(L"%c", WALL);
 }
 //左
 //x是0，y从1开始增⻓
 for (i = 1; i < 26; i++)
 {
 SetPos(0, i);
 wprintf(L"%c", WALL);
 }
 //x是56，y从1开始增⻓
 for (i = 1; i < 26; i++)
 {
 SetPos(56, i);
 wprintf(L"%c", WALL);
 }
}
void InitSnake(pSnake ps)
{
 pSnakeNode cur = NULL;
 int i = 0;
 //创建蛇⾝节点，并初始化坐标
 //头插法
 for (i = 0; i < 5; i++)
 {
 //创建蛇⾝的节点
 cur = (pSnakeNode)malloc(sizeof(SnakeNode));
 if (cur == NULL)
 {
 perror("InitSnake()::malloc()");
 return;
 }
 //设置坐标
 cur->next = NULL;
 cur->x = POS_X + i * 2;
 cur->y = POS_Y;
 //头插法
 if (ps->_pSnake == NULL)
 {
 ps->_pSnake = cur;
 }
 else
 {
 cur->next = ps->_pSnake;
 ps->_pSnake = cur;
 }
 }
 //打印蛇的⾝体
 cur = ps->_pSnake;
 while (cur)
 {
 SetPos(cur->x, cur->y);
 wprintf(L"%c", BODY);
 cur = cur->next;
 }
 //初始化贪吃蛇数据
 ps->_SleepTime = 200;
 ps->_Socre = 0;
 ps->_Status = OK;
 ps->_Dir = RIGHT;
 ps->_foodWeight = 10;
}
void CreateFood(pSnake ps)
{
 int x = 0;
 int y = 0;
again:
 //产⽣的x坐标应该是2的倍数，这样才可能和蛇头坐标对⻬。
 do
 {
 x = rand() % 53 + 2;
 y = rand() % 25 + 1;
 } while (x % 2 != 0);
 pSnakeNode cur = ps->_pSnake;//获取指向蛇头的指针
 //⻝物不能和蛇⾝冲突
 while (cur)
 {
 if (cur->x == x && cur->y == y)
 {
 goto again;
 }
 cur = cur->next;
 }
 pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode)); //创建⻝物
 if (pFood == NULL)
 {
 perror("CreateFood::malloc()");
 return;
 }
 else
 {
 pFood->x = x;
 pFood->y = y;
 SetPos(pFood->x, pFood->y);
 wprintf(L"%c", FOOD);
 ps->_pFood = pFood;
 }
}
void PrintHelpInfo()
{
 //打印提⽰信息
 SetPos(64, 15);
 printf("不能穿墙，不能咬到⾃⼰\n");
 SetPos(64, 16);
 printf("⽤↑.↓.←.→分别控制蛇的移动.");
 SetPos(64, 17);
 printf("F3 为加速，F4 为减速\n");
 SetPos(64, 18);
 printf("ESC ：退出游戏.space：暂停游戏.");
 SetPos(64, 20);
 printf("⽐特就业课@版权");
}
void pause()//暂停
{
 while (1)
 {
 Sleep(300);
 if (KEY_PRESS(VK_SPACE))
 {
 break;
 }
 }
}
//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnakeNode psn, pSnake ps)
{
 return (psn->x == ps->_pFood->x) && (psn->y == ps->_pFood->y);
}
//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
void EatFood(pSnakeNode psn, pSnake ps)
{
 //头插法
 psn->next = ps->_pSnake;
 ps->_pSnake = psn;
 pSnakeNode cur = ps->_pSnake;
 //打印蛇
 while (cur)
 {
 SetPos(cur->x, cur->y);
 wprintf(L"%c", BODY);
 cur = cur->next;
 }
 ps->_Socre += ps->_foodWeight;
 free(ps->_pFood);
 CreateFood(ps);
}
//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
void NoFood(pSnakeNode psn, pSnake ps)
{
 //头插法
 psn->next = ps->_pSnake;
 ps->_pSnake = psn;
 pSnakeNode cur = ps->_pSnake;
 //打印蛇
 while (cur->next->next)
 {
 SetPos(cur->x, cur->y);
 wprintf(L"%c", BODY);
 cur = cur->next;
 }
 //最后⼀个位置打印空格，然后释放节点
 SetPos(cur->next->x, cur->next->y);
 printf(" ");
 free(cur->next);
 cur->next = NULL;
}
//pSnake ps 维护蛇的指针
int KillByWall(pSnake ps)
{
 if ((ps->_pSnake->x == 0)
 || (ps->_pSnake->x == 56)
 || (ps->_pSnake->y == 0)
 || (ps->_pSnake->y == 26))
 {
 ps->_Status = KILL_BY_WALL;
 return 1;
 }
 return 0;
}
//pSnake ps 维护蛇的指针
int KillBySelf(pSnake ps)
{
 pSnakeNode cur = ps->_pSnake->next;
 while (cur)
 {
 if ((ps->_pSnake->x == cur->x)
 && (ps->_pSnake->y == cur->y))
 {
 ps->_Status = KILL_BY_SELF;
 return 1;
 }
 cur = cur->next;
 }
 return 0;
}
void SnakeMove(pSnake ps)
{
 //创建下⼀个节点
 pSnakeNode pNextNode = (pSnakeNode)malloc(sizeof(SnakeNode));
 if (pNextNode == NULL)
 {
 perror("SnakeMove()::malloc()");
 return;
 }
 //确定下⼀个节点的坐标，下⼀个节点的坐标根据，蛇头的坐标和⽅向确定
 switch (ps->_Dir)
 {
 case UP:
 {
 pNextNode->x = ps->_pSnake->x;
 pNextNode->y = ps->_pSnake->y - 1;
 }
 break;
 case DOWN:
 {
 pNextNode->x = ps->_pSnake->x;
 pNextNode->y = ps->_pSnake->y + 1;
 }
 break;
 case LEFT:
 {
 pNextNode->x = ps->_pSnake->x - 2;
 pNextNode->y = ps->_pSnake->y;
 }
 break;
 case RIGHT:
 {
 pNextNode->x = ps->_pSnake->x + 2;
 pNextNode->y = ps->_pSnake->y;
 }
 break;
 }
 //如果下⼀个位置就是⻝物
 if (NextIsFood(pNextNode, ps))
 {
 EatFood(pNextNode, ps);
 }
 else//如果没有⻝物
 {
 NoFood(pNextNode, ps);
 }
 KillByWall(ps);
 KillBySelf(ps);
}
void GameStart(pSnake ps)
{
 //设置控制台窗⼝的⼤⼩，30⾏，100列
 //mode 为DOS命令
 system("mode con cols=100 lines=30");
 //设置cmd窗⼝名称
 system("title 贪吃蛇"); 
 //获取标准输出的句柄(⽤来标识不同设备的数值)
 HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
 //影藏光标操作
 CONSOLE_CURSOR_INFO CursorInfo;
 GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
 CursorInfo.bVisible = false; //隐藏控制台光标
 SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
 //打印欢迎界⾯
 WelcomeToGame();
 //打印地图
 CreateMap();
 //初始化蛇
 InitSnake(ps);
 //创造第⼀个⻝物
 CreateFood(ps);
}
void GameRun(pSnake ps)
{
 //打印右侧帮助信息
 PrintHelpInfo();
 do
 {
 SetPos(64, 10);
 printf("得分：%d ", ps->_Socre);
 printf("每个⻝物得分：%d分", ps->_foodWeight);
 if (KEY_PRESS(VK_UP) && ps->_Dir != DOWN)
 {
 ps->_Dir = UP;
 }
 else if (KEY_PRESS(VK_DOWN) && ps->_Dir != UP)
 {
 ps->_Dir = DOWN;
 }
 else if (KEY_PRESS(VK_LEFT) && ps->_Dir != RIGHT)
 {
 ps->_Dir = LEFT;
 }
 else if (KEY_PRESS(VK_RIGHT) && ps->_Dir != LEFT)
 {
 ps->_Dir = RIGHT;
 }
 else if (KEY_PRESS(VK_SPACE))
 {
 pause();
 }
 else if (KEY_PRESS(VK_ESCAPE))
 {
 ps->_Status = END_NOMAL;
 break;
 }
 else if (KEY_PRESS(VK_F3))
 {
 if (ps->_SleepTime >= 50)
 {
 ps->_SleepTime -= 30;
 ps->_foodWeight += 2;
 }
 }
 else if (KEY_PRESS(VK_F4))
 {
 if (ps->_SleepTime < 350)
 {
 ps->_SleepTime += 30;
 ps->_foodWeight -= 2;
 if (ps->_SleepTime == 350)
 {
 ps->_foodWeight = 1;
 }
 }
 }
 //蛇每次⼀定之间要休眠的时间，时间短，蛇移动速度就快
 Sleep(ps->_SleepTime);
 SnakeMove(ps);
 } while (ps->_Status == OK);
}
void GameEnd(pSnake ps)
{
 pSnakeNode cur = ps->_pSnake;
 SetPos(24, 12);
 switch (ps->_Status)
 {
 case END_NOMAL:
 printf("您主动退出游戏\n");
 break;
 case KILL_BY_SELF:
 printf("您撞上⾃⼰了 ,游戏结束!\n");
 break;
 case KILL_BY_WALL:
 printf("您撞墙了,游戏结束!\n");
 break;
 }
 //释放蛇⾝的节点
 while (cur)
 {
 pSnakeNode del = cur;
 cur = cur->next;
 free(del);
 }
}

今天我们将学会实现贪吃蛇小游戏，如果本篇有不理解的地方，欢迎私信我或在评论区指出，期待与你们共同进步。创作不易，望各位大佬一键三连！

相关推荐
爱吃西瓜的小菜鸡17 分钟前
【C语言】判断回文
c语言·学习·算法
别NULL19 分钟前
机试题——疯长的草
数据结构·c++·算法
小A15940 分钟前
STM32完全学习——SPI接口的FLASH（DMA模式）
stm32·嵌入式硬件·学习
飞飞-躺着更舒服1 小时前
【QT】实现电子飞行显示器（改进版）
开发语言·qt
岁岁岁平安1 小时前
spring学习(spring-DI(字符串或对象引用注入、集合注入)(XML配置))
java·学习·spring·依赖注入·集合注入·基本数据类型注入·引用数据类型注入
武昌库里写JAVA1 小时前
Java成长之路（一）--SpringBoot基础学习--SpringBoot代码测试
java·开发语言·spring boot·学习·课程设计
qq_589568101 小时前
数据可视化echarts学习笔记
学习·信息可视化·echarts
ZSYP-S2 小时前
Day 15：Spring 框架基础
java·开发语言·数据结构·后端·spring
yuanbenshidiaos2 小时前
c++------------------函数
开发语言·c++
唐叔在学习2 小时前
【唐叔学算法】第21天：超越比较-计数排序、桶排序与基数排序的Java实践及性能剖析
数据结构·算法·排序算法
热门推荐
01构建高效的广告投放系统：应用架构的设计与实现02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO