【C语言】贪吃蛇【附源码】

news2024/11/27 16:31:12

欢迎来到英杰社区icon-default.png?t=N7T8https://bbs.csdn.net/topics/617804998

一、游戏说明：

一个基于C语言链表开发的贪吃蛇游戏：

1. 按方向键上下左右，可以实现蛇移动方向的改变。

2. 短时间长按方向键上下左右其中之一，可实现蛇向该方向的短时间加速移动。

3. 按空格键可实现暂停，暂停后按任意键继续游戏。

4. 按Esc键可直接退出游戏。

5. 按R键可重新开始游戏。

代码中运用到了键盘虚拟键判断、终端窗口大小的改变、光标的定位以及输出字体的颜色

二、效果展示：

三、代码讲解：

        首先导入必要模块：

        

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

#define ROW 22 //游戏区行数
#define COL 42 //游戏区列数

#define KONG 0 //标记空（什么也没有）
#define WALL 1 //标记墙
#define FOOD 2 //标记食物
#define HEAD 3 //标记蛇头
#define BODY 4 //标记蛇身

#define UP 72 //方向键：上
#define DOWN 80 //方向键：下
#define LEFT 75 //方向键：左
#define RIGHT 77 //方向键：右
#define SPACE 32 //暂停
#define ESC 27 //退出

初始化函数 InitSnake():

它主要完成以下几个任务：

  1. 将蛇的长度初始化为2，初始位置设定在游戏界面的中央。
  2. 初始化蛇身体的位置，将蛇身体的坐标保存在数组 body[] 中。
  3. 将蛇头和蛇身体的位置在游戏界面上标记出来，使用 face[][] 数组来表示游戏界面，其中 HEAD 表示蛇头，BODY 表示蛇身。

//初始化蛇
void InitSnake()
{
  snake.len = 2; //蛇的身体长度初始化为2
  snake.x = COL / 2; //蛇头位置的横坐标
  snake.y = ROW / 2; //蛇头位置的纵坐标
  //蛇身坐标的初始化
  body[0].x = COL / 2 - 1;
  body[0].y = ROW / 2;
  body[1].x = COL / 2 - 2;
  body[1].y = ROW / 2;
  //将蛇头和蛇身位置进行标记
  face[snake.y][snake.x] = HEAD;
  face[body[0].y][body[0].x] = BODY;
  face[body[1].y][body[1].x] = BODY;
}

随机生成食物的函数 RandFood():

  1. 使用 rand() 函数生成一个随机的横纵坐标（i 和 j）作为食物的位置。
  2. 使用 do-while 循环来确保生成的食物位置为空（即 face[i][j] 等于 KONG，表示该位置为空）。
  3. 在游戏界面的相应位置标记食物，使用 FOOD 来表示食物。
  4. 将终端颜色设置为红色，使用 color(12) 函数。
  5. 将光标跳转到生成的随机位置处，使用 CursorJump(2 * j, i) 函数。
  6. 在食物位置打印食物图标，这里使用了 "●" 表示食物。
//随机生成食物
void RandFood()
{
  int i, j;
  do
  {
    //随机生成食物的横纵坐标
    i = rand() % ROW;
    j = rand() % COL;
  } while (face[i][j] != KONG); //确保生成食物的位置为空，若不为空则重新生成
  face[i][j] = FOOD; //将食物位置进行标记
  color(12); //颜色设置为红色
  CursorJump(2 * j, i); //光标跳转到生成的随机位置处
  printf("●"); //打印食物
}

打印蛇部分：

  • 如果 flag 的值为1，表示需要打印蛇。
  • 将终端颜色设置为绿色，使用 color(10) 函数。
  • 将光标跳转到蛇头的位置，使用 CursorJump(2 * snake.x, snake.y) 函数。
  • 在蛇头的位置打印蛇头图标，这里使用了 "■" 表示蛇头。
  • 使用 for 循环遍历蛇的身体，将光标跳转到每个蛇身体部分的位置，并打印蛇身体的图标，这里使用了 "□" 表示蛇身体。

覆盖蛇部分：

  • 如果 flag 的值不为1，表示需要覆盖蛇。
  • 首先检查蛇尾的位置是否为 (0, 0)，这是为了避免在蛇的长度增加时将墙壁位置覆盖。
  • 如果蛇尾的位置不是 (0, 0)，则将光标跳转到蛇尾的位置，并将该位置打印为空格，即将蛇尾覆盖掉。

void DrawSnake(int flag)
{
  if (flag == 1) //打印蛇
  {
    color(10); //颜色设置为绿色
    CursorJump(2 * snake.x, snake.y);
    printf("■"); //打印蛇头
    for (int i = 0; i < snake.len; i++)
    {
      CursorJump(2 * body[i].x, body[i].y);
      printf("□"); //打印蛇身
    }
  }
  else //覆盖蛇
  {
    if (body[snake.len - 1].x != 0) //防止len++后将(0, 0)位置的墙覆盖
    {
      //将蛇尾覆盖为空格即可
      CursorJump(2 * body[snake.len - 1].x, body[snake.len - 1].y);
      printf("  ");
    }
  }
}

移动蛇的函数：

  1. DrawSnake(0);：调用 DrawSnake 函数，将当前显示的蛇覆盖掉，参数 0 表示覆盖蛇。

  2. face[body[snake.len - 1].y][body[snake.len - 1].x] = KONG;：将蛇移动后原来的蛇尾位置标记为空。

  3. face[snake.y][snake.x] = BODY;：将蛇头移动后的新位置标记为蛇身。

  4. 更新蛇身体的位置：

    • 使用 for 循环从蛇尾开始，依次将每个蛇身体部分的位置更新为上一个蛇身体的位置，实现蛇身体的移动。

  5. 更新蛇头的位置：

    • 将蛇头的位置信息更新为移动后的新位置。

  6. DrawSnake(1);：调用 DrawSnake 函数，打印移动后的蛇，参数 1 表示打印蛇。

void MoveSnake(int x, int y)
{
  DrawSnake(0); //先覆盖当前所显示的蛇
  face[body[snake.len - 1].y][body[snake.len - 1].x] = KONG; //蛇移动后蛇尾重新标记为空
  face[snake.y][snake.x] = BODY; //蛇移动后蛇头的位置变为蛇身
  //蛇移动后各个蛇身位置坐标需要更新
  for (int i = snake.len - 1; i > 0; i--)
  {
    body[i].x = body[i - 1].x;
    body[i].y = body[i - 1].y;
  }
  //蛇移动后蛇头位置信息变为第0个蛇身的位置信息
  body[0].x = snake.x;
  body[0].y = snake.y;
  //蛇头的位置更改
  snake.x = snake.x + x;
  snake.y = snake.y + y;
  DrawSnake(1); //打印移动后的蛇
}

初始化设置：

  • int n = RIGHT;：开始游戏时，默认向右移动。
  • int tmp = 0;：记录蛇的移动方向。

游戏循环：

  • 使用 while(1) 构建游戏主循环，表示游戏一直进行。
  • n = getch();：获取键盘输入的方向控制。

方向控制调整：

  • 通过 switch 语句，根据用户输入的方向键来调整蛇的移动方向。
  • 如果用户按下的方向键与当前蛇的移动方向相反，则忽略该输入，保持蛇的当前移动方向不变。

蛇的移动：

  • 使用 switch 语句，根据当前的移动方向来调用 run 函数，实现蛇的移动，并更新 tmp 记录的当前移动方向。

游戏控制：

  • 如果用户按下空格键，则游戏暂停。
  • 如果用户按下 ESC 键，则清空屏幕并退出游戏。
  • 如果用户按下 'r' 或 'R' 键，则重新开始游戏，清空屏幕并调用 main 函数重新执行游戏。
void Game()
{
  int n = RIGHT; 
  int tmp = 0; 
  goto first; 
  while (1)
  {
    n = getch(); 
    switch (n)
    {
    case UP:
    case DOWN: 
      if (tmp != LEFT&&tmp != RIGHT) 
      {
        n = tmp; 
      }
      break;
    case LEFT:
    case RIGHT: 
      if (tmp != UP&&tmp != DOWN) 
      {
        n = tmp; 
      }
    case SPACE:
    case ESC:
    case 'r':
    case 'R':
      break; //这四个无需调整
    default:
      n = tmp;
      break;
    }
  first:
    switch (n)
    {
    case UP: 
      run(0, -1); 
      tmp = UP;
      break;
    case DOWN: 
      run(0, 1); 
      tmp = DOWN; 
      break;
    case LEFT: 
      run(-1, 0); 
      tmp = LEFT; 
      break;
    case RIGHT:
      run(1, 0); 
      tmp = RIGHT;
      break;
    case SPACE: 
      system("pause>nul"); 
      break;
    case ESC:
      system("cls"); 
      color(7);
      CursorJump(COL - 8, ROW / 2);
      printf("  游戏结束  ");
      CursorJump(COL - 8, ROW / 2 + 2);
      exit(0);
    case 'r':
    case 'R': 
      system("cls"); 
      main();
    }
  }
}

移动控制：

  • int x, int y：参数 x 和 y 表示蛇每次移动的横向和纵向偏移量。
  • int t = 0;：初始化一个计时器 t，用来控制蛇移动的速度。

移动循环：

  • 使用 while(1) 构建移动主循环，表示蛇一直在移动。
  • t 控制了蛇的移动速度。在每次移动前，程序会等待一段时间，然后才执行移动操作。

等待时间控制：

  • if (t == 0) t = 3000;：如果 t 的值为0，则将其设置为3000，控制蛇的移动速度。t 越小，蛇移动速度越快，可以根据需要调整这个值来设置游戏的难度。
  • 使用 while(--t) 循环来实现等待，即等待一段时间后再执行移动操作。

键盘检测：

  • if (kbhit() != 0)：检测键盘是否有输入，如果有输入，则退出当前循环，返回到 Game 函数读取键值。

移动和判断：

  • 如果没有键盘输入，即 t == 0，则执行移动蛇的操作，包括判断是否得分以及游戏是否结束。
  • 如果有键盘输入，就退出移动循环，返回到 Game 函数，等待下一次键盘输入。
void run(int x, int y)
{
  int t = 0;
  while (1)
  {
    if (t == 0)
      t = 3000; 
    while (--t)
    {
      if (kbhit() != 0) 
        break;
    }
    if (t == 0) 
    {
      JudgeFunc(x, y); 
      MoveSnake(x, y); 
    }
    else 
    {
      break;
    }
  }
}

判断食物：

  • 首先检查蛇头即将到达的位置是否是食物 (FOOD)，如果是，则表示蛇吃到了食物。
  • 如果蛇吃到了食物，则执行以下操作：
    • 蛇的长度增加 snake.len++，即蛇身加长。
    • 更新得分 grade += 10。
    • 打印当前得分，并重新随机生成食物。

判断墙或蛇身碰撞：

  • 如果蛇头即将到达的位置是墙 (WALL) 或者蛇身 (BODY)，则表示游戏结束。
  • 在游戏结束时，执行以下操作：
    • 暂停一段时间留给玩家反应时间 Sleep(1000)。
    • 清空屏幕 system("cls")。
    • 根据当前得分与最高记录的比较，打印相应的提示信息，包括是否打破最高记录以及游戏是否再来一局的询问。
    • 根据玩家的选择，决定是重新开始游戏还是退出程序。
void JudgeFunc(int x, int y)
{
  //若蛇头即将到达的位置是食物，则得分
  if (face[snake.y + y][snake.x + x] == FOOD)
  {
    snake.len++; //蛇身加长
    grade += 10; //更新当前得分
    color(7); //颜色设置为白色
    CursorJump(0, ROW);
    printf("当前得分:%d", grade); //重新打印当前得分
    RandFood(); //重新随机生成食物
  }
  //若蛇头即将到达的位置是墙或者蛇身，则游戏结束
  else if (face[snake.y + y][snake.x + x] == WALL || face[snake.y + y][snake.x + x] == BODY)
  {
    Sleep(1000); //留给玩家反应时间
    system("cls"); //清空屏幕
    color(7); //颜色设置为白色
    CursorJump(2 * (COL / 3), ROW / 2 - 3);
    if (grade > max)
    {
      printf("恭喜你打破最高记录，最高记录更新为%d", grade);
      WriteGrade();
    }
    else if (grade == max)
    {
      printf("与最高记录持平，加油再创佳绩", grade);
    }
    else
    {
      printf("请继续加油，当前与最高记录相差%d", max - grade);
    }
    CursorJump(2 * (COL / 3), ROW / 2);
    printf("GAME OVER");
    while (1) //询问玩家是否再来一局
    {
      char ch;
      CursorJump(2 * (COL / 3), ROW / 2 + 3);
      printf("再来一局?(y/n):");
      scanf("%c", &ch);
      if (ch == 'y' || ch == 'Y')
      {
        system("cls");
        main();
      }
      else if (ch == 'n' || ch == 'N')
      {
        CursorJump(2 * (COL / 3), ROW / 2 + 5);
        exit(0);
      }
      else
      {
        CursorJump(2 * (COL / 3), ROW / 2 + 5);
        printf("选择错误，请再次选择");
      }
    }
  }
}

函数 ReadGrade()：

  1. 首先，它尝试以只读的方式打开文件 "贪吃蛇最高得分记录.txt"。
  2. 如果文件打开失败（即文件不存在），则会以只写的方式打开文件，并将当前最高得分 max 写入文件中（初始时 max 可能为0）。
  3. 然后，将文件指针移到文件开头。
  4. 接着，从文件中读取一个整数，即最高得分记录，将其存储到变量 max 中。
  5. 最后，关闭文件，并将文件指针置空。

void ReadGrade()
{
  FILE* pf = fopen("贪吃蛇最高得分记录.txt", "r"); //以只读的方式打开文件
  if (pf == NULL) //打开文件失败
  {
    pf = fopen("贪吃蛇最高得分记录.txt", "w"); //以只写的方式打开文件
    fwrite(&max, sizeof(int), 1, pf); //将max写入文件（此时max为0），即将最高得分初始化为0
  }
  fseek(pf, 0, SEEK_SET); //使文件指针pf指向文件开头
  fread(&max, sizeof(int), 1, pf); //读取文件当中的最高得分到max当中
  fclose(pf); //关闭文件
  pf = NULL; //文件指针及时置空
}

函数 WriteGrade()：

  1. 首先，它以只写的方式打开文件 "贪吃蛇最高得分记录.txt"。
  2. 如果文件打开失败，即 pf 为空，那么程序会打印出一条错误信息，并退出程序。
  3. 如果文件打开成功，那么函数会将本局游戏的得分 grade 写入文件中。
  4. 最后，函数关闭文件，并将文件指针 pf 置空。
void WriteGrade()
{
  FILE* pf = fopen("贪吃蛇最高得分记录.txt", "w");
  if (pf == NULL)
  {
    printf("保存最高得分记录失败\n");
    exit(0);
  }
  fwrite(&grade, sizeof(int), 1, pf);
  fclose(pf);
  pf = NULL; 
}

主函数 main()：

  1. 首先，它声明了两个全局变量 max 和 grade，分别用来存储最高得分和本局游戏得分。
  2. 然后，在 main() 函数内部，通过 #pragma warning (disable:4996) 关闭了编译器的警告提示，可能是因为某些函数被认为是不安全的。
  3. 接着，初始化了两个全局变量 max 和 grade，将它们都设置为0。
  4. 使用 system() 函数设置了命令提示符窗口的标题为 "贪吃蛇"，并设置了窗口大小为84列 * 23行。
  5. 调用 HideCursor() 函数隐藏了命令提示符窗口中的光标。
  6. 调用 ReadGrade() 函数从文件中读取最高分到全局变量 max 中。
  7. 调用 InitInterface() 函数初始化游戏界面。
  8. 调用 InitSnake() 函数初始化贪吃蛇。
  9. 使用 srand((unsigned int)time(NULL)) 函数根据当前时间设置随机数种子。
  10. 调用 RandFood() 函数随机生成食物。
  11. 调用 DrawSnake(1) 函数在界面上绘制贪吃蛇。
  12. 最后，调用 Game() 函数开始游戏。

完整代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

#define ROW 22 //游戏区行数
#define COL 42 //游戏区列数

#define KONG 0 //标记空（什么也没有）
#define WALL 1 //标记墙
#define FOOD 2 //标记食物
#define HEAD 3 //标记蛇头
#define BODY 4 //标记蛇身

#define UP 72 //方向键：上
#define DOWN 80 //方向键：下
#define LEFT 75 //方向键：左
#define RIGHT 77 //方向键：右
#define SPACE 32 //暂停
#define ESC 27 //退出

//蛇头
struct Snake
{
    int len; //记录蛇身长度
    int x; //蛇头横坐标
    int y; //蛇头纵坐标
}snake;

//蛇身
struct Body
{
    int x; //蛇身横坐标
    int y; //蛇身纵坐标
}body[ROW * COL]; //开辟足以存储蛇身的结构体数组

int face[ROW][COL]; //标记游戏区各个位置的状态

//隐藏光标
void HideCursor();
//光标跳转
void CursorJump(int x, int y);
//初始化界面
void InitInterface();
//颜色设置
void color(int c);
//从文件读取最高分
void ReadGrade();
//更新最高分到文件
void WriteGrade();
//初始化蛇
void InitSnake();
//随机生成食物
void RandFood();
//判断得分与结束
void JudgeFunc(int x, int y);
//打印蛇与覆盖蛇
void DrawSnake(int flag);
//移动蛇
void MoveSnake(int x, int y);
//执行按键
void run(int x, int y);
//游戏主体逻辑函数
void Game();

int max, grade; //全局变量
int main()
{
#pragma warning (disable:4996) 
    max = 0, grade = 0; 
    system("title 贪吃蛇");
    system("mode con cols=84 lines=23");
    HideCursor(); //隐藏光标
    ReadGrade(); //从文件读取最高分到max变量
    InitInterface(); //初始化界面
    InitSnake(); //初始化蛇
    srand((unsigned int)time(NULL));
    RandFood(); 
    DrawSnake(1); //打印蛇
    Game(); //开始游戏
    return 0;
}

//隐藏光标
void HideCursor()
{
    CONSOLE_CURSOR_INFO curInfo; //定义光标信息的结构体变量
    curInfo.dwSize = 1; //如果没赋值的话，光标隐藏无效
    curInfo.bVisible = FALSE; //将光标设置为不可见
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); //获取控制台句柄
    SetConsoleCursorInfo(handle, &curInfo); //设置光标信息
}
//光标跳转
void CursorJump(int x, int y)
{
    COORD pos; //定义光标位置的结构体变量
    pos.X = x; //横坐标
    pos.Y = y; //纵坐标
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); //获取控制台句柄
    SetConsoleCursorPosition(handle, pos); //设置光标位置
}
void InitInterface()
{
    color(6); 
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            if (j == 0 || j == COL - 1)
            {
                face[i][j] = WALL; //标记该位置为墙
                CursorJump(2 * j, i);
                printf("■");
            }
            else if (i == 0 || i == ROW - 1)
            {
                face[i][j] = WALL; //标记该位置为墙
                printf("■");
            }
            else
            {
                face[i][j] = KONG; 
            }
        }
    }
    color(7);
    CursorJump(0, ROW);
    printf("当前得分:%d", grade);
    CursorJump(COL, ROW);
    printf("历史最高得分:%d", max);
}
void color(int c)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c); 

}
void ReadGrade()
{
    FILE* pf = fopen("贪吃蛇最高得分记录.txt", "r"); 
    if (pf == NULL) //打开文件失败
    {
        pf = fopen("贪吃蛇最高得分记录.txt", "w"); 
        fwrite(&max, sizeof(int), 1, pf);
    }
    fseek(pf, 0, SEEK_SET);
    fread(&max, sizeof(int), 1, pf);
    fclose(pf); //关闭文件
    pf = NULL; //文件指针及时置空
}
//更新最高分到文件
void WriteGrade()
{
    FILE* pf = fopen("贪吃蛇最高得分记录.txt", "w"); //以只写的方式打开文件
    if (pf == NULL) //打开文件失败
    {
        printf("保存最高得分记录失败\n");
        exit(0);
    }
    fwrite(&grade, sizeof(int), 1, pf); //将本局游戏得分写入文件当中
    fclose(pf); //关闭文件
    pf = NULL; //文件指针及时置空
}
void InitSnake()
{
    snake.len = 2; 
    snake.x = COL / 2; 
    snake.y = ROW / 2; 
    body[0].x = COL / 2 - 1;
    body[0].y = ROW / 2;
    body[1].x = COL / 2 - 2;
    body[1].y = ROW / 2;

    face[snake.y][snake.x] = HEAD;
    face[body[0].y][body[0].x] = BODY;
    face[body[1].y][body[1].x] = BODY;
}
void RandFood()
{
    int i, j;
    do
    {
        i = rand() % ROW;
        j = rand() % COL;
    } while (face[i][j] != KONG);
    face[i][j] = FOOD; 
    color(12); 
    CursorJump(2 * j, i); 
    printf("●"); 
}
void JudgeFunc(int x, int y)
{
    if (face[snake.y + y][snake.x + x] == FOOD)
    {
        snake.len++; 
        grade += 10; 
        color(7); 
        CursorJump(0, ROW);
        printf("当前得分:%d", grade);
        RandFood(); 
    }
    else if (face[snake.y + y][snake.x + x] == WALL || face[snake.y + y][snake.x + x] == BODY)
    {
        Sleep(1000);
        system("cls"); 
        color(7);
        CursorJump(2 * (COL / 3), ROW / 2 - 3);
        if (grade > max)
        {
            printf("恭喜你打破最高记录，最高记录更新为%d", grade);
            WriteGrade();
        }
        else if (grade == max)
        {
            printf("与最高记录持平，加油再创佳绩", grade);
        }
        else
        {
            printf("请继续加油，当前与最高记录相差%d", max - grade);
        }
        CursorJump(2 * (COL / 3), ROW / 2);
        printf("GAME OVER");
        while (1) 
        {
            char ch;
            CursorJump(2 * (COL / 3), ROW / 2 + 3);
            printf("再来一局?(y/n):");
            scanf("%c", &ch);
            if (ch == 'y' || ch == 'Y')
            {
                system("cls");
                main();
            }
            else if (ch == 'n' || ch == 'N')
            {
                CursorJump(2 * (COL / 3), ROW / 2 + 5);
                exit(0);
            }
            else
            {
                CursorJump(2 * (COL / 3), ROW / 2 + 5);
                printf("选择错误，请再次选择");
            }
        }
    }
}

void DrawSnake(int flag)
{
    if (flag == 1) 
    {
        color(10); 
        CursorJump(2 * snake.x, snake.y);
        printf("■"); 
        for (int i = 0; i < snake.len; i++)
        {
            CursorJump(2 * body[i].x, body[i].y);
            printf("□"); 
        }
    }
    else
    {
        if (body[snake.len - 1].x != 0) 
        {
            CursorJump(2 * body[snake.len - 1].x, body[snake.len - 1].y);
            printf("  ");
        }
    }
}
void MoveSnake(int x, int y)
{
    DrawSnake(0); 
    face[body[snake.len - 1].y][body[snake.len - 1].x] = KONG; 
    face[snake.y][snake.x] = BODY;

    for (int i = snake.len - 1; i > 0; i--)
    {
        body[i].x = body[i - 1].x;
        body[i].y = body[i - 1].y;
    }
    body[0].x = snake.x;
    body[0].y = snake.y;
    snake.x = snake.x + x;
    snake.y = snake.y + y;
    DrawSnake(1); 
}
void run(int x, int y)
{
    int t = 0;
    while (1)
    {
        if (t == 0)
            t = 3000;
        while (--t)
        {
            if (kbhit() != 0)
                break;
        }
        if (t == 0) //键盘未被敲击
        {
            JudgeFunc(x, y); //判断到达该位置后，是否得分与游戏结束
            MoveSnake(x, y); //移动蛇
        }
        else //键盘被敲击
        {
            break; 
        }
    }
}
void Game()
{
    int n = RIGHT; 
    int tmp = 0; 
    goto first; 
    while (1)
    {
        n = getch(); //读取键值
        switch (n)
        {
        case UP:
        case DOWN: 
            if (tmp != LEFT && tmp != RIGHT) 
            {
                n = tmp; //那么下一次蛇的移动方向设置为上一次蛇的移动方向
            }
            break;
        case LEFT:
        case RIGHT: 
            if (tmp != UP && tmp != DOWN) 
            {
                n = tmp; 
            }
        case SPACE:
        case ESC:
        case 'r':
        case 'R':
            break; //这四个无需调整
        default:
            n = tmp; 
            break;
        }
    first:
        switch (n)
        {
        case UP: 
            run(0, -1); 
            tmp = UP;
            break;
        case DOWN: //方向键：下
            run(0, 1); 
            tmp = DOWN; //记录当前蛇的移动方向
            break;
        case LEFT: //方向键：左
            run(-1, 0); 
            tmp = LEFT; //记录当前蛇的移动方向
            break;
        case RIGHT: 
            run(1, 0); 
            tmp = RIGHT; 
            break;
        case SPACE: //暂停
            system("pause>nul"); 
            break;
        case ESC: 
            system("cls");
            color(7); 
            CursorJump(COL - 8, ROW / 2);
            printf("  游戏结束  ");
            CursorJump(COL - 8, ROW / 2 + 2);
            exit(0);
        case 'r':
        case 'R': 
            system("cls"); 
            main();
        }
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

flutter生成二维码并截图保存到图库

flutter生成二维码并截图保存到图库

引入库&#xff1a;flutter_screenutil、image_gallery_saver、qr_flutter弹窗布局 import dart:async; import dart:typed_data; import package/generated/l10n.dart; import package:jade/configs/PathConfig.dart; import package:jade/utils/ImageWaterMarkUtil.dart; im…
阅读更多...
三、强一致性介绍

三、强一致性介绍

这里写自定义目录标题 三、强一致性介绍3.1 基本理解3.2 DTP模型3.3 落地协议XA3.4 ⼆阶段提交模型3.5 ⼆阶段提交的问题3.6 navicat操作xa 三、强一致性介绍 3.1 基本理解 相关特点 强⼀致性解决⽅案要求在任何时间点&#xff0c;任何时刻查询&#xff0c;参与全局事务的各个…
阅读更多...
ROS 2边学边练（7）-- 何为动作（actions）

ROS 2边学边练（7）-- 何为动作（actions）

概念 我们先来看一张动图&#xff0c;下文再围绕这张图对动作作简单阐释和说明。 如上图所示&#xff0c;动作的复杂度比之前提到的几种通信方式&#xff08;主题、服务&#xff09;要大一点&#xff0c;但是几者之间也有着千丝万缕的关系&#xff0c;动作糅合了主题和服务的机…
阅读更多...
【MySQL】DQL-排序查询-语法＆排序方式＆注意事项＆可cv例题语句

【MySQL】DQL-排序查询-语法＆排序方式＆注意事项＆可cv例题语句

前言 大家好吖&#xff0c;欢迎来到 YY 滴MySQL系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C Linux的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; YY的《C》专栏YY的《C11》专栏YY的…
阅读更多...
常用技术-Stream流

常用技术-Stream流

目录 Stream流是什么&#xff1f; 认识Stream流 流和集合的区别 Stream流的操作 中间操作 Filter(过滤) Map(转换) Sorted(排序) Distinct(去重) Limit(限制) Skip(跳过) Peek(展示) 终止操作 forEach(循环) Collect(收集) Count(计数) Reduce(聚合) 使用Strea…
阅读更多...
我爱DFS序列搜索

我爱DFS序列搜索

什么是DFS&#xff1f; DFS算法&#xff0c;即深度优先搜索&#xff08;Depth-First Search&#xff09;算法&#xff0c;是一种用于遍历或搜索图或树的算法。DFS算法可以解决诸如路径查找、图的连通性、拓扑排序以及树结构中的深度遍历等问题。然而&#xff0c;需要注意的是&…
阅读更多...
C++基础12：标准模板库

C++基础12：标准模板库

此专栏为移动机器人知识体系下的编程语言中的 C {\rm C} C从入门到深入的专栏&#xff0c;参考书籍&#xff1a;《深入浅出 C {\rm C} C》(马晓锐)和《从 C {\rm C} C到 C {\rm C} C精通面向对象编程》(曾凡锋等)。 11.标准模板库 11.1 泛型化编程与STL简介 泛型化编程思想是一…
阅读更多...
实践笔记-harbor搭建（版本：2.9.0）

实践笔记-harbor搭建（版本：2.9.0）

harbor搭建 1.下载安装包&#xff08;版本&#xff1a;2.9.0&#xff09;2.修改配置文件3.安装4.访问harbor5.可能用得上的命令: 环境&#xff1a;centos7 1.下载安装包&#xff08;版本&#xff1a;2.9.0&#xff09; 网盘资源&#xff1a;https://pan.baidu.com/s/1fcoJIa4x…
阅读更多...
垃圾回收机制--GC 垃圾收集器--JVM调优-面试题

垃圾回收机制--GC 垃圾收集器--JVM调优-面试题

1.触发垃圾回收的条件 新生代 Eden区域满了&#xff0c;触发young gc (ygc)老年代区域满了&#xff0c;触发full gc (fgc)通过ygc后进入老年代的平均大小大于老年代的可用内存,触发full gc(fgc).程序中主动调用的System.gc()强制执行gc,是full gc&#xff0c;但是不必然执行。…
阅读更多...
KUKA机器人调整示教器灵敏度（校屏）

KUKA机器人调整示教器灵敏度（校屏）

KUKA机器人KRC4的示教器升级后&#xff0c;示教器屏幕由之前的电阻屏改为电容屏&#xff0c;不仅在外观上有所变化&#xff0c;屏幕校准的方法也有所不同。通过以下方法分别对新旧两款示教器进行屏幕校正&#xff0c;调整示教器屏幕灵敏度。 对新款示教器而言&#xff1a; 一…
阅读更多...
热烈祝贺阿里云PolarDB登顶2024最新一期中国数据库流行榜

热烈祝贺阿里云PolarDB登顶2024最新一期中国数据库流行榜

热烈祝贺阿里云PolarDB登顶2024最新一期中国数据库流行榜 墨天轮墨天轮国产数据库流行度排行PolarDB首度夺魁关于话题的讨论数据库流行度排行榜会影响你的数据库选型吗&#xff1f;对于 PolarDB 的本次登顶&#xff0c;你认为关键因素是什么&#xff1f;PolarDB“三层分离”新版…
阅读更多...
LeetCode-331. 验证二叉树的前序序列化【栈 树 字符串 二叉树】

LeetCode-331. 验证二叉树的前序序列化【栈 树 字符串 二叉树】

LeetCode-331. 验证二叉树的前序序列化【栈 树 字符串 二叉树】 题目描述&#xff1a;解题思路一&#xff1a;看提示主要是栈和树。这题其实不是二叉树的遍历题&#xff0c;而是检验二叉树基础知识的题&#xff0c;也许有些难想。第一种解法是&#xff1a;把有效的叶子节点使用…
阅读更多...
【OceanBase实战之路】第3篇：多租户架构实现资源隔离

【OceanBase实战之路】第3篇：多租户架构实现资源隔离

码到三十五 &#xff1a; 个人主页 心中有诗画&#xff0c;指尖舞代码&#xff0c;目光览世界&#xff0c;步履越千山&#xff0c;人间尽值得 ! 目录 一、什么是OceanBase的多租户二、兼容模式2.1 MySQL 模式2.2 Oracle 模式三、租户介绍3.1 系统租户3.2 用户租户3.3 Meta 租…
阅读更多...
强化基础-Java-泛型基础

强化基础-Java-泛型基础

什么是泛型&#xff1f; 泛型其实就参数化类型&#xff0c;也就是说这个类型类似一个变量是可变的。 为什么会有泛型&#xff1f; 在没有泛型之前&#xff0c;java中是通过Object来实现泛型的功能。但是这样做有下面两个缺陷&#xff1a; 1 获取值的时候必须进行强转 2 没有…
阅读更多...
计算机网络-TCP/IP 网络模型

计算机网络-TCP/IP 网络模型

TCP/IP网络模型各层的详细描述&#xff1a; 应用层&#xff1a;应用层为应用程序提供数据传输的服务&#xff0c;负责各种不同应用之间的协议。主要协议包括&#xff1a; HTTP&#xff1a;超文本传输协议&#xff0c;用于从web服务器传输超文本到本地浏览器的传送协议。FTP&…
阅读更多...
Linux 设备树： 设备树节点与属性在 dtb 文件中的存储

Linux 设备树： 设备树节点与属性在 dtb 文件中的存储

前言 当前新版本的 Linux 内核 设备驱动框架&#xff0c;与设备树&#xff08;Device Tree&#xff09;结合密切&#xff0c;整体 设备树的设备驱动框架&#xff0c;比较的庞大&#xff0c;但又非常的经典。 一个个的 设备树解析函数&#xff0c;都是前人【智慧】的结晶&#…
阅读更多...
微服务监控：确保分布式系统的可观察性与稳定性

微服务监控：确保分布式系统的可观察性与稳定性

码到三十五 &#xff1a; 个人主页 心中有诗画&#xff0c;指尖舞代码&#xff0c;目光览世界&#xff0c;步履越千山&#xff0c;人间尽值得 ! 目录 一、前言二、微服务监控的重要性三、关键监控指标四、常用监控工具五、最佳实践六、结论 一、前言 在当前的软件开发领域&a…
阅读更多...
2.快速排序

2.快速排序

快速排序 思想&#xff1a;双指针法&#xff08;左右指针法&#xff09; 时间复杂度&#xff1a;O(n log n)&#xff08;最理想的情况下&#xff09; 最坏的情况&#xff1a;输入的数组已经是有序的或者接近有序时 快速排序的性能会退化到O(n^2) 我们的快速排序其实就是让两…
阅读更多...
Wezterm配置

Wezterm配置

Windows 的图形界面目前来说在有图形界面的系统中&#xff0c;表现最稳定 linux 的终端最方便 和 tui 程序也多 我建议winodws安装 wsl 既可以使用 linux的环境和可以使用windows的桌面 关键 neovide --wsl 的表现很棒 如果项目的历史提交很多而且&#xff0c;工程很大&#xf…
阅读更多...
C++STLmap，set

C++STLmap，set

我最近开了几个专栏&#xff0c;诚信互三&#xff01; > |||《算法专栏》&#xff1a;&#xff1a;刷题教程来自网站《代码随想录》。||| > |||《C专栏》&#xff1a;&#xff1a;记录我学习C的经历&#xff0c;看完你一定会有收获。||| > |||《Linux专栏》&#xff1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023