大二必做项目贪吃蛇超详解之下篇游戏核心逻辑实现

贪吃蛇系列文章

上篇win32库介绍
中篇设计与分析
下篇游戏主逻辑

可以在Gitee上获取贪吃蛇代码。

文章目录

贪吃蛇系列文章
5. 核心逻辑实现分析
- 5. 3 GameRun
- - 5. 3. 1 PrintScore
  - 5. 3. 2 CheckVK
  - 5. 3. 3 BuyNewNode
  - 5. 3. 4 NextIsFood
  - 5. 3. 4 EatFood
  - 5. 3. 5 NotFood
  - 5. 3. 6 CheckIsWall和CheckIsSelf
- 5. 4 GameOver
6. 已知Bug与一些可能的改进意见

5. 核心逻辑实现分析

5. 3 GameRun

这个部分需要完成的任务：

游戏运行期间，右侧刷新分数
根据游戏状态检查游戏是否继续，如果是状态是NORMAL，游戏继续，否则游戏结束。
如果游戏继续，就是检测按键情况，确定蛇下一步的方向，或者是否加速减速，是否暂停或者退出游戏。
检查下一步会不会吃到食物，然后走一步

需要用到的虚拟按键值：

上： 	VK_UP
下： 	VK_DOWN
左： 	VK_LEFT
右： 	VK_RIGHT
空格：	VK_SPACE
ESC：	VK_ESCAPE
F1： 	VK_F1
F2： 	VK_F2

我们先来简单地分析一下如果没有死亡，走一步大概是怎么走的：

通过前几步找到下一步走到的位置，并根据这个坐标创建一个SnakeNode作为走一步之后的头
如果下一步是食物，那就直接把这个新节点头插到蛇身上，然后再创建一个食物
如果下一步不是食物，不仅要把新节点头插上去，还需要遍历链表，把最后一个位置打印上空格（不然蛇就会越来越长），再把最后一个节点释放掉。

现在我们解释一下Snake结构体中的_SleepTime是怎么控制速度的。
首先我们要明确：程序的运行速度是非常快的，对于贪吃蛇这样的小项目来说，所有的代码都可以看作是瞬间完成的，如果直接执行，那贪吃蛇一定会在我们反应过来之前直接死亡，所以说我们需要使用Sleep函数让函数停下来一会儿来控制速度。

Sleep(unsigned long);

参数的单位是毫秒，当程序运行到这里时，可以让程序暂停参数的时长。
我们就可以借助这个函数来控制贪吃蛇的速度了，在每次走一步之后，Sleep(ps->_SleepTime);就可以了。

那么我们就可以写出来

void GameRun(pSnake ps)
{
	do	//这个循环用来控制一场游戏何时结束
	{
		//打印分数
		//打印分数应该放在最前面，不然会导致贪吃蛇在走出第一步的时候右边还没有分数
		PrintScore(ps);
		
		//检查按键
		CheckVK(ps);

		//新建一个节点，作为下一个头
		pSnakeNode nextnode = BuyNewNode(ps);

		//检查下一个是不是食物，如果是，加分并连接，走一步
		if (NextIsFood(nextnode,ps))
			EatFood(nextnode,ps);
		else
			NotFood(nextnode,ps);

		//检查是否撞到自己
		CheckIsSelf(ps);
		//检查是否撞墙
		CheckIsWall(ps);

		//休眠，控制速度
		Sleep(ps->_SleepTime);
	} while (ps->_Sta == NORMAL);
}

5. 3. 1 PrintScore

void PrintScore(pSnake ps)
{
	SetPos(64, 10);
	printf("得分：%d ", ps->_Score);
	printf("每个食物得分：%2d分", ps->_FoodAdd);
}

在打印每个食物得分的时候，因为可能这个数字是一位数，所以要使用%2d来使打印出来的数字占两个位置，不然可能会出现这样的情况：

每个食物得分：12分
//减速
每个食物得分：82分

之前打印上的 2 如果不被覆盖掉的话是不会消失的。

5. 3. 2 CheckVK

这里用到了我们自定义的一个宏：KEY_PRESS，

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

不了解的话可以前往翻看这篇博客：win32库介绍。
要实现贪吃蛇转弯，但是显而易见地转弯的时候不能转到自己的身后，所以要加以限制。
另外加速和减速时，当然不能让玩家无限制地加速或减速下去，必须做出一定限制。

void CheckVK(pSnake ps)
{
	if (KEY_PRESS(VK_UP))			//上
	{
		if (ps->_Dir != DOWN)
			ps->_Dir = UP;
	}
	else if (KEY_PRESS(VK_DOWN))	//下
	{
		if (ps->_Dir != UP)
			ps->_Dir = DOWN;
	}
	else if (KEY_PRESS(VK_LEFT))	//左
	{
		if (ps->_Dir != RIGHT)
			ps->_Dir = LEFT;
	}
	else if (KEY_PRESS(VK_RIGHT))	//右
	{
		if (ps->_Dir != LEFT)
			ps->_Dir = RIGHT;
	}
	else if (KEY_PRESS(VK_F1))		//加速
	{
		if (ps->_SleepTime >= 50)	//速度上限
		{
			ps->_SleepTime -= 30;
			ps->_FoodAdd += 2;		//记得更改每个食物的分数
		}
	}
	else if (KEY_PRESS(VK_F2))		//减速
	{
		if (ps->_SleepTime < 320)	//速度下限
		{
			ps->_SleepTime += 30;
			ps->_FoodAdd -= 2;
		}
	}
	else if (KEY_PRESS(VK_SPACE))	//空格,暂停
	{
		while (!KEY_PRESS(VK_SPACE))
		{
			//在再次点击空格之前，循环休眠
			Sleep(200);
		}
	}
	else if (KEY_PRESS(VK_ESCAPE))	//ESC，主动退出
	{
		ps->_Sta = ESC;				//注意这个ESC是我们在上篇博客中写的枚举类型的成员
	}
}

5. 3. 3 BuyNewNode

一个申请新的链表节点的函数，只是它存储的数据需要通过计算。
不过要注意，由于我们是用了宽字符，涉及到X方向的坐标改变时，我们需要±2，而Y方向还是1。

pSnakeNode BuyNewNode(pSnake ps)
{
	int newx = ps->_Head->x;
	int newy = ps->_Head->y;
	//根据链表的头结点的位置和蛇的方向找的下一个位置的头的位置
	if (ps->_Dir == LEFT)
		newx -= 2;
	else if (ps->_Dir == RIGHT)
		newx += 2;
	else if (ps->_Dir == UP)
		newy -= 1;
	else if (ps->_Dir == DOWN)
		newy += 1;
	pSnakeNode nextnode = (pSnakeNode)malloc(sizeof(SnakeNode));
	if (!nextnode)
	{
		perror("NoFood()::malloc()");
		exit(1);
	}
	nextnode->x = newx;
	nextnode->y = newy;
	return nextnode;
}

5. 3. 4 NextIsFood

检查下一步是不是食物，只需要将新的头（还未插入）的数据和食物的坐标进行比较就可以了。

bool NextIsFood(pSnakeNode nextnode, pSnake ps)
{
	if (ps->_Food->x == nextnode->x && ps->_Food->y == nextnode->y)
		return true;
	else
		return false;
}

5. 3. 4 EatFood

吃下食物有这么几个步骤：

将newnode头插到蛇身上去
删除食物并重新生成一个（注意食物节点是动态开辟的，要free掉）
把原来的食物的图标用蛇身覆盖掉
加分

void EatFood(pSnakeNode newhead, pSnake ps)
{
	//将newhead头插到蛇身上
	newhead->next = ps->_Head;
	ps->_Head = newhead;
	//删除食物
	free(ps->_Food);
	ps->_Food = NULL;
	CreatFood(ps);

	//打印蛇头把食物覆盖掉
	SetPos(ps->_Head->x, ps->_Head->y);
	wprintf(L"%c", SNAKE_BODY);

	//也可以直接刷新整个蛇身，显示效果可能稍有差异
	//pSnakeNode cur = ps->_Head;
	//while (cur)
	//{
	//	SetPos(cur->x, cur->y);
	//	wprintf(L"%c", SNAKE_BODY);
	//	cur = cur->next;
	//}
	
	//加分
	ps->_Score += ps->_FoodAdd;
}

5. 3. 5 NotFood

如果下一步不是食物有这么几个步骤：

把新节点头插上去
打印新的头节点
把原来的尾节点打印的符号用空格覆盖掉
尾删

void NotFood(pSnakeNode newhead, pSnake ps)
{
	//头插
	newhead->next = ps->_Head;
	ps->_Head = newhead;

	//打印新头
	SetPos(ps->_Head->x, ps->_Head->y);
	wprintf(L"%c", SNAKE_BODY);

	//将尾节点的符号用空格顶替掉
	pSnakeNode cur = ps->_Head;
	while (cur->next->next)	//这个循环最终会找到尾节点的上一个节点
		cur = cur->next;
	SetPos(cur->next->x, cur->next->y);
	printf("  ");

	//尾删
	free(cur->next);
	cur->next = NULL;
}

5. 3. 6 CheckIsWall和CheckIsSelf

这两个函数就是死亡判定了。
检测是否撞墙，只需要判断蛇身是否出界就可以了。
检测是否撞到自己，就需要**遍历链表来一一对比 **了。

void CheckIsSelf(pSnake ps)
{
	pSnakeNode cur = ps->_Head->next;
	//遍历检测是否撞到自己
	while (cur)
	{
		if (cur->x == ps->_Head->x && cur->y == ps->_Head->y)
		{
			ps->_Sta = KILL_BY_SELF;	//撞到了就更改状态
			break;
		}
		cur = cur->next;
	}
}

void CheckIsWall(pSnake ps)
{
	//检测头节点的坐标是否超出范围
	if (ps->_Head->x <= 0 || ps->_Head->x >= 58 || ps->_Head->y <= 0 || ps->_Head->y >= 27)
		ps->_Sta = KILL_BY_WALL;
}

那么至此，GameRun函数就写完了，游戏已经能基本正常的运行起来了。

5. 4 GameOver

那么剩下的便是收尾工作了，这个游戏中使用了动态内存管理，在不在进行使用之后，必须进行释放，不然会导致内存泄漏。
这个函数要完成以下内容：

打印死亡信息，告诉玩家是怎么死亡的（当然，也可以方便调试）
回收内存

打印死亡信息只需要根据ps->_Sta的不同状态设置不同的语句就可以了。
而蛇的销毁就是链表的销毁，也不赘述了。

void GameOver(pSnake ps)
{
	//打印死亡信息（用于调试）
	SetPos(15, 14);
	if (ps->_Sta == KILL_BY_SELF)
		printf("你撞到了自己");
	else if (ps->_Sta == KILL_BY_WALL)
		printf("你撞墙了");
	else
		printf("正常退出");
	//释放蛇的内存
	pSnakeNode cur = ps->_Head;
	while (cur)
	{
		pSnakeNode next = cur->next;
		free(cur);
		cur = next;
	}
	free(ps->_Food);
	ps->_Food = NULL;
}

那么接下来就是回到上篇博客的游戏主逻辑中，开始询问玩家要不要再来一把了。

6. 已知Bug与一些可能的改进意见

我们先来看上篇中的这个循环：

while (_kbhit())	//_kbhit()检测是否有按键被按下
{
	//使用 _getch() 获取按下的键
	_getch();
}

处理的Bug是如果在第二次及以后的游戏（也就是输入了Y进行了再来一把）中，如果使用了F1加速，就会在本把游戏结束时成为这样：

这个Y并不是手动打上去的，而是由于其他原因上去的，并且这个Y还可以再被getchar()读取下来，导致游戏再无法退出。
至于成因，可以看一眼：
在 cmd 中先输入Y，回车，F1，回车，就会看到这样的情况：

而上面的代码就可以解决这个问题了。