一、代码目标
1.地图绘制
2.蛇的移动(包含吃食物,不吃食物)
3.蛇的死亡(正常退出、撞墙死亡、撞到自己死亡)
4.分数计算
5、加速减速
6.暂停游戏、游戏重复
二、代码的实现前的准备
在哪里玩贪吃蛇呢?windows控制台。首先我们要学会调整控制台的相关指令win32 API。(WIN32 API是 32位平台的应用程序编程接口)
1.
控制台程序
平常我们运行起来的窗口就是控制台程序,我们可以使用cmd命令来设置控制台窗口的长宽:设置控制台大小30行,100列, 设置控制台窗口名称为:“贪吃蛇”,用到system函数,包含stdlib.h头文件
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
system("mode con cols=100 lines=30");
system("title 贪吃蛇");
getchar();
return 0;
}
此处利用getchar();来控制不要让程序结束,否则无法看到被修改的标题
效果:
---------------------------------------------------------------------------------------------------------------------------------
控制台坐标COORD
COORD是Windows API 中定义的一个结构体,表示一个字符在控制台屏幕缓冲区上的坐标,坐标
(0,0)的原点位于缓冲区的顶部左侧单元格。
COORD类型声明:
typedef struct _COORD {
SHORT X;
SHORT Y;
} COORD, *PCOORD;
//注意这里是短整型
给坐标赋值:
COORD pos = { 10, 15 }
---------------------------------------------------------------------------------------------------------------------------------
API函数:GetStdHandle
GetStdHandle是⼀个Windows API函数。它⽤于从⼀个特定的标准设备(标准输⼊、标准输出或标 准错误)中取得⼀个句柄(⽤来标识不同设备的数值),使⽤这个句柄可以操作设备。
简单理解:有了它才能找见是那个窗口,从而进行操控
HANDLE GetStdHandle(DWORD nStdHandle);
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
经过以上操作就存在了hOutput里。
API函数:GetConsoleCursorInfo
检索有关指定控制台屏幕缓冲区的光标⼤⼩和可⻅性的信息
BOOL WINAPI GetConsoleCursorInfo(
HANDLE hConsoleOutput,
PCONSOLE_CURSOR_INFO lpConsoleCursorInfo
);
PCONSOLE_CURSOR_INFO 是指向 CONSOLE_CURSOR_INFO 结构的指针,该结构接收有关主机游标
eg:
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
要传入句柄和 CONSOLE_CURSOR_INFO类型结构体的地址
CONSOLE_CURSOR_INFO:结构体,包含控制台光标信息
typedef struct _CONSOLE_CURSOR_INFO {
DWORD dwSize;
BOOL bVisible;
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;
dwSize:光标填充占比,为百分比值,介于1-100之间
bVisible:可见性。TRUE / FALSE ----- 可见 / 不可见
隐藏光标如下:
CursorInfo.bVisible = false;
SetConsoleCursorInfo :设定指定控制台屏幕缓冲区的光标的大小和可见性。
BOOL WINAPI SetConsoleCursorInfo(
HANDLE hConsoleOutput,
const CONSOLE_CURSOR_INFO *lpConsoleCursorInfo
);
应用:
HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//影藏光标操作
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息
CursorInfo.bVisible = false; //隐藏控制台光标
SetConsoleCursorInfo(hOutput, &CursorInfo);//设置控制台光标状态
SetConsoleCursorPosition :设置指定控制台屏幕缓冲区中的光标位置
BOOL WINAPI SetConsoleCursorPosition(
HANDLE hConsoleOutput,
COORD pos
);
应用:
COORD pos = { 10, 5};
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//设置标准输出上光标的位置为pos
SetConsoleCursorPosition(hOutput, pos);
--------------------------------------------------------------------------------------------------------------------------------
SetPos:封装一个设置光标位置的函数(传坐标即可定位光标)
//设置光标的坐标
void SetPos(short x, short y)
{
COORD pos = { x, y };
HANDLE hOutput = NULL;
//获取标准输出的句柄(⽤来标识不同设备的数值)
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//设置标准输出上光标的位置为pos
SetConsoleCursorPosition(hOutput, pos);
}
---------------------------------------------------------------------------------------------------------------------------------
GetAsyncKeyState:获取按键情况
SHORT GetAsyncKeyState(
int vKey
);
将键盘上的每个键的虚拟键值传递给函数,函数通过返回值来分辨按键的状态。
GetAsyncKeyState的返回值是short类型,在上一次调用后,如果返回的16位的short数据中,最高位是1,说明按键的状态是按下,如果最高时0,说明按键的状态是抬起;如果最低位被置为1则说明被按过,否则为0。
#define KEY_PRESS(VK) ( (GetAsyncKeyState(VK) & 0x1) ? 1 : 0 )
虚拟键码:虚拟键码 (Winuser.h) - Win32 apps | Microsoft Learn
eg:检测数字键
#include <stdio.h>
#include <windows.h>
int main()
{
while (1)
{
if (KEY_PRESS(0x30))
{
printf("0\n");
}
else if (KEY_PRESS(0x31))
{
printf("1\n");
}
else if (KEY_PRESS(0x32))
{
printf("2\n");
}
else if (KEY_PRESS(0x33))
{
printf("3\n");
}
else if (KEY_PRESS(0x34))
{
printf("4\n");
}
else if (KEY_PRESS(0x35))
{
printf("5\n");
}
else if (KEY_PRESS(0x36))
{
printf("6\n");
}
else if (KEY_PRESS(0x37))
{
printf("7\n");
}
else if (KEY_PRESS(0x38))
{
printf("8\n");
}
else if (KEY_PRESS(0x39))
{
printf("9\n");
}
}
return 0;
}
效果:按0 - 9中该数个就在屏幕上打印。
---------------------------------------------------------------------------------------------------------------------------------
三、贪吃蛇游戏设计与分析
最终呈现结构图下,那么地图如何布置?
控制台窗口坐标以左上为原点,向右X增长,向下Y增长
在游戏地图上,我们打印墙体使⽤宽字符:□,打印蛇使⽤宽字符●,打印⻝物使⽤宽字符★ 普通的字符是占⼀个字节的,这类宽字符是占⽤2个字节。
为了能使宽字符输出,需要进行本地化。用到<locale.h>头文件和setlocaleh函数
char* setlocale (int category, const char* locale);
第一个参数选择:LC_ALL, 第二个参数选择“”(切换到本地环境)
setlocale(LC_ALL, " ");//切换到本地环境
宽体字符打印:wprintf(L"%lc",L'字符')
eg:
#include <stdio.h>
#include<locale.h>
int main()
{ setlocale(LC_ALL, "");
wchar_t ch1 = L'●';
wchar_t ch2 = L'★';
printf("%c%c\n", 'a', 'b');
wprintf(L"%lc\n", ch1);
wprintf(L"%lc\n", ch2);
return 0;
}
一个字符占两个正常字母位置
---------------------------------------------------------------------------------------------------------------------------------
地图坐标
假设一个27行,58列的棋盘,再围绕地图画出墙
---------------------------------------------------------------------------------------------------------------------------------
蛇身和食物
初始状态,假设蛇长度为5,在固定一个坐标处,比如(24,5)处开始出现蛇,连续5个节点。
注意:蛇的每个节点的x坐标必须是2个倍数,否则可能会出现蛇的⼀个节点有⼀半⼉出现在墙体中, 另外⼀般在墙外的现象,坐标不好对⻬。 关于⻝物,就是在墙体内随机⽣成⼀个坐标(x坐标必须是2的倍数),坐标不能和蛇的⾝体重合,然 后打印★。
---------------------------------------------------------------------------------------------------------------------------------
数据结构设计:
在游戏运⾏的过程中,蛇每次吃⼀个⻝物,蛇的⾝体就会变⻓⼀节,如果我们使⽤链表存储蛇的信 息,那么蛇的每⼀节其实就是链表的每个节点。每个节点只要记录好蛇⾝节点在地图上的坐标就⾏, 所以蛇节点结构如下:
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;
顺便定义结构体指针为pSnake;(_pSnake指向蛇头)
蛇的方向(枚举)
//⽅向
enum DIRECTION
{
UP = 1,
DOWN,
LEFT,
RIGHT
};
游戏状态(枚举)
//游戏状态
enum GAME_STATUS
{
OK,//正常运⾏
KILL_BY_WALL,//撞墙
KILL_BY_SELF,//咬到⾃⼰
END_NOMAL//正常结束
};
---------------------------------------------------------------------------------------------------------------------------------
游戏流程设计:
---------------------------------------------------------------------------------------------------------------------------------
三、代码实现
首先要设置支持本地模式,然后进入主逻辑
1.游戏开始(GameStart)完场游戏的初始化
2.游戏运行(GameRun)完成游戏运行逻辑
3.游戏结束(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;
}
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);
}
接下来依次实现:
//打印欢迎界⾯ WelcomeToGame();
//打印地图 CreateMap();
//初始化蛇 InitSnake(ps);
//创造第⼀个⻝物 CreateFood(ps);
---------------------------------------------------------------------------------------------------------------------------------
WelcomeToGame():
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");
}
打印墙体:坐标计算(分四边打印),顺便重新定义墙体字符打印时的一串字符为WALL,蛇身为BODY,食物为FOOD。
#define WALL L'□'
#define BODY L'●'
#define FOOD 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);
}
}
InitSnake(ps):初始化蛇身
蛇的起始长度为5节,分别对应链表的一个节点,蛇身的每一个节点都有自己的坐标。
创建5个节点,然后将每个节点存放在链表中进行管理。创建完之后,打印到屏幕上。
• 蛇的初始位置从 (24,5) 开始。
再设置当前游戏的状态,蛇移动的速度,默认的⽅向,初始成绩,每个⻝物的分数。
• 游戏状态是:OK
• 蛇的移动速度:200毫秒
• 蛇的默认⽅向:RIGHT
• 初始成绩:0
• 每个⻝物的分数:10
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;
}
CreateFood(ps);创建食物
• 先随机⽣成⻝物的坐标
◦ x坐标必须是2的倍数
◦ ⻝物的坐标不能和蛇⾝每个节点的坐标重复
• 创建⻝物节点,打印⻝物
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
{
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;
}
}
---------------------------------------------------------------------------------------------------------------------------------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);
}
为了检测按键,封装一个宏
#define KEY_PRESS(VK) ((GetAsyncKeyState(VK)&0x1) ? 1 : 0)
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);
}
在GameRun中定好蛇的方向,速度,就可以让蛇走动了
SnakeMove(蛇身移动)
原理:
1.创建下一个节点(根据移动方向和蛇头坐标,移动到下一个位置的坐标)
2.确定了下一个位置后,看下一个位置是否是食物(NextFood),是食物就吃(EatFood),
不是食物就(NoFood)。
3.移动后判断是否会撞墙(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;//注意x加减是2,y是1
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);
}
NextIsFood:
//pSnakeNode psn 是下⼀个节点的地址
//pSnake ps 维护蛇的指针
int NextIsFood(pSnakeNode psn, pSnake ps)
{
return (psn->x == ps->_pFood->x) && (psn->y == ps->_pFood->y);
}
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);
}
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;
}
判断是否死亡(都是用坐标是否重合判断)
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;
}
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;
}
GameEnd(游戏结束)
游戏状态不再是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);
}
}
**************************************************************************************************************参考代码
Snake.h
#pragma once//本次代码为抄写,在于理解贪吃蛇的所有结构,便于以后复习
#include<windows.h>
#include<stdbool.h>
#include<stdlib.h>
#include<stdio.h>
#include<time.h>
#define POS_X 24
#define POS_Y 5
#define WALL L'□'
#define BODY L'●'
#define FOOD L'★'
//类型声明
//蛇的方向
enum DRECTION
{
UP = 1,
DOWN,
LEFT,
RIGHT
};
//蛇的状态
//正常,撞墙,撞到自己,正常退出
enum GAME_STATUS
{
OK,//正常
KILL_BY_WALL,//撞墙
KILL_BY_SELF,//撞到自己
END_NORMAL//正常退出
};
//蛇身节点类型
typedef struct SnakeNode
{
//坐标
int x;
int y;
//指向下一个节点的指针
struct SnakeNode* next;
}SnakeNode, * pSnakeNode;
//typedef struct SnakeNode pSnakeNode
//贪吃蛇
typedef struct Snake
{
pSnakeNode _pSnake;//指向蛇头的指针
pSnakeNode _pFood;//指向食物的指针
enum DIRECTION _dir;//蛇的方向
enum GAME_STATUS _status;//游戏的状态
int _food_weight;//一个食物的分数
int _score;//总成绩
int _sleep_time;//休息时间,越短速度越快,越长速度越慢
}Snake,* pSnake;
//函数声明
//定位光标位置
void SetPos(short x, short y);
//游戏的初始化
void GameStart(pSnake ps);
//欢迎界面打印
void WelcomeToGame();
//创建地图
void CreateMap();
//初始化蛇身
void InitSnake(pSnake ps);
//创建食物
void CreateFood(pSnake ps);
//游戏运行逻辑
void GameRun(pSnake ps);
//蛇的移动-走一步
void SnakeMove(pSnake ps);
//判断下一个坐标是否是食物
int NextIsFood(pSnakeNode pn, pSnake ps);
//下一个位置是食物,就吃掉食物
void EatFood(pSnakeNode pn, pSnake ps);
//下一个不是食物
void NoFood(pSnakeNode pn, pSnake ps);
//检测蛇是否撞墙
void KillByWall(pSnake ps);
//检测蛇是否撞到自己
void KillBySelf(pSnake ps);
//游戏的善后工作
void GameEnd(pSnake ps);
Snake.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"snake.h"
void SetPos(short x, short y)//为什么用短整型?因为坐标结构体内规定的就是短整型
{
//获得标准输出设备的句柄
HANDLE houtput = NULL;
houtput = GetStdHandle(STD_OUTPUT_HANDLE);
//定位光标的位置
COORD pos = { x, y };
SetConsoleCursorPosition(houtput, pos);//设置位置(相当于上一行给的是值,这一行实际应用把值传过去了)
}
void WelcomeToGame()
{
SetPos(40, 14);
wprintf(L"欢迎来到贪吃蛇小游戏\n");
SetPos(42, 20);
system("pause");
system("clc");
SetPos(25, 14);
wprintf(L"用↑.↓.←.→ 来控制蛇的移动,按F3加速,F4减速\n");
SetPos(25, 15);
wprintf(L"加速能够得到更高的分数\n");
SetPos(42, 20);
system("pause");
system("cls");
}
void CreateMap()
{
//上
int i = 0;
for (i = 0; i < 29; i++)
{
wprintf(L"%lc", WALL);
}
//下
SetPos(0, 25);
for (i = 0; i < 29; i++)
{
wprintf(L"%lc", WALL);
}
//左
for (i = 1; i < 25; i++)
{
SetPos(0, i);
wprintf(L"%lc", WALL);
}
//右
for (i = 1; i < 25; i++)
{
SetPos(56, i);
wprintf(L"%lc", WALL);
}
}
void InitSnake(pSnake ps)
{
int i = 0;
pSnakeNode cur = NULL;
for (i = 0; i < 5; i++)
{
cur = (pSnakeNode)malloc(sizeof(SnakeNode));//pSnakeNode == *SnakeNode
if (cur == NULL)
{
perror("malloc fail!");
return;
}
cur->next = NULL;
cur->x = POS_X + 2 * i;
cur->y = POS_Y;//放入初始蛇(假定长度5)
//头插法插入链表
if (ps->_pSnake == NULL)//空链表
{
ps->_pSnake = cur;//直接让新节点当头节点(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->_dir = RIGHT;//初始移动方向向右
ps->_score = 0;//初始总分是0
ps->_food_weight = 10;//单个食物奖励10分
ps->_sleep_time = 200;//移动步骤间隔200ms
ps->_status = OK;//存活状态:OK
}
void CreateFood(pSnake ps)
{
int x = 0;
int y = 0;
//生成x是2的倍数,因为蛇身一个节点占据两个字节
//x:2 - 54
//y:1 - 25
again:
do
{
x = rand() % 53 + 2;//%53,x在0 - 52之间,加上2则为 2 - 54之间
y = rand() % 24 + 1;
} while (x % 2 != 0);//while排除x为奇数的情况
//x和y的坐标不能和蛇身体冲突
pSnakeNode cur = ps->_pSnake;//定义一个指针指向蛇头
while (cur)//遍历蛇身节点看是否有重复,有重复回到do--while循环重新申请
{
if (x == cur->x && y == cur->y)
{
goto again;
}
cur = cur->next;
}
//有了食物坐标,开始创建食物节点
pSnakeNode pFood = (pSnakeNode)malloc(sizeof(SnakeNode));//申请空间
if (pFood == NULL)
{
perror("malloc fail!");
return;
}
pFood->x = x;
pFood->y = y;
pFood->next = NULL;//输入值
SetPos(x, y);//定位位置
wprintf(L"%lc", FOOD);//打印上食物的图案
ps->_pFood = pFood;//使_Food指针指向新创建的食物节点
}
void GameStart(pSnake ps)
{
//0.先设置窗口大小,再光标隐藏
system("mode con cols=100 lines=30");
system("title 贪吃蛇");
HANDLE houtput = GetStdHandle(STD_OUTPUT_HANDLE);
//隐藏光标
CONSOLE_CURSOR_INFO CursorInfo;//定义光标结构体
GetConsoleCursorInfo(houtput, &CursorInfo);//获取控制台光标信息
CursorInfo.bVisible = false; //隐藏控制台光标
SetConsoleCursorInfo(houtput, &CursorInfo);//设置控制台光标状态
//1. 打印环境界面和功能介绍
WelcomeToGame();
//2. 绘制地图
CreateMap();
//3. 创建蛇
InitSnake(ps);
//4. 创建食物
CreateFood(ps);
}
void PrintHelpInfo()//打印提示信息以及分数信息等
{
SetPos(64, 14);
wprintf(L"%ls", L"不能穿墙,不能咬到自己");
SetPos(64, 15);
wprintf(L"%ls", L"用↑.↓.←.→ 来控制蛇的移动");
SetPos(64, 16);
wprintf(L"%ls", L"按F3加速,F4减速");
SetPos(64, 17);
wprintf(L"%ls", L"ESC退出游戏,按空格暂停游戏");
}
#define KEY_PRESS(vk) ((GetAsyncKeyState(vk) & 1 ? 1 : 0))
void Pause()
{
while (1)
{
Sleep(1000);
if (KEY_PRESS(VK_ESCAPE))
{
break;
}
}
}
int NextIsFood(pSnakeNode pn, pSnake ps)//判断下一个是不是食物(下一个节点是否与食物节点重合)
{
return(ps->_pFood->x == pn->x && ps->_pFood->y == pn->y);
}
void EatFood(pSnakeNode pn, pSnake ps)
{
//头插
ps->_pFood->next = ps->_pSnake;//食物的下一个节点指向蛇头节点
ps->_pSnake = ps->_pFood;//头结点更新
//释放下一个位置的节点(下一个节点和食物节点在显示器上是一个位置,所以只需要一个,剩下的一个释放掉)
free(pn);
pn = NULL;
pSnakeNode cur = ps->_pSnake;
//打印蛇
while (cur)
{
SetPos(cur->x, cur->y);//传坐标,使得光标移动到给定XY
wprintf(L"%lc", BODY);
cur = cur->next;
}
ps->_score += ps->_food_weight;//吃食物加分
//重新创建食物
CreateFood(ps);
}
void NoFood(pSnakeNode pn, pSnake ps)
{
//头插法
pn->next = ps->_pSnake;//头插
ps->_pSnake = pn;//更新头结点
pSnakeNode cur = ps->_pSnake;//定义一个cur节点指向头结点
while (cur->next->next != NULL)//这样设定条件使得cur停止在倒数第二个
{
SetPos(cur->x, cur->y);
wprintf(L"%lc", BODY);
cur = cur->next;
}
//把最后一个节点打印成空格
SetPos(cur->next->x, cur->next->y);
printf(" ");
//释放最后一个节点
free(cur->next);
//让倒数第二个节点指向NULL
cur->next = NULL;
}
void KillByWall(pSnake ps)//蛇的身体与墙重合就是碰到墙
{
if (ps->_pSnake->x == 0 || ps->_pSnake->x == 56 ||
ps->_pSnake->y == 0 || ps->_pSnake->y == 25)
{
ps->_status = KILL_BY_WALL;
}
}
void KillBySelf(pSnake ps)//蛇头与身体重合(需要遍历)就是自己碰到自己
{
pSnakeNode cur = ps->_pSnake->next;
while (cur)
{
if (cur->x == ps->_pSnake->x && cur->y == ps->_pSnake->y)
{
ps->_status = KILL_BY_SELF;
break;
}
cur = cur->next;
}
}
void SnakeMove(pSnake ps)
{
//创建一个节点,表示蛇即将到来的下一个节点
pSnakeNode pNextNode = (pSnakeNode)malloc(sizeof(SnakeNode));
if (pNextNode == NULL)
{
perror("malloc fail!");
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 GameRun(pSnake ps)
{
//打印帮助信息
PrintHelpInfo();
do
{
//打印总分数和食物的分值(循环)
SetPos(64, 10);
printf("总分数:%d\n", ps->_score);
SetPos(64, 11);
printf("当前食物的分数:%2d\n", ps->_food_weight);//用%2d是因为不用的话,二位数的时候打印不会覆盖各位
//判断按键是否按下,用修改过的宏定义返回 1 / 0;原理是按下后的返回值和1与(&)为1
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_NORMAL;
}
else if (KEY_PRESS(VK_F3))
{
//加速
if (ps->_sleep_time > 80)
{
ps->_sleep_time -= 30;
ps->_food_weight += 2;
}
}
else if (KEY_PRESS(VK_F4))
{
//减速
if (ps->_food_weight > 2)
{
ps->_sleep_time += 30;
ps->_food_weight -= 2;
}
}
SnakeMove(ps);
Sleep(ps->_sleep_time);
} while (ps->_status == OK);
}
void GameEnd(pSnake ps)
{
SetPos(24, 12);
switch (ps->_status)//检测到死亡条件弹出提示
{
case END_NORMAL:
wprintf(L"您主动结束游戏\n");
break;
case KILL_BY_WALL:
wprintf(L"您撞到墙上,游戏结束\n");
break;
case KILL_BY_SELF:
wprintf(L"您撞到了自己,游戏结束\n");
break;
}
//释放蛇身的链表,善后
pSnakeNode cur = ps->_pSnake;
while (cur)
{
pSnakeNode del = cur;
cur = cur->next;
free(del);
}
}
text.c
#define _CRT_SECURE_NO_WARNINGS 1
#include<locale.h>
#include"snake.h"
//完成的是游戏的逻辑测试
void test()
{
int ch = 0;
do
{
system("cls");//清理屏幕,防止输入的东西还在屏幕上显示
//创建贪吃蛇
Snake snake = { 0 };
//初始化游戏
//1. 打印环境界面
//2. 功能介绍
//3. 绘制地图
//4. 创建蛇
//5. 创建食物
//6. 设置游戏的相关信息
GameStart(&snake);
//运行游戏
GameRun(&snake);
//结束游戏-善后工作
GameEnd(&snake);
SetPos(20, 15);
printf("再来一局吗?(Y/N):");
ch = getchar();
while (getchar() != '\n');
} while (ch =='Y' || ch == 'y');
SetPos(0, 27);
}
int main()
{
//设置本地适配环境
setlocale(LC_ALL, "");
srand((unsigned int)time(NULL));
test();
return 0;
}