C语言实现贪吃蛇

前言

贪吃蛇是一款经典的休闲益智类电子游戏，通常用C语言实现时，会涉及到以下几个主要部分：

游戏初始化：设置游戏窗口大小、颜色、速度等参数，并初始化蛇的长度和位置。
游戏循环：在一个无限循环中，不断更新游戏状态，包括蛇的移动、食物的生成和碰撞检测等。
蛇的移动：根据用户的输入（通常是方向键），控制蛇的头部向相应方向移动，并更新蛇的身体位置。
食物的生成：在游戏区域内随机生成食物，并标记其位置。
碰撞检测：检测蛇是否吃到食物、是否碰到游戏边界或自己的身体。
游戏结束条件：如果蛇碰到游戏边界或自己的身体，游戏结束，显示游戏结束画面。
渲染画面：使用图形库（如SDL、Allegro等）绘制游戏界面，包括蛇、食物和游戏边界等。

在C语言中，这些功能通常通过定义结构体来管理游戏状态，使用函数来实现各个功能模块，并通过循环和条件语句来控制游戏流程。实现过程中还需要考虑性能优化和用户体验等因素。

一、游戏背景

贪吃蛇是久负盛名的游戏，它也和俄罗斯方块，扫雷等游戏位列经典游戏的行列。

在编程语言的学习中，我将以贪吃蛇为例，从设计到代码来展示一个C语言项目实战，进而再一步提升读者对C语言的理解和认知。

二、游戏效果演示

三、课程目标

使用C语言在Windows环境的控制台中模拟实现经典小游戏贪吃蛇

实现基本的功能：

贪吃蛇地图绘制
蛇吃食物的功能（上、下、左、右方向键控制蛇的动作）
蛇撞墙死亡
蛇撞自身死亡
计算得分
蛇身加速、减速
暂停游戏

四、项目定位

提高读者对编程的兴趣
对C语言语法做一个基本的巩固。
对游戏开发有兴趣的读者做一个启发。
项目适合：C语言学完的同学，有一定的代码能力，初步接触数据结构中的链表。

五、技术要点

C语言函数、枚举、结构体、动态内存管理、预处理指令、链表、Win32 API等。

六、Win32 API介绍

本次实现贪吃蛇会使用到的一些Win32 API知识，那么就学习一下

Win32 API是Windows操作系统提供的一套应用程序接口，它允许开发者使用C或C++等编程语言来创建各种Windows应用程序。自Windows 3.1版本起，Win32 API已成为Windows软件开发的基石，为开发者提供了丰富的功能和工具，从基础的系统服务到高级的图形和多媒体支持。

使用Win32 API，开发者可以控制Windows操作系统的各个层面，从创建窗口和处理用户输入，到文件操作、网络编程和图形渲染等。这使得开发者能够构建出功能强大、性能卓越的应用程序，满足各种复杂的业务需求。

Win32 API的一个重要特点是其稳定性。多年来，尽管Windows操作系统经历了多个版本的更新和迭代，但Win32 API的基本结构和功能都保持了高度的稳定性。这使得开发者可以在不同的Windows版本上开发和维护应用程序，而不必担心API的兼容性问题。

然而，随着技术的不断进步和用户需求的变化，Win32 API也面临着一些挑战。一方面，随着Windows操作系统的升级，一些旧的API函数可能不再被推荐使用，甚至被新的API函数所替代。另一方面，随着移动互联网和云计算的快速发展，传统的Win32应用程序在某些场景下面临着性能和兼容性的挑战。

为了应对这些挑战，微软不断推出新的技术和工具来支持Win32应用程序的开发。例如，Universal Windows Platform（UWP）是一种全新的应用程序平台，它提供了更加现代化的API和框架，使得开发者能够创建出更加高效、美观和兼容的应用程序。同时，微软还提供了各种工具和服务来帮助开发者将传统的Win32应用程序迁移到UWP平台，以确保应用程序能够在未来的Windows操作系统上继续运行。

总之，Win32 API作为Windows应用程序开发的基础，为开发者提供了丰富的功能和工具。尽管面临着一些挑战和变化，但通过不断的技术创新和升级，Win32 API将继续在Windows应用程序开发中发挥着重要的作用。

6.1 Win32 API

Windows这个多作业系统除了协调应用程序的执行、分配内存、管理资源之外，它同时也是一个很大的服务中心，调用这个服务中⼼的各种服务（每一种服务就是一个函数），可以帮应用程序达到开启视窗、描绘图形、使用周边设备等目的，由于这些函数服务的对象是应用程序(Application)，所以便称之为 Application Programming Interface，简称API函数。WIN32 API也就是Microsoft Windows32位平台的应用程序编程接口。

6.2 控制台程序

平常我们运行起来的黑框程序其实就是控制台程序

注意：并不是所有的vs2022运行起来的黑框程序都是控制台程序

我们可以通过右键来更改运行的黑框程序

我们可以使用cmd命令来设置控制台窗口的长宽：设置控制台窗口的大小，30行，100列

mode con cols=100 lines=30

参考：mode命令

注意： 在控制台上写程序不要写成mode con cols = 100 lines = 30 ,多加空格也会导致程序运行不了

如上所示

也可以通过命令设置控制台窗口的名字：

title 贪吃蛇

参考：title命令

这些能在控制台窗口执行的命令，也可以调用C语言函数system来执行。例如：

#include <stdio.h>
int main()
{
 //设置控制台窗口的长宽：设置控制台窗口的大小，30行，100列 
  system("mode con cols=100 lines=30");
 //设置cmd窗口名称
  system("title 贪吃蛇"); 
  return 0;
}

6.3 控制台屏幕上的坐标COORD

COORD是Windows API中定义的一个结构体，表示一个字符在控制台屏幕上的坐标

typedef struct _COORD {
 SHORT X;
 SHORT Y;
} COORD, *PCOORD;

给坐标赋值：

COORD pos = { 10, 15 };

6.4 GetStdHandle

GetStdHandle是一个Windows API函数。它用于从一个特定的标准设备（标准输入、标准输出或标准错误）中取得一个句柄（用来标识不同设备的数值），使用这个句柄可以操作设备。

句柄，作为计算机编程中的一个核心概念，它是对资源引用的抽象表示。无论是文件、网络连接、图形界面元素还是其他类型的资源，句柄都提供了一种统一且灵活的方式来管理和操作这些资源。

在操作系统的底层，句柄是资源管理器分配的一个标识符，它指向内存中的一个数据结构，该数据结构包含了关于资源的所有信息。通过句柄，应用程序可以间接地访问和操作这些资源，而无需关心资源在内存中的具体位置和细节。

句柄的重要性在于其提供了一种资源隔离和保护的机制。由于句柄是对资源的抽象引用，因此操作系统可以通过控制句柄的访问权限来实现对资源的访问控制。例如，当一个进程试图访问一个文件句柄时，操作系统会检查该进程是否具有相应的权限，如果没有，则拒绝访问请求。

此外，句柄还提供了资源管理的便利性。当应用程序不再需要某个资源时，它可以通过关闭句柄来释放该资源，这样操作系统就可以回收该资源并将其分配给其他需要的应用程序。这种动态的资源分配方式使得操作系统能够更加高效地管理系统资源。

在现代操作系统中，句柄的概念得到了广泛的应用。无论是Windows、Linux还是macOS等操作系统，都采用了句柄机制来管理各种资源。通过句柄，操作系统为应用程序提供了一个稳定且一致的接口，使得应用程序能够更加方便地访问和操作系统资源。

综上所述，句柄作为计算机编程中的一个核心概念，不仅提供了一种统一且灵活的方式来管理和操作资源，还提供了资源隔离、保护和管理的便利性。在未来的计算机系统中，句柄将继续发挥重要作用，为应用程序提供更加高效、安全和便捷的资源访问方式。

HANDLE GetStdHandle(DWORD nStdHandle);

实例：

HANDLE hOutput = NULL;
//获取标准输出的句柄(用来标识不同设备的数值) 
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);

6.5 GetConsoleCursorInfo

检索有关指定控制台屏幕缓冲区的光标大小和可见性的信息

BOOL WINAPI GetConsoleCursorInfo(HANDLE hConsoleOutput,PCONSOLE_CURSOR_INFO lpConsoleCursorInfo);

PCONSOLE_CURSOR_INFO 是指向 CONSOLE_CURSOR_INFO 结构的指针，该结构接收有关主机游标（光标）的信息

实例：

HANDLE hOutput = NULL;
//获取标准输出的句柄(用来标识不同设备的数值) 
hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(hOutput, &CursorInfo);//获取控制台光标信息

6.5.1 CONSOLE_CURSOR_INFO

这个结构体，包含有关控制台光标的信息

typedef struct _CONSOLE_CURSOR_INFO {
 DWORD dwSize;
 BOOL bVisible;
} CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO;

dwSize，由光标填充的字符单元格的百分比。此值介于1到100之间。光标外观会变化，范围从完全填充单元格到单元底部的水平线条。
bVisible，游标的可见性。如果光标可见，则此成员为TRUE。

CursorInfo.bVisible = false; //隐藏控制台光标

6.6 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);//设置控制台光标状态

6.7 SetConsoleCursorPosition

设置指定控制台屏幕缓冲区中的光标位置，我们将想要设置的坐标信息放在COORD类型的pos中，调用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);
}

6.8 GetAsyncKeyState

获取按键情况，GetAsyncKeyState的函数原型如下：

SHORT GetAsyncKeyState(int vKey);

将键盘上每个键的虚拟键值传递给函数，函数通过返回值来分辨按键的状态。

参考：虚拟键代码

GetAsyncKeyState 的返回值是short类型，在上一次调用 GetAsyncKeyState 函数后，如果返回的16位的short数据中，最高位是1，说明按键的状态是按下，如果最高是0，说明按键的状态是抬起；如果最低位被置为1则说明，该按键被按过，否则为0。

如果我们要判断一个键是否被按过，可以检测GetAsyncKeyState返回值的最低值是否为1.

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

0x1  即0x0000 0001  & 0x???? ???1  == 0000 0001或0000 0000

实例：检测数字键

#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;
}

七、贪吃蛇游戏设计与分析

7.1 地图

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

这里不得不讲一下控制台窗口的一些知识，如果想在控制台的窗口中指定位置输出信息，我们得知道该位置的坐标，所以首先介绍一下控制台窗口的坐标知识。

控制台窗口的坐标所示，横向的是X轴，从左向右依次增长，纵向是Y轴，从上到下依次增长。

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

这里再简单的讲一下C语言的国际化特性相关的知识，过去C语言并不适合非英语国家（地区）使用。

C语言最初假定字符都是但自己的。但是这些假定并不是在世界的任何地方都适用。

C语言字符默认是采用ASCII编码的，ASCII字符集采用的是单字节编码，且只使用了单字节中的低7位，最高位是没有使用的，可表示为0xxxxxxxx；可以看到，ASCII字符集共包含128个字符，在英语国家中，128个字符是基本够用的，但是，在其他国家语言中，比如，在法语中，字母上方有注音符号，它就无法用ASCII码表示。于是，一些欧洲国家就决定，利用字节中闲置的最高位编入新的符号。比如，法语中的é的编码为130（二进制10000010）。这样一来，这些欧洲国家使用的编码体系，可以表示最多256个符号。但是，这里又出现了新的问题。不同的国家有不同的字母，因此，哪怕它们都使用256个符号的编码方式，代表的字母却不一样。比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel(后来为了使C语言适应国际化，C语言的标准中不断加入了国际化的支持。

比如：加入和宽字符的类型wchar_t 和宽字符的输入和输出函数，加入和<locale.h>头文件，其中提供了允许程序员针对特定地区（通常是国家或者说某种特定语言的地理区域）调整程序行为的函数。

7.1.1 <locale.h>本地化

<locale.h>提供的函数用于控制C标准库中对于不同的地区会产生不一样行为的部分。

在标准可以中，依赖地区的部分有以下几项：

数字量的格式
货币量的格式
字符集
日期和时间的表示形式

7.1.2 类项

通过修改地区，程序可以改变它的行为来适应世界的不同区域。但地区的改变可能会影响库的许多部分，其中一部分可能是我们不希望修改的。所以C语言支持针对不同的类项进行修改，下面的一个宏，指定一个类项：

LC_COLLATE：影响字符串比较函数 strcoll() 和 strxfrm() 。
LC_CTYPE：影响字符处理函数的行为。
LC_MONETARY：影响货币格式。
LC_NUMERIC：影响 printf() 的数字格式。
LC_TIME：影响时间格式 strftime() 和 wcsftime() 。
LC_ALL-针对所有类项修改，将以上所有类别设置为给定的语言环境。

每个类项的详细说明，请参考

7.1.3 setlocale函数

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

setlocale函数用于修改当前地区，可以针对一个类项修改，也可以针对所有类项。

setlocale的第一个参数可以是前面说明的类项中的一个，那么每次只会影响一个类项，如果第一个参数是LC_ALL，就会影响所有的类项。

C标准给第二个参数仅定义了2种可能取值：

setlocale(LC_ALL, "C");

当地区设置为"C"，库函数按正常方式执行，小数点是一个点。

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

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

7.1.4 宽字符的打印

那如果想在屏幕上打印宽字符，怎么打印呢？

#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"%c\n", ch1);
  wprintf(L"%c\n", ch2);
  wprintf(L"%c\n", ch3);
  wprintf(L"%c\n", ch4);
  return 0;
}

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

普通字符和宽字符打印出宽度的展示如下：

7.1.5 地图坐标

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

7.2 蛇身和食物

初始化状态，假设蛇的长度是5，蛇身的每个节点是●，在固定的一个坐标处，比如(24,5)处开始出现蛇，连续5个节点。

注意：蛇的每个节点的x坐标必须是2个倍数，否则可能会出现蛇的一个节点有一半出现在墙体中，另外一般在墙外的现象，坐标不好对⻬。

关于食物，就是在墙体内随机生成一个坐标（x坐标必须是2的倍数），坐标不能和蛇的身体重合，然后打印★。

7.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//正常结束 
};

7.4 游戏流程设计

八、核心逻辑实现分析

程序开始就设置程序支持本地模式，然后进入游戏的主逻辑。

8.1 游戏主逻辑

主逻辑分为3个过程：

游戏开始（GameStart）完成游戏的初始化
游戏运行（GameRun）完成游戏运行逻辑的实现
游戏结束（GameEnd）完成游戏结束的说明，实现资源释放

#include "Snake.h"
#include <locale.h>
void test()
{
  int ch = 0;
  srand((unsigned int)time(NULL));
  do
  {
    system("cls");
    Snake snake = { 0 };
    GameStart(&snake);
    GameRun(&snake);
    GameEnd(&snake);
    SetPos(20, 15);
    printf("再来一局吗？(Y/N):");
    scanf("%c", &ch);
  } while (ch == 'Y'|| ch == 'y');
  SetPos(0, 27);
}
int main()
{
  //修改当前地区为本地模式，为了支持中文宽字符的打印 
  setlocale(LC_ALL, "");
  //测试逻辑 
  test();
  return 0;
}

8.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);
}

8.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");
}

8.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);
  }
}

8.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"%c", BODY);
    cur = cur->next;
  }
  //初始化贪吃蛇数据 
  ps->_SleepTime = 200;
  ps->_Socre = 0;
  ps->_Status = OK;
  ps->_Dir = RIGHT;
  ps->_foodWeight = 10;
}

8.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;
  }
}

8.3 游戏运行

游戏运行期间，右侧打印帮助信息，提示玩家，坐标开始位置(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 >= 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);
}

8.3.1 KEY_PRESS

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

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

8.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：暂停游戏.");
}

8.3.3 蛇身移动

先创建下一个节点，根据移动方向和蛇头的坐标，蛇移动到下一个位置的坐标。

确定了下一个位置后，看下一个位置是否是食物（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);
}

8.3.3.1 NextIsFood

int NextIsFood(pSnakeNode psn, pSnake ps)
{
  return (psn->x == ps->_pFood->x) && (psn->y == ps->_pFood->y);
}

8.3.3.2 EatFood

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);
}

8.3.3.3 NoFood

将下一个节点头插入蛇的身体，并将之前蛇身最后一个节点打印为空格，放弃掉蛇身的最后一个节点

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;
}

8.3.3.4 KillByWall

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

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;
}

8.3.3.5 KillBySelf

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

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;
}

8.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个文件实现

snake.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#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);

test.cpp

#include "Snake.h"
#include <locale.h>
void test()
{
  int ch = 0;
  srand((unsigned int)time(NULL));
  do
  {
    system("cls");
    Snake snake = { 0 };
    GameStart(&snake);
    GameRun(&snake);
    GameEnd(&snake);
    SetPos(20, 15);
    printf("再来一局吗？(Y/N):");
    scanf("%c", &ch);
  } while (ch == 'Y'|| ch == 'y');
  SetPos(0, 27);
}
int main()
{
  //修改当前地区为本地模式，为了支持中文宽字符的打印 
  setlocale(LC_ALL, "");
  //测试逻辑 
  test();
  return 0;
}

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：暂停游戏.");
}
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);
  }
}

文献参考

汉字字符集编码查询;中文字符集编码:GB2312、BIG5、GBK、GB18030、Unicode

C语言项目实战——贪吃蛇