C语言实战：贪吃蛇（万字详解）

💡目录

效果图

界面设计思路

1. 基本布局

2. 视觉元素

游戏机制设计

基本规则

游戏代码

 前期准备

游戏代码详解

数据结构设计

宏定义

数据结构定义

函数原型（详见后文）

主函数代码

核心代码

Review

效果图

界面设计思路

1. 基本布局

  • 游戏区域：屏幕中央占据大部分面积，用于显示游戏地图，地图通常被设计成一个矩形网格，每个单元格代表蛇可以移动的一个位置
  • 得分显示：位于屏幕的顶部或角落，实时更新并显示玩家当前的得分，鼓励玩家追求更高的分数
  • 控制提示：初学者友好设计，简短说明如何控制蛇的移动（如使用箭头键），通常在游戏开始前或暂停时显示

2. 视觉元素

  • 蛇：使用不同的字符或颜色块来表示蛇的身体和头部，头部可能有特殊标记以区分，蛇移动时，通过改变字符或颜色的位置来模拟动画效果
  • 食物：采用醒目的颜色或符号，使其在地图上易于识别，吸引玩家去追逐
  • 边界：地图边缘用特殊的符号或颜色加重，提醒玩家避免碰撞

游戏机制设计

基本规则

  • 移动：玩家通过键盘控制蛇的前进方向，蛇会在每一帧自动向前移动一格，无法倒退或立即转向180度
  • 生长：当蛇头触碰到食物时，蛇的长度增加，同时分数增加，并在地图上的随机空白处生成新的食物
  • 死亡条件：蛇碰到自己的身体或地图边界时，游戏结束。此外，可以设定时间限制或生命值系统增加挑战性
  • 速度控制：玩家可通过按键调整蛇的移动速度


 

游戏代码

snake.h

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1
#define _KEY_STATE(x) (GetAsyncKeyState(x)&1?1:0)
#define _SNAKE_LENTH_ 5
#define GAME_WIDTH 26
#define GAME_HEIGHT 26


#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<stdbool.h>
#include<locale.h>
#include<io.h>
#include<fcntl.h>
#include<time.h>


typedef enum DIRECTION//蛇的方向
{
	UP,DOWN,LEFT,RIGHT
}DIRECTION;

typedef enum STATE//蛇的状态
{
	RUN,PAUSE,KILL_BY_SELF,KILL_BY_WALL
}STATE;

typedef struct Psnake //用于记录蛇的各个节点
{
	int x;
	int y;
	struct Psnake* next;
}Psnake;
Psnake* PsnakeNode;

typedef struct Food 
{
	int x;
	int y;
	int score;
}Food;

typedef struct object 
{
	Psnake* psnakenode;
	Food food;
	int score;
	int speed;
	DIRECTION dir;
	STATE state;
}object;
object SNAKE;

void set_pos(short x, short y);//设置光标坐标

void cursor(bool state, int x);//设置光标可见性和大小

void map();//打印地图

void cover();//打印封面

void GameStart();//游戏初始化

void printInstruction(int y, const wchar_t* message);//打印提示信息

void PrintFood(Food* pos);//打印食物

void CreateFood(Psnake* snake);//创建食物

bool FoodJudge(Psnake* next);//判断下一节点是否为食物

Psnake* buynode(int x, int y);//申请节点

Psnake* InitSnake(Psnake** head);//初始化蛇

void PrintSnake(Psnake* head);//打印蛇

void IsDie();//判断满足结束条件

void SnakeMove(Psnake** head);//移动蛇

void ClearScreen();//清屏

void GameOver(int score);//游戏结束

void GameRun(Psnake** head);//运行游戏

void GameStart();//游戏前准备

snake.c

#include "snake.h"

//设置坐标
void set_pos(short x, short y)
{
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD coord;
	coord.X = x;
	coord.Y = y;
	SetConsoleCursorPosition(hConsole, coord);
}//设置坐标

//设置光标信息
void cursor(bool state, int x)
{
	HANDLE op = GetStdHandle(STD_OUTPUT_HANDLE);

	CONSOLE_CURSOR_INFO con;

	con.dwSize = x;
	con.bVisible = state;
	
	SetConsoleCursorInfo(op, &con);
}

//打印提示信息
void printInstruction(int y, const wchar_t* message) {
	set_pos(60, y);
	wprintf(message);
}

//打印地图
void map() {
	// Draw top border
	set_pos(0, 0);
	for (int i = 0; i < 29; i++) {
		wprintf(L"□");
	}

	// Draw left and right borders
	for (int i = 1; i < 29; i++) {
		set_pos(0, i);
		wprintf(L"□");
		set_pos(28 * 2, i); //右边的坐标（28*2 ，i）
		wprintf(L"□");
	}

	// Draw bottom border
	set_pos(0, 29);
	for (int i = 0; i < 29; i++) {
		wprintf(L"□");
	}
	const wchar_t* instructions[] = {
		L"操作指南: 使用方向键←↑→↓",
		L"速度控制: F2 加速, F3 减速",
		L"暂停游戏: 按 P",
		L"退出游戏: 按 ESC"
	};

	for (int i = 0; i < sizeof(instructions) / sizeof(instructions[0]); ++i) {
		printInstruction(10 + i, instructions[i]);
	}
}

//打印封面
void cover()
{
	system("mode con cols=120 lines=50");
	system("title 贪吃蛇");
	
	set_pos(40, 10);
	wprintf(L"                                                                                                         \n");
	wprintf(L"         .-----------------.  .-----------------. .----------------.  .----------------.  .---------------- .\n");
	wprintf(L"	| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |\n");
	wprintf(L"	| |    _______   | || | ____  _____  | || |      __      | || |     ______   | || |  ___  ____   | |\n");
	wprintf(L"	| |   /  ___  |  | || ||_   \\ |_  _| | || |     /  \\     | || |   .' ___  |  | || | |_  ||_  _|  | |\n");
	wprintf(L"	| |  |  (__ \\_|  | || |  |   \\ | |   | || |    / /\\ \\    | || |  / .'   \\_|  | || |   | |_/ /    | |\n");
	wprintf(L"	| |   '.___`-.   | || |  | |\\ \\| |   | || |   / ____ \\   | || | | |          | || |   |  __'.    | |\n");
	wprintf(L"	| |  |`\\____) |  | || | _| |_\\ | |_  | || |  / /    \\ \\_ | || |  \\ `.___.'\\  | || |  _| |  \\ \\_  | |\n");
	wprintf(L"	| |  |_______.'  | || ||_____|\\____| | || ||____|  |____|| || |   `._____.'  | || | |____ || __|_| |\n");
	wprintf(L"	| |              | || |              | || |              | || |              | || |              | |\n");
	wprintf(L"	| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |\n");
	wprintf(L"	'----------------'  '------'---------'  '----------------'  '------'---------'    '--'-------------'\n");
	
	set_pos(45, 29);

	system("pause");
	system("cls");

	map();

}

//打印食物坐标
void PrintFood(Food* pos)
{
	set_pos((*pos).x, (*pos).y);
	wprintf(L"◆");
}

//创造食物
void CreateFood(Psnake* snake)
{
	Food* pos = (Food*)malloc(sizeof(Food));

	if (!pos)
	{
		perror("MALLOC FAILED:");
		return;
	}

	Psnake* cur = snake;
	//生成随机数
	srand((unsigned int)time(NULL));

again:
	(*pos).x = (rand() % GAME_WIDTH + 2) * 2; // rand() % 27 会得到0到26之间的数，加2后变为2到28
	(*pos).y = rand() % GAME_HEIGHT + 2; // rand() % 27 会得到0到26之间的数，加2后变为2到28
	(*pos).score = 1;
	while (cur)
	{
		if ((*pos).x == cur->x && (*pos).y == cur->y)
			goto again;
		cur = cur->next;
	}

	SNAKE.food = *pos;
	PrintFood(pos);
}

//判断下一个节点是否为食物
bool FoodJudge(Psnake* next)
{
	return ((next->x == SNAKE.food.x) && (next->y == SNAKE.food.y)) ? true : false;
}

//申请一个节点
Psnake* buynode(int x,int y)
{
	Psnake* newnode = (Psnake*)calloc(1, sizeof(Psnake));
	if (newnode == NULL)
	{
		perror("calloc:");
		return NULL;
	}
	newnode->next = NULL;
	newnode->x = x;
	newnode->y = y;

	return newnode;
}

//初始化蛇的信息
Psnake* InitSnake(Psnake**head)
{
	if (!(head&&*head)) {
		fprintf(stderr, "Memory allocation failed\n");
		return NULL;
	}
	(*head) = (Psnake*)calloc(1, sizeof(Psnake));
	

	// 初始化成员
	(*head)->x = 6;
	(*head)->y = 10;
	(*head)->next = NULL;

	Psnake* cur = *head;
	if (!cur)
	{
		perror("head is nullptr");
		return NULL;
	}
	int x = _SNAKE_LENTH_;
	while (x--)
	{
		Psnake* newnode= buynode((cur->x)+2, cur->y);
		newnode->next = cur;
		cur = newnode;
	}
	SNAKE.dir = RIGHT;
	SNAKE.psnakenode = cur;
	SNAKE.state = RUN;
	SNAKE.speed = 150;

	return cur;
}

//打印蛇
void PrintSnake(Psnake* head)
{
	Psnake* cur = SNAKE.psnakenode;
	while (cur)
	{
		set_pos(cur->x, cur->y);
		wprintf(L"●");
		cur = cur->next;
	}
}

void IsDie() {
	Psnake* cur = SNAKE.psnakenode->next; // 从第二个节点开始
	Psnake* prev = SNAKE.psnakenode; // 保存蛇头节点用于比较

	while (cur->next) {
		cur = cur->next;
		if (cur->x == prev->x && cur->y == prev->y) { // 检查当前节点是否与之前的节点重合
			SNAKE.state = KILL_BY_SELF;
			return;
		}
		
	}

	if (SNAKE.psnakenode->x == 56||SNAKE.psnakenode->x==0 ||SNAKE.psnakenode->y==0||SNAKE.psnakenode->y == 28) {
		SNAKE.state = KILL_BY_WALL;
		return;
	}
}

//蛇的移动
void SnakeMove(Psnake** head)
{
	// 首先检查蛇头的下一个位置
	Psnake* next = (Psnake*)calloc(1, sizeof(Psnake));
	if (!next) {
		perror("Failed to allocate memory for next snake node");
		exit(EXIT_FAILURE);
	}

	// 根据当前方向设置蛇头的下一个位置
	switch (SNAKE.dir)
	{
	case UP:
		next->x = SNAKE.psnakenode->x;
		next->y = SNAKE.psnakenode->y - 1;
		break;
	case DOWN:
		next->x = SNAKE.psnakenode->x;
		next->y = SNAKE.psnakenode->y + 1;
		break;
	case LEFT:
		next->x = SNAKE.psnakenode->x - 2;
		next->y = SNAKE.psnakenode->y;
		break;
	case RIGHT:
		next->x = SNAKE.psnakenode->x + 2;
		next->y = SNAKE.psnakenode->y;
		break;
	default:
		free(next);
		return; // 如果方向无效，不移动蛇
	}

	// 检查下一个位置是否有食物
	if (FoodJudge(next))
	{
		SNAKE.score += SNAKE.food.score; // 增加得分
		next->next = (*head); // 将新节点放在头部
		*head = next; // 更新头指针
		CreateFood(*head); // 生成新的食物
	}
	else
	{
		// 没有食物，移动蛇的尾部到头部
		Psnake* tail = SNAKE.psnakenode;
		Psnake* prev = NULL;
		if (!(tail || prev))
		{
			perror("POINTER IS NULL:");
			return;
		}
		// 找到尾节点和其前一个节点
		while (tail->next) {
			prev = tail;
			tail = tail->next;
		}

		// 将尾部节点移动到头部
		prev->next = NULL; // 将前一个节点的next设置为NULL，它现在是尾部
		set_pos(tail->x, tail->y);
		wprintf(L"  ");

		tail->next = SNAKE.psnakenode; // 将原尾部节点放在头部
		SNAKE.psnakenode = tail; // 更新头指针

		// 更新头部位置
		SNAKE.psnakenode->x = next->x;
		SNAKE.psnakenode->y = next->y;

		// 释放之前分配的next节点，因为我们只是移动了尾部节点
		free(next);
	}
	IsDie();
	PrintSnake(SNAKE.psnakenode);
}

//=========================================
//运行游戏

void ClearScreen() {  // 定义清屏函数，适用于Windows和Linux/macOS
#ifdef _WIN32
	system("cls");
#else
	system("clear");
#endif
}

void GameOver(int score) {
	// 游戏结束后的善后处理
	ClearScreen();  // 清除屏幕

	wprintf(L"Game Over!\n");  // 打印游戏结束信息
	wprintf(L"总分: %d\n", score);  // 显示玩家得分

	// 询问玩家是否想再玩一次
	wprintf(L"再来一次？(y/n): ");

	system("pause >> nul");
	if (_KEY_STATE(0x59)){
		GameStart();
		fflush(stdin);
	}
	else {
		wprintf(L"感谢游玩\n");
		exit(0);  // 结束程序
	}
}

void GameRun(Psnake**head)
{
	do
	{
		set_pos(60, 6);
		wprintf(L"当前分数: %d", SNAKE.score);

		if ((_KEY_STATE(VK_UP) || _KEY_STATE(0x57)) && SNAKE.dir != DOWN)
		{
			SNAKE.dir = UP;
		}
		else if ((_KEY_STATE(VK_DOWN) || _KEY_STATE(0x53)) && SNAKE.dir != UP)
		{
			SNAKE.dir = DOWN;
		}
		else if ((_KEY_STATE(VK_LEFT) || _KEY_STATE(0x41)) && SNAKE.dir != RIGHT)
		{
			SNAKE.dir = LEFT;
		}
		else if ((_KEY_STATE(VK_RIGHT) || _KEY_STATE(0x44)) && SNAKE.dir != LEFT)
		{
			SNAKE.dir = RIGHT;
		}
		else if (_KEY_STATE(0x71)&&SNAKE.speed>=0&&SNAKE.speed<=500)
		{
			(SNAKE.speed) -= 30;
		}		
		else if (_KEY_STATE(0x72)&&SNAKE.speed>=0&&SNAKE.speed<=500)
		{
			(SNAKE.speed) += 30;
		}
		else if (_KEY_STATE(0x50))
		{
			SNAKE.speed = 2147483647;
		}

		SnakeMove(head);
		Sleep(SNAKE.speed);
	} while (SNAKE.state == RUN);
	GameOver(SNAKE.score);
}

//开始游戏及游戏前准备
void GameStart()
{
	cover();

	SNAKE.psnakenode = (Psnake*)malloc(sizeof(Psnake));
	InitSnake(&SNAKE.psnakenode);
	PrintSnake(SNAKE.psnakenode);

	CreateFood(SNAKE.psnakenode);


	set_pos(40, 36);
	GameRun(&SNAKE.psnakenode);
}

main.c

#include"snake.h"

int main()
{
//	环境配置
//=================================================
//	可打印宽字符
	_setmode(_fileno(stdout), _O_U16TEXT);
	//切换到本地
	setlocale(LC_ALL, "");

	system("mode con cols=10 lines=20");

	set_pos(0, 20);
	cursor(false, 10);
//=================================================
//	正式开始
	GameStart();

	set_pos(0, 40);
	return 0;
}

 前期准备

在 visual studio 2022中，默认窗口为cmd终端，无法实现预期效果，我们需要以下设置。若为其他开发环境请自查资料。

游戏代码详解

数据结构设计

snake.h

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1
#define _KEY_STATE(x) (GetAsyncKeyState(x)&1?1:0)
#define _SNAKE_LENTH_ 5
#define GAME_WIDTH 26
#define GAME_HEIGHT 26


#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<stdbool.h>
#include<locale.h>
#include<io.h>
#include<fcntl.h>
#include<time.h>


typedef enum DIRECTION//蛇的方向
{
	UP,DOWN,LEFT,RIGHT
}DIRECTION;

typedef enum STATE//蛇的状态
{
	RUN,PAUSE,KILL_BY_SELF,KILL_BY_WALL
}STATE;

typedef struct Psnake //用于记录蛇的各个节点
{
	int x;
	int y;
	struct Psnake* next;
}Psnake;
Psnake* PsnakeNode;

typedef struct Food 
{
	int x;
	int y;
	int score;
}Food;

typedef struct object 
{
	Psnake* psnakenode;
	Food food;
	int score;
	int speed;
	DIRECTION dir;
	STATE state;
}object;
object SNAKE;

void set_pos(short x, short y);//设置光标坐标

void cursor(bool state, int x);//设置光标可见性和大小

void map();//打印地图

void cover();//打印封面

void GameStart();//游戏初始化

void printInstruction(int y, const wchar_t* message);//打印提示信息

void PrintFood(Food* pos);//打印食物

void CreateFood(Psnake* snake);//创建食物

bool FoodJudge(Psnake* next);//判断下一节点是否为食物

Psnake* buynode(int x, int y);//申请节点

Psnake* InitSnake(Psnake** head);//初始化蛇

void PrintSnake(Psnake* head);//打印蛇

void IsDie();//判断满足结束条件

void SnakeMove(Psnake** head);//移动蛇

void ClearScreen();//清屏

void GameOver(int score);//游戏结束

void GameRun(Psnake** head);//运行游戏

void GameStart();//游戏前准备

宏定义

  • #pragma once: 用于防止头文件被重复包含。
  • _CRT_SECURE_NO_WARNINGS 1: 禁用Visual Studio中的某些不安全函数警告，比如使用scanf等。
  • _KEY_STATE(x) (GetAsyncKeyState(x)&1?1:0): 自定义宏，用来检查给定虚拟键是否被按下。GetAsyncKeyState是Windows API函数( 配合虚拟键码使用 )，用于检查按键状态。
  • _SNAKE_LENTH_ 5: 定义初始蛇的长度为5个单位。
  • GAME_WIDTH 26 和 GAME_HEIGHT 26: 定义游戏地图的宽度和高度，均为26个单位。

数据结构定义

  • enum DIRECTION: 定义蛇的移动方向，包括上、下、左、右。
  • enum STATE: 定义蛇的状态，包括运行中、暂停、自杀死亡、撞墙死亡。
  • struct Psnake: 蛇的节点结构体，包含位置坐标(x, y)和指向下一个节点的指针。
  • struct Food: 食物结构体，包含位置坐标(x, y)和分数。
  • struct object: 游戏对象结构体，整合蛇、食物、得分、速度、方向和状态等游戏所需的所有信息。

将蛇、食物抽象成一个结构体，用宽字符来打印，enum STATE、enum DIRECTION 来表示蛇的状态。将以上数据放在object结构体中进行管理。

函数原型（详见后文）

  • set_pos(short x, short y): 设置控制台光标位置。
  • cursor(bool state, int x): 设置控制台光标的可见性和大小。
  • map(): 打印游戏地图。
  • cover(): 打印游戏封面。
  • GameStart(): 游戏初始化入口，可能包含了封面展示、地图绘制、蛇的初始化等。
  • printInstruction(int y, const wchar_t* message): 在指定行打印宽字符格式的提示信息。
  • PrintFood(Food* pos): 在指定位置打印食物。
  • CreateFood(Psnake* snake): 随机生成食物，并确保不与蛇身重叠。
  • FoodJudge(Psnake* next): 判断蛇的下一个位置是否为食物。
  • buynode(int x, int y): 申请一个新的蛇节点内存。
  • InitSnake(Psnake** head): 初始化蛇的链表结构。
  • PrintSnake(Psnake* head): 打印蛇的当前位置。
  • IsDie(): 判断游戏是否结束，即蛇是否撞墙或自相残杀。
  • SnakeMove(Psnake** head): 处理蛇的移动逻辑，包括方向改变和吃到食物的处理。
  • ClearScreen(): 清除屏幕内容。
  • GameOver(int score): 游戏结束时的操作，显示分数并可能询问是否重新开始。
  • GameRun(Psnake** head): 游戏主循环，处理用户输入和游戏逻辑。

整个框架围绕着贪吃蛇的基本逻辑展开，包括了游戏的初始化、地图绘制、蛇的移动与增长、食物的生成与检测、游戏状态管理以及用户交互。

主函数代码

main.c

#include"snake.h"

int main()
{
//	环境配置
//=================================================
//	可打印宽字符
	_setmode(_fileno(stdout), _O_U16TEXT);
	//切换到本地
	setlocale(LC_ALL, "");

	system("mode con cols=10 lines=20");

	set_pos(0, 20);
	cursor(false, 10);
//=================================================
//	正式开始
	GameStart();

	set_pos(0, 40);
	return 0;
}

_setmode(_fileno(stdout) , _O_U16TEXT);    将输出模式设置为 _O_U16TEXT 模式，以便后续打印宽字符。

  • _setmode 函数来自 <io.h> 头文件。
  • _fileno 函数来自 <stdio.h> 头文件。
  • _O_U16TEXT 宏定义通常在 <fcntl.h> 或 <io.h> 中找到

setlocale(LC_ARR,"");    切换到本地模式

  • LC_ALL是一个宏，代表所有类别，包括日期和时间格式、数字表示、货币符号、语言等。使用 LC_ALL 意味着你想改变所有方面的区域设置。
  • "" 作为第二个参数，是一个特殊的值，它告诉函数使用用户默认的或者环境变量（如 LANG 或 LC_ALL）指定的区域设置。

system("mode con cols=10 lines=20");     将窗口设置为20行高，10列宽，在vs控制台中，字符高度一致，但宽度不一致，一般来说宽字符是窄字符的两倍，为了达到预期效果，需按照以上比例设置。

set_pos(0,20);      设置打印字符的位置，这是我自己封装的函数，后续会讲到。

cursor(false,10);    设置光标状态，自己封装的函数，后续会讲到。

GameStart();    正式进入游戏。跳转到snake.c文件中。

核心代码

snake.c

#include "snake.h"

//设置坐标
void set_pos(short x, short y)
{
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD coord;
	coord.X = x;
	coord.Y = y;
	SetConsoleCursorPosition(hConsole, coord);
}//设置坐标

//设置光标信息
void cursor(bool state, int x)
{
	HANDLE op = GetStdHandle(STD_OUTPUT_HANDLE);

	CONSOLE_CURSOR_INFO con;

	con.dwSize = x;
	con.bVisible = state;
	
	SetConsoleCursorInfo(op, &con);
}

//打印提示信息
void printInstruction(int y, const wchar_t* message) {
	set_pos(60, y);
	wprintf(message);
}

//打印地图
void map() {
	// Draw top border
	set_pos(0, 0);
	for (int i = 0; i < 29; i++) {
		wprintf(L"□");
	}

	// Draw left and right borders
	for (int i = 1; i < 29; i++) {
		set_pos(0, i);
		wprintf(L"□");
		set_pos(28 * 2, i); //右边的坐标（28*2 ，i）
		wprintf(L"□");
	}

	// Draw bottom border
	set_pos(0, 29);
	for (int i = 0; i < 29; i++) {
		wprintf(L"□");
	}
	const wchar_t* instructions[] = {
		L"操作指南: 使用方向键←↑→↓",
		L"速度控制: F2 加速, F3 减速",
		L"暂停游戏: 按 P",
		L"退出游戏: 按 ESC"
	};

	for (int i = 0; i < sizeof(instructions) / sizeof(instructions[0]); ++i) {
		printInstruction(10 + i, instructions[i]);
	}
}

//打印封面
void cover()
{
	system("mode con cols=120 lines=50");
	system("title 贪吃蛇");
	
	set_pos(40, 10);
	wprintf(L"                                                                                                         \n");
	wprintf(L"         .-----------------.  .-----------------. .----------------.  .----------------.  .---------------- .\n");
	wprintf(L"	| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |\n");
	wprintf(L"	| |    _______   | || | ____  _____  | || |      __      | || |     ______   | || |  ___  ____   | |\n");
	wprintf(L"	| |   /  ___  |  | || ||_   \\ |_  _| | || |     /  \\     | || |   .' ___  |  | || | |_  ||_  _|  | |\n");
	wprintf(L"	| |  |  (__ \\_|  | || |  |   \\ | |   | || |    / /\\ \\    | || |  / .'   \\_|  | || |   | |_/ /    | |\n");
	wprintf(L"	| |   '.___`-.   | || |  | |\\ \\| |   | || |   / ____ \\   | || | | |          | || |   |  __'.    | |\n");
	wprintf(L"	| |  |`\\____) |  | || | _| |_\\ | |_  | || |  / /    \\ \\_ | || |  \\ `.___.'\\  | || |  _| |  \\ \\_  | |\n");
	wprintf(L"	| |  |_______.'  | || ||_____|\\____| | || ||____|  |____|| || |   `._____.'  | || | |____ || __|_| |\n");
	wprintf(L"	| |              | || |              | || |              | || |              | || |              | |\n");
	wprintf(L"	| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |\n");
	wprintf(L"	'----------------'  '------'---------'  '----------------'  '------'---------'    '--'-------------'\n");
	
	set_pos(45, 29);

	system("pause");
	system("cls");

	map();

}

//打印食物坐标
void PrintFood(Food* pos)
{
	set_pos((*pos).x, (*pos).y);
	wprintf(L"◆");
}

//创造食物
void CreateFood(Psnake* snake)
{
	Food* pos = (Food*)malloc(sizeof(Food));

	if (!pos)
	{
		perror("MALLOC FAILED:");
		return;
	}

	Psnake* cur = snake;
	//生成随机数
	srand((unsigned int)time(NULL));

again:
	(*pos).x = (rand() % GAME_WIDTH + 2) * 2; // rand() % 27 会得到0到26之间的数，加2后变为2到28
	(*pos).y = rand() % GAME_HEIGHT + 2; // rand() % 27 会得到0到26之间的数，加2后变为2到28
	(*pos).score = 1;
	while (cur)
	{
		if ((*pos).x == cur->x && (*pos).y == cur->y)
			goto again;
		cur = cur->next;
	}

	SNAKE.food = *pos;
	PrintFood(pos);
}

//判断下一个节点是否为食物
bool FoodJudge(Psnake* next)
{
	return ((next->x == SNAKE.food.x) && (next->y == SNAKE.food.y)) ? true : false;
}

//申请一个节点
Psnake* buynode(int x,int y)
{
	Psnake* newnode = (Psnake*)calloc(1, sizeof(Psnake));
	if (newnode == NULL)
	{
		perror("calloc:");
		return NULL;
	}
	newnode->next = NULL;
	newnode->x = x;
	newnode->y = y;

	return newnode;
}

//初始化蛇的信息
Psnake* InitSnake(Psnake**head)
{
	if (!(head&&*head)) {
		fprintf(stderr, "Memory allocation failed\n");
		return NULL;
	}
	(*head) = (Psnake*)calloc(1, sizeof(Psnake));
	

	// 初始化成员
	(*head)->x = 6;
	(*head)->y = 10;
	(*head)->next = NULL;

	Psnake* cur = *head;
	if (!cur)
	{
		perror("head is nullptr");
		return NULL;
	}
	int x = _SNAKE_LENTH_;
	while (x--)
	{
		Psnake* newnode= buynode((cur->x)+2, cur->y);
		newnode->next = cur;
		cur = newnode;
	}
	SNAKE.dir = RIGHT;
	SNAKE.psnakenode = cur;
	SNAKE.state = RUN;
	SNAKE.speed = 150;

	return cur;
}

//打印蛇
void PrintSnake(Psnake* head)
{
	Psnake* cur = SNAKE.psnakenode;
	while (cur)
	{
		set_pos(cur->x, cur->y);
		wprintf(L"●");
		cur = cur->next;
	}
}

void IsDie() {
	Psnake* cur = SNAKE.psnakenode->next; // 从第二个节点开始
	Psnake* prev = SNAKE.psnakenode; // 保存蛇头节点用于比较

	while (cur->next) {
		cur = cur->next;
		if (cur->x == prev->x && cur->y == prev->y) { // 检查当前节点是否与之前的节点重合
			SNAKE.state = KILL_BY_SELF;
			return;
		}
		
	}

	if (SNAKE.psnakenode->x == 56||SNAKE.psnakenode->x==0 ||SNAKE.psnakenode->y==0||SNAKE.psnakenode->y == 28) {
		SNAKE.state = KILL_BY_WALL;
		return;
	}
}

//蛇的移动
void SnakeMove(Psnake** head)
{
	// 首先检查蛇头的下一个位置
	Psnake* next = (Psnake*)calloc(1, sizeof(Psnake));
	if (!next) {
		perror("Failed to allocate memory for next snake node");
		exit(EXIT_FAILURE);
	}

	// 根据当前方向设置蛇头的下一个位置
	switch (SNAKE.dir)
	{
	case UP:
		next->x = SNAKE.psnakenode->x;
		next->y = SNAKE.psnakenode->y - 1;
		break;
	case DOWN:
		next->x = SNAKE.psnakenode->x;
		next->y = SNAKE.psnakenode->y + 1;
		break;
	case LEFT:
		next->x = SNAKE.psnakenode->x - 2;
		next->y = SNAKE.psnakenode->y;
		break;
	case RIGHT:
		next->x = SNAKE.psnakenode->x + 2;
		next->y = SNAKE.psnakenode->y;
		break;
	default:
		free(next);
		return; // 如果方向无效，不移动蛇
	}

	// 检查下一个位置是否有食物
	if (FoodJudge(next))
	{
		SNAKE.score += SNAKE.food.score; // 增加得分
		next->next = (*head); // 将新节点放在头部
		*head = next; // 更新头指针
		CreateFood(*head); // 生成新的食物
	}
	else
	{
		// 没有食物，移动蛇的尾部到头部
		Psnake* tail = SNAKE.psnakenode;
		Psnake* prev = NULL;
		if (!(tail || prev))
		{
			perror("POINTER IS NULL:");
			return;
		}
		// 找到尾节点和其前一个节点
		while (tail->next) {
			prev = tail;
			tail = tail->next;
		}

		// 将尾部节点移动到头部
		prev->next = NULL; // 将前一个节点的next设置为NULL，它现在是尾部
		set_pos(tail->x, tail->y);
		wprintf(L"  ");

		tail->next = SNAKE.psnakenode; // 将原尾部节点放在头部
		SNAKE.psnakenode = tail; // 更新头指针

		// 更新头部位置
		SNAKE.psnakenode->x = next->x;
		SNAKE.psnakenode->y = next->y;

		// 释放之前分配的next节点，因为我们只是移动了尾部节点
		free(next);
	}
	IsDie();
	PrintSnake(SNAKE.psnakenode);
}

//=========================================
//运行游戏

void ClearScreen() {  // 定义清屏函数，适用于Windows和Linux/macOS
#ifdef _WIN32
	system("cls");
#else
	system("clear");
#endif
}

void GameOver(int score) {
	// 游戏结束后的善后处理
	ClearScreen();  // 清除屏幕

	wprintf(L"Game Over!\n");  // 打印游戏结束信息
	wprintf(L"总分: %d\n", score);  // 显示玩家得分

	// 询问玩家是否想再玩一次
	wprintf(L"再来一次？(y/n): ");

	system("pause >> nul");
	if (_KEY_STATE(0x59)){
		GameStart();
		fflush(stdin);
	}
	else {
		wprintf(L"感谢游玩\n");
		exit(0);  // 结束程序
	}
}

void GameRun(Psnake**head)
{
	do
	{
		set_pos(60, 6);
		wprintf(L"当前分数: %d", SNAKE.score);

		if ((_KEY_STATE(VK_UP) || _KEY_STATE(0x57)) && SNAKE.dir != DOWN)
		{
			SNAKE.dir = UP;
		}
		else if ((_KEY_STATE(VK_DOWN) || _KEY_STATE(0x53)) && SNAKE.dir != UP)
		{
			SNAKE.dir = DOWN;
		}
		else if ((_KEY_STATE(VK_LEFT) || _KEY_STATE(0x41)) && SNAKE.dir != RIGHT)
		{
			SNAKE.dir = LEFT;
		}
		else if ((_KEY_STATE(VK_RIGHT) || _KEY_STATE(0x44)) && SNAKE.dir != LEFT)
		{
			SNAKE.dir = RIGHT;
		}
		else if (_KEY_STATE(0x71)&&SNAKE.speed>=0&&SNAKE.speed<=500)
		{
			(SNAKE.speed) -= 30;
		}		
		else if (_KEY_STATE(0x72)&&SNAKE.speed>=0&&SNAKE.speed<=500)
		{
			(SNAKE.speed) += 30;
		}
		else if (_KEY_STATE(0x50))
		{
			SNAKE.speed = 2147483647;
		}

		SnakeMove(head);
		Sleep(SNAKE.speed);
	} while (SNAKE.state == RUN);
	GameOver(SNAKE.score);
}

//开始游戏及游戏前准备
void GameStart()
{
	cover();

	SNAKE.psnakenode = (Psnake*)malloc(sizeof(Psnake));
	InitSnake(&SNAKE.psnakenode);
	PrintSnake(SNAKE.psnakenode);

	CreateFood(SNAKE.psnakenode);


	set_pos(40, 36);
	GameRun(&SNAKE.psnakenode);
}

1.    set_pos( short  x , short y ) 

void set_pos(short x, short y)
{
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD coord;
	coord.X = x;
	coord.Y = y;
	SetConsoleCursorPosition(hConsole, coord);
}//设置坐标
  • 作用: 设置光标在控制台上的位置，以便在指定坐标输出字符。
  • 思路: 使用GetStdHandle获得控制台光标句柄 ---> 修改值 ---> SetConsoleCursorPosition实现对光标的控制。           

  注：SetConsoleCursorPosition的使用需一个COORD结构体，将x和y改成目标值。

  • 知识点: Windows API使用、句柄概念、坐标系统。

2.    cursor ( bool state , short x ) 

//设置光标信息
void cursor(bool state, int x)
{
	HANDLE op = GetStdHandle(STD_OUTPUT_HANDLE);

	CONSOLE_CURSOR_INFO con;

	con.dwSize = x;
	con.bVisible = state;
	
	SetConsoleCursorInfo(op, &con);
}
  • 作用: 控制光标的显示状态（可见或隐藏）及大小。
  • 思路: 使用 GetStdHandle 获得光标句柄 ---> 进行值的修改 ---> 使用SetConsoleCursorInfo进行设置 。

注：SetConsoleCursorInfo需要定义 CONSOLE_CURSOR_INFO类型的结构体

  • 知识点: 控制台编程、光标属性设置。

3. printInstruction( int y , const wchar_t* message )

//打印提示信息
void printInstruction(int y, const wchar_t* message) {
	set_pos(60, y);
	wprintf(message);
}
  • 作用: 在指定的行上打印游戏的指令或提示信息。
  • 思路: 调用set_pos定位光标，然后使用宽字符输出信息。
  • 知识点: 宽字符输出、动态打印信息布局。

4.  map( )

//打印地图
void map() {
	// Draw top border
	set_pos(0, 0);
	for (int i = 0; i < 29; i++) {
		wprintf(L"□");
	}

	// Draw left and right borders
	for (int i = 1; i < 29; i++) {
		set_pos(0, i);
		wprintf(L"□");
		set_pos(28 * 2, i); //右边的坐标（28*2 ，i）
		wprintf(L"□");
	}

	// Draw bottom border
	set_pos(0, 29);
	for (int i = 0; i < 29; i++) {
		wprintf(L"□");
	}
	const wchar_t* instructions[] = {
		L"操作指南: 使用方向键←↑→↓",
		L"速度控制: F2 加速, F3 减速",
		L"暂停游戏: 按 P",
		L"退出游戏: 按 ESC"
	};

	for (int i = 0; i < sizeof(instructions) / sizeof(instructions[0]); ++i) {
		printInstruction(10 + i, instructions[i]);
	}
}
  • 作用: 绘制游戏的地图边界和游戏说明。
  • 思路: 分别绘制上、下、左、右边界，并在固定位置打印游戏规则。

注：宽字符打印需要wprintf，wprintf( L "  " ) ;

  • 知识点: 循环结构、字符串输出、坐标计算。

5.  cover ( )

//打印封面
void cover()
{
	system("mode con cols=120 lines=50");
	system("title 贪吃蛇");
	
	set_pos(40, 10);
	wprintf(L"                                                                                                         \n");
	wprintf(L"         .-----------------.  .-----------------. .----------------.  .----------------.  .---------------- .\n");
	wprintf(L"	| .--------------. || .--------------. || .--------------. || .--------------. || .--------------. |\n");
	wprintf(L"	| |    _______   | || | ____  _____  | || |      __      | || |     ______   | || |  ___  ____   | |\n");
	wprintf(L"	| |   /  ___  |  | || ||_   \\ |_  _| | || |     /  \\     | || |   .' ___  |  | || | |_  ||_  _|  | |\n");
	wprintf(L"	| |  |  (__ \\_|  | || |  |   \\ | |   | || |    / /\\ \\    | || |  / .'   \\_|  | || |   | |_/ /    | |\n");
	wprintf(L"	| |   '.___`-.   | || |  | |\\ \\| |   | || |   / ____ \\   | || | | |          | || |   |  __'.    | |\n");
	wprintf(L"	| |  |`\\____) |  | || | _| |_\\ | |_  | || |  / /    \\ \\_ | || |  \\ `.___.'\\  | || |  _| |  \\ \\_  | |\n");
	wprintf(L"	| |  |_______.'  | || ||_____|\\____| | || ||____|  |____|| || |   `._____.'  | || | |____ || __|_| |\n");
	wprintf(L"	| |              | || |              | || |              | || |              | || |              | |\n");
	wprintf(L"	| '--------------' || '--------------' || '--------------' || '--------------' || '--------------' |\n");
	wprintf(L"	'----------------'  '------'---------'  '----------------'  '------'---------'    '--'-------------'\n");
	
	set_pos(45, 29);

	system("pause");
	system("cls");

	map();

}
  • 作用: 打印游戏封面。
  • 思路: 使用特殊字符和格式化输出来设计一个吸引人的启动画面，随后清除屏幕并进入游戏。
  • 知识点: 字符串操作、系统调用（改变窗口尺寸、标题）、多行输出。

6. void PrintFood（Food* pos）

//打印食物坐标
void PrintFood(Food* pos)
{
	set_pos((*pos).x, (*pos).y);
	wprintf(L"◆");
}
  • 作用: 在指定位置打印食物图标。
  • 思路: 移动光标至食物坐标，输出食物的符号。（Food 在 snake.h 会详解）
  • 知识点: 结构体使用、函数传参。

7. CreateFood ( Psnake* snake )

//创造食物
void CreateFood(Psnake* snake)
{
	Food* pos = (Food*)malloc(sizeof(Food));

	if (!pos)
	{
		perror("MALLOC FAILED:");
		return;
	}

	Psnake* cur = snake;
	//生成随机数
	srand((unsigned int)time(NULL));

again:
	(*pos).x = (rand() % GAME_WIDTH + 2) * 2; // rand() % 27 会得到0到26之间的数，加2后变为2到28
	(*pos).y = rand() % GAME_HEIGHT + 2; // rand() % 27 会得到0到26之间的数，加2后变为2到28
	(*pos).score = 1;
	while (cur)
	{
		if ((*pos).x == cur->x && (*pos).y == cur->y)
			goto again;
		cur = cur->next;
	}

	SNAKE.food = *pos;
	PrintFood(pos);
}
  • 作用: 随机生成食物并确保不与蛇身重叠。
  • 思路: 使用 rand 随机生成食物 x、y 坐标，食物遍历贪吃蛇每个节点的坐标，然后更新食物位置信息。
  • 知识点: 随机数生成、链表遍历、内存管理（malloc）。

8. FoodJudge(Psnake* next)

//判断下一个节点是否为食物
bool FoodJudge(Psnake* next)
{
	return ((next->x == SNAKE.food.x) && (next->y == SNAKE.food.y)) ? true : false;
}
  • 作用: 判断下一个节点位置是否为食物所在。
  • 思路: 比较节点坐标与食物坐标。
  • 知识点: 简单逻辑判断、结构体成员访问。

9.buynode(int x, int y)

//申请一个节点
Psnake* buynode(int x,int y)
{
	Psnake* newnode = (Psnake*)calloc(1, sizeof(Psnake));
	if (newnode == NULL)
	{
		perror("calloc:");
		return NULL;
	}
	newnode->next = NULL;
	newnode->x = x;
	newnode->y = y;

	return newnode;
}
  • 作用: 创建一个新的蛇节点。
  • 思路: 申请内存，初始化节点数据，链接到链表。

蛇按照方向进行移动，需要对蛇头的前，左右进行申请节点

  • 知识点: 动态内存分配、链表操作。

10.InitSnake(Psnake**head)

//初始化蛇的信息
Psnake* InitSnake(Psnake**head)
{
	if (!(head&&*head)) {
		fprintf(stderr, "Memory allocation failed\n");
		return NULL;
	}
	(*head) = (Psnake*)calloc(1, sizeof(Psnake));
	

	// 初始化成员
	(*head)->x = 6;
	(*head)->y = 10;
	(*head)->next = NULL;

	Psnake* cur = *head;
	if (!cur)
	{
		perror("head is nullptr");
		return NULL;
	}
	int x = _SNAKE_LENTH_;
	while (x--)
	{
		Psnake* newnode= buynode((cur->x)+2, cur->y);
		newnode->next = cur;
		cur = newnode;
	}
	SNAKE.dir = RIGHT;
	SNAKE.psnakenode = cur;
	SNAKE.state = RUN;
	SNAKE.speed = 150;

	return cur;
}
  • 作用: 初始化蛇的结构，创建初始蛇身。
  • 思路: 设置蛇头位置、按照长度申请节点，并设置蛇其他信息
  • 知识点: 指针引用、循环构造链表、内存管理。

11.PrintSnake(Psnake* head)

//打印蛇
void PrintSnake(Psnake* head)
{
	Psnake* cur = SNAKE.psnakenode;
	while (cur)
	{
		set_pos(cur->x, cur->y);
		wprintf(L"●");
		cur = cur->next;
	}
}
  • 作用: 打印蛇身在屏幕上。
  • 思路: 遍历链表，逐个输出蛇身位置的字符。
  • 知识点: 链表遍历、光标移动打印。

12. IsDie()

void IsDie() {
	Psnake* cur = SNAKE.psnakenode->next; // 从第二个节点开始
	Psnake* prev = SNAKE.psnakenode; // 保存蛇头节点用于比较

	while (cur->next) {
		cur = cur->next;
		if (cur->x == prev->x && cur->y == prev->y) { // 检查当前节点是否与之前的节点重合
			SNAKE.state = KILL_BY_SELF;
			return;
		}
		
	}

	if (SNAKE.psnakenode->x == 56||SNAKE.psnakenode->x==0 ||SNAKE.psnakenode->y==0||SNAKE.psnakenode->y == 28) {
		SNAKE.state = KILL_BY_WALL;
		return;
	}
}
  • 作用: 检查游戏是否结束（撞墙或自食）。
  • 思路: 检测是否撞到自身：将蛇头坐标与每个蛇身节点坐标相比较；撞墙：蛇头与游戏边界重叠。之后将蛇的状态修改。
  • 知识点: 边界条件检测、循环逻辑。

13. SnakeMove(Psnake** head)

//蛇的移动
void SnakeMove(Psnake** head)
{
	// 首先检查蛇头的下一个位置
	Psnake* next = (Psnake*)calloc(1, sizeof(Psnake));
	if (!next) {
		perror("Failed to allocate memory for next snake node");
		exit(EXIT_FAILURE);
	}

	// 根据当前方向设置蛇头的下一个位置
	switch (SNAKE.dir)
	{
	case UP:
		next->x = SNAKE.psnakenode->x;
		next->y = SNAKE.psnakenode->y - 1;
		break;
	case DOWN:
		next->x = SNAKE.psnakenode->x;
		next->y = SNAKE.psnakenode->y + 1;
		break;
	case LEFT:
		next->x = SNAKE.psnakenode->x - 2;
		next->y = SNAKE.psnakenode->y;
		break;
	case RIGHT:
		next->x = SNAKE.psnakenode->x + 2;
		next->y = SNAKE.psnakenode->y;
		break;
	default:
		free(next);
		return; // 如果方向无效，不移动蛇
	}

	// 检查下一个位置是否有食物
	if (FoodJudge(next))
	{
		SNAKE.score += SNAKE.food.score; // 增加得分
		next->next = (*head); // 将新节点放在头部
		*head = next; // 更新头指针
		CreateFood(*head); // 生成新的食物
	}
	else
	{
		// 没有食物，移动蛇的尾部到头部
		Psnake* tail = SNAKE.psnakenode;
		Psnake* prev = NULL;
		if (!(tail || prev))
		{
			perror("POINTER IS NULL:");
			return;
		}
		// 找到尾节点和其前一个节点
		while (tail->next) {
			prev = tail;
			tail = tail->next;
		}

		// 将尾部节点移动到头部
		prev->next = NULL; // 将前一个节点的next设置为NULL，它现在是尾部
		set_pos(tail->x, tail->y);
		wprintf(L"  ");

		tail->next = SNAKE.psnakenode; // 将原尾部节点放在头部
		SNAKE.psnakenode = tail; // 更新头指针

		// 更新头部位置
		SNAKE.psnakenode->x = next->x;
		SNAKE.psnakenode->y = next->y;

		// 释放之前分配的next节点，因为我们只是移动了尾部节点
		free(next);
	}
	IsDie();
	PrintSnake(SNAKE.psnakenode);
}
  • 作用: 处理蛇的移动逻辑，包括食物检测和身体跟随。
  • 思路:申请三个节点（蛇头前左右） 用switch对蛇的方向进行判断（先让蛇头走一步），判断该方向下一节点是否为食物，将蛇身剩下的节点逐个移动一个节点。

移动分两部分，蛇头移动和蛇身移动，先让蛇头走一步，蛇身每个节点进行移动

  • 知识点: 方向判断、链表头节点更新、内存释放。

14.ClearScreen( )


void ClearScreen() {  // 定义清屏函数，适用于Windows和Linux/macOS
#ifdef _WIN32
	system("cls");
#else
	system("clear");
#endif
}
  • 作用: 清除屏幕内容。
  • 思路: 根据操作系统调用不同的清屏命令。

#ifdef 与 #endif 要成对存在

  • 知识点: 条件编译、系统调用。

15.GameOver( int score )

void GameOver(int score) {
	// 游戏结束后的善后处理
	ClearScreen();  // 清除屏幕

	wprintf(L"Game Over!\n");  // 打印游戏结束信息
	wprintf(L"总分: %d\n", score);  // 显示玩家得分

	// 询问玩家是否想再玩一次
	wprintf(L"再来一次？(y/n): ");

	system("pause >> nul");
	if (_KEY_STATE(0x59)){
		GameStart();
		fflush(stdin);
	}
	else {
		wprintf(L"感谢游玩\n");
		exit(0);  // 结束程序
	}
}
  • 作用: 游戏结束时显示分数，并询问是否重新开始。
  • 思路: 显示最终得分，根据用户输入决定是否重启游戏。

system("pause>>nul"); 与 system("pause"); 效果类似，后者会打印按任意键继续字样，前者不会

  • 知识点: 用户输入读取、流程控制。

16.  GameRun(Psnake**head)

void GameRun(Psnake**head)
{
	do
	{
		set_pos(60, 6);
		wprintf(L"当前分数: %d", SNAKE.score);

		if ((_KEY_STATE(VK_UP) || _KEY_STATE(0x57)) && SNAKE.dir != DOWN)
		{
			SNAKE.dir = UP;
		}
		else if ((_KEY_STATE(VK_DOWN) || _KEY_STATE(0x53)) && SNAKE.dir != UP)
		{
			SNAKE.dir = DOWN;
		}
		else if ((_KEY_STATE(VK_LEFT) || _KEY_STATE(0x41)) && SNAKE.dir != RIGHT)
		{
			SNAKE.dir = LEFT;
		}
		else if ((_KEY_STATE(VK_RIGHT) || _KEY_STATE(0x44)) && SNAKE.dir != LEFT)
		{
			SNAKE.dir = RIGHT;
		}
		else if (_KEY_STATE(0x71)&&SNAKE.speed>=0&&SNAKE.speed<=500)
		{
			(SNAKE.speed) -= 30;
		}		
		else if (_KEY_STATE(0x72)&&SNAKE.speed>=0&&SNAKE.speed<=500)
		{
			(SNAKE.speed) += 30;
		}
		else if (_KEY_STATE(0x50))
		{
			SNAKE.speed = 2147483647;
		}

		SnakeMove(head);
		Sleep(SNAKE.speed);
	} while (SNAKE.state == RUN);
	GameOver(SNAKE.score);
}
  • 作用: 游戏主循环，处理用户输入和游戏逻辑。
  • 思路: 此处do while效果要比while效果要好，通过检测检测按键状态来确定蛇的移动方向。

虚拟键码（Virtual Key Codes）是在计算机键盘输入中使用的一套编码标准，用于标识键盘上的每一个按键，无论键盘的实际物理布局如何。

  • 知识点: 主循环控制、事件响应、时间延迟。

17.  GameStart ()

//开始游戏及游戏前准备
void GameStart()
{
	cover();

	SNAKE.psnakenode = (Psnake*)malloc(sizeof(Psnake));
	InitSnake(&SNAKE.psnakenode);
	PrintSnake(SNAKE.psnakenode);

	CreateFood(SNAKE.psnakenode);


	set_pos(40, 36);
	GameRun(&SNAKE.psnakenode);
}
  • 作用: 游戏启动入口，包含初始化、封面展示和游戏开始。
  • 思路: 先展示封面，初始化游戏环境，然后进入游戏主循环。

将蛇“创建”出来，作为游戏运行的主体

  • 知识点: 函数调用顺序、程序入口点。

Review

整理一下思路：

  1. 需求分析

    • 明确游戏目标：控制蛇吃食物变长，避免碰撞自身或边界。
    • 确定基本功能：初始化游戏、绘制游戏界面、处理用户输入、蛇的移动与增长、食物的随机生成、碰撞检测、得分计算、游戏结束与重开机制。

  2. 技术选型与环境搭建

    • 准备vs2022

  3. 核心模块设计

    • 游戏界面：设计简洁直观的游戏界面，包括游戏区域、分数显示、游戏说明等。
    • 蛇的实现：
      • 数据结构：链表或数组来存储蛇身的各个部分。
      • 移动逻辑：根据用户输入改变蛇头方向，自动延伸蛇身。
    • 食物管理：随机位置生成食物，检测蛇头碰撞并重新生成。
    • 碰撞检测：检查蛇头是否触碰边界或自身身体。
    • 得分系统：每次吃到食物增加分数，记录最高分。

  4. 用户交互

    • 接收用户输入（键盘/触摸），转换为游戏内操作指令。
    • 提供开始新游戏、退出游戏等选项。

  5. 性能与优化

    • 优化游戏循环，确保流畅运行。
    • 考虑内存管理，避免内存泄漏。

        在这个数字编织的宇宙🌌中，你已悄然绘制了一条属于自己的璀璨轨迹。

        每一次思考与实践，都在为你的技能之树浇灌成长的甘露🌱。愿你带着这份宝贵的经历，继续遨游于代码的星辰大海，发现更多的奇遇与美好。

      加油，程序员之旅的探险者们，前路广阔，星辰大海，我们共勉！🚀✨

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/682568.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

[论文笔记]Mixtral of Experts

[论文笔记]Mixtral of Experts

引言 今天带来大名鼎鼎的Mixtral of Experts的论文笔记&#xff0c;即Mixtral-8x7B。 作者提出了Mixtral 8x7B&#xff0c;一种稀疏专家混合(Sparse Mixture of Experts&#xff0c;SMoE)语言模型。Mixtral与Mistral 7B具有相同的架构&#xff0c;不同之处在于每个层由8个前馈…
阅读更多...
Mybatis03-ResultMap及分页

Mybatis03-ResultMap及分页

1、属性名和字段名不一致问题 1.问题 数据库中的字段 新建一个项目Mybatis-04&#xff0c;拷贝之前&#xff0c;测试实体类字段不一致的情况 public class User {private int id;private String name;private String password; }select * from mybatis.user where id #{id} …
阅读更多...
2024年会计、金融与工商管理国际会议（ICAFBA 2024）

2024年会计、金融与工商管理国际会议（ICAFBA 2024）

2024年会计、金融与工商管理国际会议 2024 International Conference on Accounting, Finance, and Business Administration 【1】会议简介 2024年会计、金融与工商管理国际会议是一场集合了全球会计、金融与工商管理领域专家学者的学术盛会。此次会议旨在深入探讨会计、金融与…
阅读更多...
【C++课程学习】：类和对象（上）（类的基础详细讲解）

【C++课程学习】：类和对象（上）（类的基础详细讲解）

&#x1f381;个人主页&#xff1a;我们的五年 &#x1f50d;系列专栏&#xff1a;C课程学习 &#x1f389;欢迎大家点赞&#x1f44d;评论&#x1f4dd;收藏⭐文章 目录 &#x1f35f;1.1类的引出&#xff1a; &#x1f35f;1.2类的结构&#xff1a; &#x1f35f;1.3类的…
阅读更多...
进入新公司有焦虑感怎么办？

进入新公司有焦虑感怎么办？

前因 前两天技术交流群里有童鞋问了一个很有意思的问题&#xff0c;他问如何克服进入新公司的焦虑感&#xff1f;很多热心的童鞋都纷纷支招&#xff0c;比如 “主动干活”、“专注干活”、“让时间冲淡焦虑感”、……等等&#xff0c;这些都很有道理&#xff0c;不过&#xff…
阅读更多...
解决uniapp中的tsconfig.json文件配置nativeTags,报错属性不存在

解决uniapp中的tsconfig.json文件配置nativeTags,报错属性不存在

将Vue - Official版本修改到2.0.12 再重启即可
阅读更多...
最小栈、栈的弹出(C++)

最小栈、栈的弹出(C++)

1.最小栈 思路分析&#xff1a; 代码&#xff1a; class MinStack { public:MinStack() {}void push(int val) {st.push(val);//两种情况需要更新最小值//1.最小栈为空(就是存最小值的那个栈)//2.插入的值小于或等于最小栈的栈顶元素if(minstack.empty()||minstack.top()>…
阅读更多...
高并发系统限流原理

高并发系统限流原理

短时间内巨大的访问流量&#xff0c;我们如何让系统在处理高并发的同时还能保证自身系统的稳定性&#xff1f;估计有人会说&#xff0c;增加机器就可以了&#xff0c;因为我的系统架构设计就是按照分布式思想进行架构设计的&#xff0c;所以可以只需要增加机器就可以解决问题了…
阅读更多...
word自带公式编辑器技巧

word自带公式编辑器技巧

1.实现多行公式换行且对齐 1.1 准备阶段&#xff08;默认Unicode模式&#xff09; 进入公式编辑模式&#xff0c;输入\eqarray&#xff0c;紧接着按下空格键输入空格&#xff0c;如下 1.2 实现换行和对齐 将要编辑的公式输入到括号内 &&#xff1a;实现位置对齐 &…
阅读更多...
【微机原理与汇编语言】循环程序设计

【微机原理与汇编语言】循环程序设计

一、实验目的 1.熟练掌握8086/8088常用汇编指令的使用方法 2.熟练掌握循环结构程序编程技巧 3.熟练掌握汇编语言程序运行调试方法 二、实验要求 认真分析实验题目&#xff0c;设计程序流程图&#xff0c;独立完成代码编写及运行调试。 三、实验题目 给出不大于255的十个…
阅读更多...
中信证券：A股下半年将迎来年度级别上涨行情的起点

中信证券：A股下半年将迎来年度级别上涨行情的起点

中信证券认为&#xff0c; 过去3年压制A股表现的经济动能转换&#xff0c;资本市场生态&#xff0c;中美战略博弈这三大叙事都将迎来重大拐点&#xff0c;随着政策、价格、外部三类信号逐步验证&#xff0c;2024年下半年A股市场将迎来年度级别上涨行情的起点 过去3年压制A股表…
阅读更多...
uniapp小程序开发 | 从零实现一款影视类app （后台接口实现，go-zero微服务的使用）

uniapp小程序开发 | 从零实现一款影视类app （后台接口实现，go-zero微服务的使用）

uniapp小程序开发实战系列&#xff0c;完整介绍从零实现一款影视类小程序。包含小程序前端和后台接口的全部完整实现。系列连载中&#xff0c;喜欢的可以点击收藏。 该篇着重介绍获取轮播图后台接口和获取正在热映电影的两个后台接口的实现。 后台服务使用golang&#xff0c;…
阅读更多...
vue3学习（七）

vue3学习（七）

前言 接上一篇学习笔记&#xff0c;今天主要是分享上次学习完了&#xff0c;还没来得及记录&#xff0c;趁今天晚上换换脑子的时间记录下。 今天主要是记录的vuex文件的拆分&#xff0c;因为毕竟如果只在一个index.js文件写&#xff0c;文件会随着业务的复杂性上升&…
阅读更多...
益智内容教培教育课程小程序的效果是什么

益智内容教培教育课程小程序的效果是什么

从孩子出生开始&#xff0c;很多家长们就可以开始制定学习计划&#xff0c;幼儿园前后时间段益智学习家长们很看重&#xff0c;各样的线上课程、线下读本及老师指导等。 市场中也有相关从业公司&#xff0c;在品牌拓展和内容触达转化方面发力&#xff0c;客商双方服务获取条件…
阅读更多...
王道408数据结构CH4_串

王道408数据结构CH4_串

概述 4 串 4.1 串的实现 4.1.1 存储结构 定长顺序存储 #define Maxsize 255typedef struct{char *ch[Maxsize];int length; }SString;堆分配存储 typedef struct{char *ch;int length; }HString;块链存储 4.1.2 基本操作 4.2 模式匹配&#xff08;子串定位&#xff09; 4.2.…
阅读更多...
如何有效防御.360勒索病毒：.360勒索病毒加密文件预防方法探讨

如何有效防御.360勒索病毒：.360勒索病毒加密文件预防方法探讨

导言&#xff1a; 随着信息技术的飞速发展&#xff0c;网络安全问题也日益凸显。其中&#xff0c;勒索病毒作为一种新型的网络安全威胁&#xff0c;给用户和企业带来了极大的困扰和损失。特别是.360勒索病毒&#xff0c;以其独特的加密方式和恶劣的勒索手段&#xff0c;引起了…
阅读更多...
宝兰德参编！《2023年中国数据库年度行业分析报告》正式发布

宝兰德参编！《2023年中国数据库年度行业分析报告》正式发布

近日&#xff0c;墨天轮发布 《2023年中国数据库年度行业分析报告》&#xff08;以下简称《报告》&#xff09;。宝兰德深度参与《报告》重要章节内容的编写工作&#xff0c;凭借在中间件领域深厚的技术沉淀和丰富的实践经验&#xff0c;输出了大量具有专业性和前瞻性的意见&am…
阅读更多...
计算机组成原理一轮

计算机组成原理一轮

目录 一、计算机系统概论 组成 概念 二、计算机的运算方法 二进制和八进制、二进制和八进制间的转换 任意进制数转换为十进制数 十进制转二进制 移码 定点数的移位运算 定点数的加减运算 定点数的乘除运算 相乘 相除 溢出的判别方法 采用一位符号位 采用双符号…
阅读更多...
【微机原理与汇编语言】并行接口8255实验

【微机原理与汇编语言】并行接口8255实验

一、实验目的 掌握可编程并行接口芯片8255的工作原理及初始化方法掌握8255在实际应用中的硬件连接及编程应用 二、实验要求 根据实验室现有条件&#xff0c;针对实验任务&#xff0c;设计实验方案并进行实现。 三、实验内容 启动0#计数器&#xff0c;每计5个数&#xff08…
阅读更多...
elasticsearch安装与使用(1)-使用docker安装Elasticsearch

elasticsearch安装与使用(1)-使用docker安装Elasticsearch

1、Elasticsearch安装 docker network create elastic docker pull docker.elastic.co/elasticsearch/elasticsearch:8.3.3 docker run --name es-node01 --net elastic -p 9200:9200 -p 9300:9300 -it docker.elastic.co/elasticsearch/elasticsearch:8.3.3-----------------…
阅读更多...
最新文章

Copyright @ 2022~2023