2024年Go最新c++经典项目控制台贪吃蛇小游戏详细教程_贪吃蛇小游戏c++(1)，2024年最新字节跳动上千道精选面试题还不刷起来

2401_84904969

于 2024-05-11 05:55:47 发布

阅读量779

点赞数 31

分类专栏：程序员文章标签： go 学习面试

本文链接：https://blog.csdn.net/2401_84904969/article/details/138694380

版权

程序员专栏收录该内容

58 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

游戏截图

开始界面
游戏结束
开始动画：

游戏过程：

游戏架构设计

该游戏的玩法简单，玩家通过键盘方向键控制蛇上下左右移动，吃到食物得分并增长，碰到墙或者自己的身体则死亡，游戏结束。
整个游戏其实就是一个无穷的循环，直到退出游戏时退出循环。我们暂且将这个循环称为一级循环，这个循环包含游戏开始动画，游戏难度选择，游戏过程这三个子模块，其中游戏过程这个模块亦是一个循环，我们暂且将其称为二级循环。它们之间的关系大致如下图：
这里写图片描述
现在我们根据上图进行细化，对各个模块的实现进行简单描述。

1.游戏开始动画

开始动画的实现主要依靠对点的操作来实现，这里我们先建立一个概念，就是将控制台界面看成一个原点在左上角的坐标系，一个点（x，y）表示坐标系中的一个格子，如下图所示：
这里写图片描述
我们的开始动画是由一条蛇和一行文字从左到右移动而成，这里我们先单独讨论一下蛇，要达到移动的效果，我采取的策略是将整个过程分为三部分：
第一部分为蛇从左边开始出现到整个身体完全出现
第二部分为蛇身整体从左移动到接触右边界的过程
第三部分为蛇从接触右边界到完全消失的过程
这里写图片描述

我们先来看一下第一部分，这一部分的实现首先是建立一个deque双端队列，用于存储点的对象，这些点就是组成蛇身的元素，然后再用一个for循环将容器中的点依次打印出来，每打印一个点停顿一会，这样就达到了移动的效果。全部打印完后就到了第二部分，这部分蛇的每次前进都是通过计算将要移动到的下一个点的坐标，然后将这个点打印出来，与此同时将蛇尾，亦即queue中的首端点去掉，并擦除屏幕上该点颜色。第三部分就直接依次从蛇尾擦除即可。
同理，文字snake的移动也基本类似，稍微改动即可，因为无需对首尾进行操作，而是要对所以点进行移动，因此容器选用vector。
具体请参看startinterface.h以及startinterface.cpp

2.选择难度

其实这个模块很简单，我就简单介绍一下，先将难度选择的文字信息打印在屏幕上，然后通过控制键盘方向键选择，回车键确认，为了突出选中项，需要给选中项打上背景色，然后每一次上下移动时，先将当前的背景色去掉，然后给下一个选中项打上背景色，按下回车后通过改变蛇移动的速度实现改变难度。其中读取键盘输入是通过getch()函数完成的。
这里写图片描述

3.游戏过程

这个模块就是整个游戏最主要的部分了，首先它先绘制出地图以及侧边栏，同时初始化蛇和食物，然后通过一个无穷循环监听键盘，以此来控制蛇移动，同时又进行各种判断，来判断是否死亡、吃到食物或暂停。需要提一下，这里使用kbhit()函数来监听键盘，它用来判断在一段固定的时间内是否有键盘输入，要知道，这个函数的返回值有两个，第一个是是否有输入的返回值，第二个才是键盘输入的内容，也就是说要经过两次的读取缓冲区才能读到真正的键盘输入。
这里写图片描述

游戏代码实现

从这里开始我们就可以真正动手来实现游戏了，在动手之前，我建议先下载游戏来玩几局，弄清整个游戏的逻辑，这样更能有一个清晰的思路。
接着你可以将以下的代码或者github上的代码按下面几张图的流程添加进工程里，当然如果你使用其他IDE的话就按照它的方式来弄，然后进行编译试一下。

首先新建工程
这里写图片描述

然后将文件一个一个添加进工程里

这里写图片描述

最后所有文件添加完就是这样了

这里写图片描述

记得要把编译器改成c++11标准

这里写图片描述

完成了以上几步后就可以点编译按钮进行编译，同时运行一下，看看效果。然后阅读源码或者修改一下，看看编译后有什么不同。
这里代码.h文件是类的定义，.cpp文件是类的实现。整个程序共有七个类，分别为Tools,Point,StartInterface,Snake,Map,Food。
因为整个游戏需要对于点的大量操作，所以建立Tools和Point两个类，Tools工具类主要是用于设置光标的位置以及输出文字的颜色，Point类设置点的对象，因为其他类都是建立在这两个类的基础上的，所以阅读代码时要先看这两个。然后才开始从main.cpp开始看，一行一行，看到出现新的类就转到该类的声明与定义文件去看，这样阅读起来比较清晰，这里简要说明一下各个类的功能，Controller类就是控制整个游戏过程的，包括游戏的各个阶段，比如更新分数，游戏难度选择等；Food类实现食物的随机出现；Map类负责绘制地图，我由于时间关系（主要是懒）没有加入地图，只有边界，但原理和边界是一模一样的，同样是将点绘制出来，然后每一次都判断蛇是否撞到地图即可；Snake类控制蛇的移动和吃到食物等。
各个类之间的关系大致如下：

这里写图片描述

以下是实现的代码

main.cpp

#include "controller.h"

int main()//程序入口
{
    Controller c;//声明一个Controller类
    c.Game();//整个游戏循环
    return 0;
}

controller.h

#ifndef CONTROLLER\_H
#define CONTROLLER\_H


class Controller
{
public:
    Controller() : speed(200), key(1), score(0) {}
    void Start();
    void Select();
    void DrawGame();
    int PlayGame();
    void UpdateScore(const int&);
    void RewriteScore();
    int Menu();
    void Game();
    int GameOver();
private:
    int speed;
    int key;
    int score;
};
#endif // CONTROLLER\_H

controller.cpp

#include <iostream>
#include <time.h>
#include <conio.h>
#include <windows.h>
#include "controller.h"
#include "tools.h"
#include "startinterface.h"
#include "map.h"
#include "snake.h"
#include "food.h"

void Controller::Start()//开始界面
{
    SetWindowSize(41, 32);//设置窗口大小
    SetColor(2);//设置开始动画颜色
    StartInterface *start = new StartInterface();//动态分配一个StartInterface类start
    start->Action();//开始动画
    delete start;//释放内存空间

    /\*设置关标位置，并输出提示语，等待任意键输入结束\*/
    SetCursorPosition(13, 26);
    std::cout << "Press any key to start... " ;
    SetCursorPosition(13, 27);
    system("pause");
}

void Controller::Select()//选择界面
{
    /\*初始化界面选项\*/
    SetColor(3);
    SetCursorPosition(13, 26);
    std::cout << " " ;
    SetCursorPosition(13, 27);
    std::cout << " " ;
    SetCursorPosition(6, 21);
    std::cout << "请选择游戏难度：" ;
    SetCursorPosition(6, 22);
    std::cout << "(上下键选择,回车确认)" ;
    SetCursorPosition(27, 22);
    SetBackColor();//第一个选项设置背景色以表示当前选中
    std::cout << "简单模式" ;
    SetCursorPosition(27, 24);
    SetColor(3);
    std::cout << "普通模式" ;
    SetCursorPosition(27, 26);
    std::cout << "困难模式" ;
    SetCursorPosition(27, 28);
    std::cout << "炼狱模式" ;
    SetCursorPosition(0, 31);
    score = 0;

    /\*上下方向键选择模块\*/
    int ch;//记录键入值
    key = 1;//记录选中项，初始选择第一个
    bool flag = false;//记录是否键入Enter键标记，初始置为否
    while ((ch = getch()))
    {
        switch (ch)//检测输入键
        {
        case 72://UP上方向键
            if (key > 1)//当此时选中项为第一项时，UP上方向键无效
            {
                switch (key)
                {
                case 2:
                    SetCursorPosition(27, 22);//给待选中项设置背景色
                    SetBackColor();
                    std::cout << "简单模式" ;

                    SetCursorPosition(27, 24);//将已选中项取消我背景色
                    SetColor(3);
                    std::cout << "普通模式" ;

                    --key;
                    break;
                case 3:
                    SetCursorPosition(27, 24);
                    SetBackColor();
                    std::cout << "普通模式" ;

                    SetCursorPosition(27, 26);
                    SetColor(3);
                    std::cout << "困难模式" ;

                    --key;
                    break;
                case 4:
                    SetCursorPosition(27, 26);
                    SetBackColor();
                    std::cout << "困难模式" ;

                    SetCursorPosition(27, 28);
                    SetColor(3);
                    std::cout << "炼狱模式" ;

                    --key;
                    break;
                }
            }
            break;

        case 80://DOWN下方向键
            if (key < 4)
            {
                switch (key)
                {
                case 1:
                    SetCursorPosition(27, 24);
                    SetBackColor();
                    std::cout << "普通模式" ;
                    SetCursorPosition(27, 22);
                    SetColor(3);
                    std::cout << "简单模式" ;

                    ++key;
                    break;
                case 2:
                    SetCursorPosition(27, 26);
                    SetBackColor();
                    std::cout << "困难模式" ;
                    SetCursorPosition(27, 24);
                    SetColor(3);
                    std::cout << "普通模式" ;

                    ++key;
                    break;
                case 3:
                    SetCursorPosition(27, 28);
                    SetBackColor();
                    std::cout << "炼狱模式" ;
                    SetCursorPosition(27, 26);
                    SetColor(3);
                    std::cout << "困难模式" ;

                    ++key;
                    break;
                }
            }
            break;

        case 13://Enter回车键
            flag = true;
            break;
        default://无效按键
            break;
        }
        if (flag) break;//输入Enter回车键确认，退出检查输入循环

        SetCursorPosition(0, 31);//将光标置于左下角，避免关标闪烁影响游戏体验
    }

    switch (key)//根据所选选项设置蛇的移动速度，speed值越小，速度越快
    {
    case 1:
        speed = 135;
        break;
    case 2:
        speed = 100;
        break;
    case 3:
        speed = 60;
        break;
    case 4:
        speed = 30;
        break;
    default:
        break;
    }
}

void Controller::DrawGame()//绘制游戏界面
{
    system("cls");//清屏

    /\*绘制地图\*/
    SetColor(3);
    Map *init_map = new Map();
    init_map->PrintInitmap();
    delete init_map;

    /\*绘制侧边栏\*/
    SetColor(3);
    SetCursorPosition(33, 1);
    std::cout << "Greedy Snake" ;
    SetCursorPosition(34, 2);
    std::cout << "贪吃蛇" ;
    SetCursorPosition(31, 4);
    std::cout << "难度：" ;
    SetCursorPosition(36, 5);
    switch (key)
    {
    case 1:
        std::cout << "简单模式" ;
        break;
    case 2:
        std::cout << "普通模式" ;
        break;
    case 3:
        std::cout << "困难模式" ;
        break;
    case 4:
        std::cout << "炼狱模式" ;
        break;
    default:
        break;
    }
    SetCursorPosition(31, 7);
    std::cout << "得分：" ;
    SetCursorPosition(37, 8);
    std::cout << " 0" ;
    SetCursorPosition(33, 13);
    std::cout << " 方向键移动" ;
    SetCursorPosition(33, 15);
    std::cout << " ESC键暂停" ;
}

int Controller::PlayGame()//游戏二级循环
{
    /\*初始化蛇和食物\*/
    Snake *csnake = new Snake();
    Food *cfood = new Food();
    SetColor(6);
    csnake->InitSnake();
    srand((unsigned)time(NULL));//设置随机数种子，如果没有 食物的出现位置将会固定
    cfood->DrawFood(*csnake);

    /\*游戏循环\*/
    while (csnake->OverEdge() && csnake->HitItself()) //判断是否撞墙或撞到自身，即是否还有生命
    {
        /\*调出选择菜单\*/
        if (!csnake->ChangeDirection()) //按Esc键时
        {
            int tmp = Menu();//绘制菜单，并得到返回值
            switch (tmp)
            {
            case 1://继续游戏
                break;

            case 2://重新开始
                delete csnake;
                delete cfood;
                return 1;//将1作为PlayGame函数的返回值返回到Game函数中，表示重新开始

            case 3://退出游戏
                delete csnake;
                delete cfood;
                return 2;//将2作为PlayGame函数的返回值返回到Game函数中，表示退出游戏

            default:
                break;
            }
        }

        if (csnake->GetFood(*cfood)) //吃到食物
        {
            csnake->Move();//蛇增长
            UpdateScore(1);//更新分数，1为分数权重
            RewriteScore();//重新绘制分数
            cfood->DrawFood(*csnake);//绘制新食物
        }
        else
        {
            csnake->NormalMove();//蛇正常移动
        }

        if (csnake->GetBigFood(*cfood)) //吃到限时食物
        {
            csnake->Move();
            UpdateScore(cfood->GetProgressBar()/5);//分数根据限时食物进度条确定
            RewriteScore();
        }

        if (cfood->GetBigFlag()) //如果此时有限时食物，闪烁它
        {
            cfood->FlashBigFood();
        }

        Sleep(speed);//制造蛇的移动效果
    }

    /\*蛇死亡\*/
    delete csnake;//释放分配的内存空间
    delete cfood;
    int tmp = GameOver();//绘制游戏结束界面，并返回所选项
    switch (tmp)
    {
    case 1:
        return 1;//重新开始
    case 2:
        return 2;//退出游戏
    default:
        return 2;
    }
}

void Controller::UpdateScore(const int& tmp)//更新分数
{
    score += key * 10 * tmp;//所得分数根据游戏难度及传人的参数tmp确定
}

void Controller::RewriteScore()//重绘分数
{
    /\*为保持分数尾部对齐，将最大分数设置为6位，计算当前分数位数，将剩余位数用空格补全，再输出分数\*/
    SetCursorPosition(37, 8);
    SetColor(11);
    int bit = 0;
    int tmp = score;
    while (tmp != 0)
    {
        ++bit;
        tmp /= 10;
    }
    for (int i = 0; i < (6 - bit); ++i)
    {
        std::cout << " " ;
    }
    std::cout << score ;
}

int Controller::Menu()//选择菜单
{
    /\*绘制菜单\*/
    SetColor(11);
    SetCursorPosition(32, 19);
    std::cout << "菜单：" ;
    Sleep(100);
    SetCursorPosition(34, 21);
    SetBackColor();
    std::cout << "继续游戏" ;
    Sleep(100);
    SetCursorPosition(34, 23);
    SetColor(11);
    std::cout << "重新开始" ;
    Sleep(100);
    SetCursorPosition(34, 25);
    std::cout << "退出游戏" ;
    SetCursorPosition(0, 31);

    /\*选择部分\*/
    int ch;
    int tmp_key = 1;
    bool flag = false;
    while ((ch = getch()))
    {
        switch (ch)
        {
        case 72://UP
            if (tmp_key > 1)
            {
                switch (tmp_key)
                {
                case 2:
                    SetCursorPosition(34, 21);
                    SetBackColor();
                    std::cout << "继续游戏" ;
                    SetCursorPosition(34, 23);
                    SetColor(11);
                    std::cout << "重新开始" ;

                    --tmp_key;
                    break;
                case 3:
                    SetCursorPosition(34, 23);
                    SetBackColor();
                    std::cout << "重新开始" ;
                    SetCursorPosition(34, 25);
                    SetColor(11);
                    std::cout << "退出游戏" ;

                    --tmp_key;
                    break;
                }
            }
            break;

        case 80://DOWN
            if (tmp_key < 3)
            {
                switch (tmp_key)
                {
                case 1:
                    SetCursorPosition(34, 23);
                    SetBackColor();
                    std::cout << "重新开始" ;
                    SetCursorPosition(34, 21);
                    SetColor(11);
                    std::cout << "继续游戏" ;

                    ++tmp_key;
                    break;
                case 2:
                    SetCursorPosition(34, 25);
                    SetBackColor();
                    std::cout << "退出游戏" ;
                    SetCursorPosition(34, 23);
                    SetColor(11);
                    std::cout << "重新开始" ;

                    ++tmp_key;
                    break;
                }
            }
            break;

        case 13://Enter
            flag = true;
            break;

        default:
            break;
        }

        if (flag)
        {
            break;
        }
        SetCursorPosition(0, 31);
    }

    if (tmp_key == 1) //选择继续游戏，则将菜单擦除
    {
        SetCursorPosition(32, 19);
        std::cout << " " ;
        SetCursorPosition(34, 21);
        std::cout << " ";
        SetCursorPosition(34, 23);
        std::cout << " ";
        SetCursorPosition(34, 25);
        std::cout << " ";
    }
    return tmp_key;
}

void Controller::Game()//游戏一级循环
{
    Start();//开始界面
    while (true)//游戏可视为一个死循环，直到退出游戏时循环结束
    {
        Select();//选择界面
        DrawGame();//绘制游戏界面
        int tmp = PlayGame();//开启游戏循环，当重新开始或退出游戏时，结束循环并返回值给tmp
        if (tmp == 1) //返回值为1时重新开始游戏
        {
            system("cls");
            continue;
        }
        else if (tmp == 2) //返回值为2时退出游戏
        {
            break;
        }
        else
        {
            break;
        }
    }
}

int Controller::GameOver()//游戏结束界面
{
    /\*绘制游戏结束界面\*/
    Sleep(500);
    SetColor(11);
    SetCursorPosition(10, 8);
    std::cout << "━━━━━━━━━━━━━━━━━━━━━━" ;
    Sleep(30);
    SetCursorPosition(9, 9);
    std::cout << " ┃ Game Over !!! ┃" ;
    Sleep(30);
    SetCursorPosition(9, 10);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 11);
    std::cout << " ┃ 很遗憾！你挂了 ┃" ;
    Sleep(30);
    SetCursorPosition(9, 12);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 13);
    std::cout << " ┃ 你的分数为： ┃" ;
    SetCursorPosition(24, 13);
    std::cout << score ;
    Sleep(30);
    SetCursorPosition(9, 14);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 15);
    std::cout << " ┃ 是否再来一局？ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 16);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 17);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 18);
    std::cout << " ┃ 嗯，好的 不了，还是学习有意思 ┃" ;
    Sleep(30);
    SetCursorPosition(9, 19);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(9, 20);
    std::cout << " ┃ ┃" ;
    Sleep(30);
    SetCursorPosition(10, 21);
    std::cout << "━━━━━━━━━━━━━━━━━━━━━━" ;

    Sleep(100);
    SetCursorPosition(12, 18);
    SetBackColor();
    std::cout << "嗯，好的" ;
    SetCursorPosition(0, 31);

    /\*选择部分\*/
    int ch;
    int tmp_key = 1;
    bool flag = false;
    while ((ch = getch()))
    {
        switch (ch)
        {
        case 75://LEFT
            if (tmp_key > 1)
            {
                SetCursorPosition(12, 18);
                SetBackColor();
                std::cout << "嗯，好的" ;
                SetCursorPosition(20, 18);
                SetColor(11);
                std::cout << "不了，还是学习有意思" ;
                --tmp_key;
            }
            break;

        case 77://RIGHT
            if (tmp_key < 2)
            {
                SetCursorPosition(20, 18);
                SetBackColor();
                std::cout << "不了，还是学习有意思" ;
                SetCursorPosition(12, 18);
                SetColor(11);
                std::cout << "嗯，好的" ;
                ++tmp_key;
            }
            break;

        case 13://Enter
            flag = true;
            break;

        default:
            break;
        }

        SetCursorPosition(0, 31);
        if (flag) {
            break;
        }
    }

    SetColor(11);
    switch (tmp_key)
    {
    case 1:
        return 1;//重新开始
    case 2:
        return 2;//退出游戏
    default:
        return 1;
    }
}

food.h

#ifndef FOOD\_H
#define FOOD\_H

#include "snake.h"
class Snake;
class Food
{
public:
    Food() : cnt(0), flash\_flag(false), big\_flag(false), x(0), y(0), big\_x(0), big\_y(0), progress\_bar(0) {}
    void DrawFood(Snake&);
    void DrawBigFood(Snake&);
    int GetCnt();
    void FlashBigFood();
    bool GetBigFlag();
    int GetProgressBar();
private:
    int cnt;
    bool flash_flag;//闪烁标记
    bool big_flag;//是否有限时食物标记
    int x, y;
    int big_x, big_y;
    int progress_bar;//限时食物进度条
    friend class Snake;
};
#endif // FOOD\_H

food.cpp

#include "food.h"
#include "tools.h"
#include <cstdlib>
#include <iostream>


void Food::DrawFood(Snake& csnake)//绘制食物
{
    /\*利用rand函数获得坐标，并将其范围限制在2-29内，即在地图内，如果获得的坐标与蛇身重叠，则重新获取。
 同时每5颗食物就出现一颗限时食物\*/
    while (true)
    {
        int tmp_x = rand() % 30;
        int tmp_y = rand() % 30;
        if(tmp_x < 2) tmp_x += 2;
        if(tmp_y < 2) tmp_y += 2;
        bool flag = false;
        for (auto& point : csnake.snake)
        {
            if ((point.GetX() == tmp_x && point.GetY() == tmp_y) || (tmp_x == big_x && tmp_y == big_y)) {
                flag = true;
                break;
            }
        }
        if (flag)
            continue;
        x = tmp_x;
        y = tmp_y;
        SetCursorPosition(x, y);
        SetColor(13);
        std::cout << "★" ;
        ++cnt;
        cnt %= 5;
        if (cnt == 0)
        {
            DrawBigFood(csnake);
        }
        break;
    }
}

void Food::DrawBigFood(Snake& csnake)//绘制限时食物
{
    SetCursorPosition(5, 0);
    SetColor(11);
    std::cout << "------------------------------------------" ;//进度条
    progress_bar = 42;
    while (true)
    {
        int tmp_x = rand() % 30;
        int tmp_y = rand() % 30;
        if(tmp_x < 2) tmp_x += 2;
        if(tmp_y < 2) tmp_y += 2;
        bool flag = false;
        for (auto& point : csnake.snake)
        {
            if ((point.GetX() == tmp_x && point.GetY() == tmp_y) || (tmp_x == x && tmp_y == y))
            {
                flag = true;
                break;
            }
        }
        if (flag)
            continue;

        big_x = tmp_x;
        big_y = tmp_y;
        SetCursorPosition(big_x, big_y);
        SetColor(18);
        std::cout << "■" ;
        big_flag = true;
        flash_flag = true;
        break;
    }
}

int Food::GetCnt()
{
    return cnt;
}

void Food::FlashBigFood()//闪烁限时食物
{
    SetCursorPosition(big_x, big_y);
    SetColor(18);
    if (flash_flag)
    {
        std::cout << " " ;
        flash_flag = false;
    }
    else
    {
        std::cout << "■" ;
        flash_flag = true;
    }

    SetCursorPosition(26, 0);
    SetColor(11);
    for (int i = 42; i >= progress_bar; --i)//进度条缩短
        std::cout << "\b \b" ;
    --progress_bar;
    if (progress_bar == 0) {
        SetCursorPosition(big_x, big_y);
        std::cout << " " ;
        big_flag = false;
        big_x = 0;
        big_y = 0;
    }
}

bool Food::GetBigFlag()
{
    return big_flag;
}

int Food::GetProgressBar()
{
    return progress_bar;
}

map.h

#ifndef MAP\_H
#define MAP\_H

#include <vector>
#include "point.h"

class Map
{
public:
 Map()//默认构造函数，将正方形各点压入initmap
 {
 initmap.emplace\_back(Point(1, 1));
 initmap.emplace\_back(Point(2, 1));
 initmap.emplace\_back(Point(3, 1));
 initmap.emplace\_back(Point(4, 1));
 initmap.emplace\_back(Point(5, 1));
 initmap.emplace\_back(Point(6, 1));
 initmap.emplace\_back(Point(7, 1));
 initmap.emplace\_back(Point(8, 1));
 initmap.emplace\_back(Point(9, 1));
 initmap.emplace\_back(Point(10, 1));
 initmap.emplace\_back(Point(11, 1));
 initmap.emplace\_back(Point(12, 1));
 initmap.emplace\_back(Point(13, 1));
 initmap.emplace\_back(Point(14, 1));
 initmap.emplace\_back(Point(15, 1));
 initmap.emplace\_back(Point(16, 1));
 initmap.emplace\_back(Point(17, 1));
 initmap.emplace\_back(Point(18, 1));
 initmap.emplace\_back(Point(19, 1));
 initmap.emplace\_back(Point(20, 1));
 initmap.emplace\_back(Point(21, 1));
 initmap.emplace\_back(Point(22, 1));
 initmap.emplace\_back(Point(23, 1));
 initmap.emplace\_back(Point(24, 1));


![img](https://img-blog.csdnimg.cn/img_convert/48d98987c9a05fb50fd0c86603caa7be.png)
![img](https://img-blog.csdnimg.cn/img_convert/02128116221469c46d02a2d6087b2ef0.png)
![img](https://img-blog.csdnimg.cn/img_convert/aa4885fedee1d9ba3ea620e3bb332e2b.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618658159)**

(Point(9, 1));
 initmap.emplace\_back(Point(10, 1));
 initmap.emplace\_back(Point(11, 1));
 initmap.emplace\_back(Point(12, 1));
 initmap.emplace\_back(Point(13, 1));
 initmap.emplace\_back(Point(14, 1));
 initmap.emplace\_back(Point(15, 1));
 initmap.emplace\_back(Point(16, 1));
 initmap.emplace\_back(Point(17, 1));
 initmap.emplace\_back(Point(18, 1));
 initmap.emplace\_back(Point(19, 1));
 initmap.emplace\_back(Point(20, 1));
 initmap.emplace\_back(Point(21, 1));
 initmap.emplace\_back(Point(22, 1));
 initmap.emplace\_back(Point(23, 1));
 initmap.emplace\_back(Point(24, 1));


[外链图片转存中...(img-8C6jSPJY-1715378124139)]
[外链图片转存中...(img-M5Tupb3P-1715378124139)]
[外链图片转存中...(img-YRtdjZfm-1715378124140)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618658159)**

2401_84904969

关注

31
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
2024年Go最新c++经典项目控制台贪吃蛇小游戏详细教程_贪吃蛇小游戏c++(1)，2024年最新字节跳动上千道精选面试题还不刷起来

需要提一下，这里使用kbhit()函数来监听键盘，它用来判断在一段固定的时间内是否有键盘输入，要知道，这个函数的返回值有两个，第一个是是否有输入的返回值，第二个才是键盘输入的内容，也就是说要经过两次的读取缓冲区才能读到真正的键盘输入。其实这个模块很简单，我就简单介绍一下，先将难度选择的文字信息打印在屏幕上，然后通过控制键盘方向键选择，回车键确认，为了突出选中项，需要给选中项打上背景色，然后每一次上下移动时，先将当前的背景色去掉，然后给下一个选中项打上背景色，按下回车后通过改变蛇移动的速度实现改变难度。
复制链接

扫一扫