C++贪吃蛇，源码，编译命令，环境都附上了

最新推荐文章于 2021-12-26 17:26:33 发布
最新推荐文章于 2021-12-26 17:26:33 发布
阅读量256 收藏
点赞数
分类专栏： 游戏 文章标签： windows c++ 游戏 程序设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53065050/article/details/115386524
版权

文章目录

前言

每年学校都要求娃参加各种科技比赛，这哪里是娃参加啊，明明就是难为老爹嘛，娃才3年级，能做什么科技作品？我要是不搞点东西应付一下的话，娃他妈那关过不了，算了，花点时间写个C++的贪吃蛇吧。整体写的比较简陋，娃他妈催的很急，很多想法没来得及写，代码也没好好的整，凑合看吧。

网上也有不少C语言写的贪吃蛇的源码，代码都很精炼，我也看过，觉得写的很好，奈何做C++好多年，写代码不封装几个类出来浑身难受。代码比较简单，egg就是贪吃蛇里面那个蛋，map就是地图，player就是指蛇，director就是字面意思，控制整体流程。从我自己的角度来看，分类之后分工明确了，什么代码该写在什么类里面一目了然。

一、目录结构

第一层目录：

include目录：

二、直接上代码

egg.h

#ifndef __CPPS_EGG_H__
#define __CPPS_EGG_H__

class CPPSEgg
{
public:
    CPPSEgg();
    ~CPPSEgg()=default;

    void display(int offset);
    char getStyle() const { return mStyle; };

private:
    int mX;
    int mY;
    char mStyle;
};

#endif

map.h

#ifndef __CPPS_MAP_H__
#define __CPPS_MAP_H__

#define DEFAULT_MAP_WALL_X_THICKNESS 1
#define DEFAULT_MAP_WALL_Y_THICKNESS 1

class CPPSMap
{
public:
    CPPSMap();
    CPPSMap(int width, int height);
    ~CPPSMap()=default;

public:
    int getWidth() const { return mMapWidth; };
    int getHeight() const { return mMapHeight; };

    int setWidth(int width) { mMapWidth = width; };
    int setheight(int height) { mMapHeight = height; };

    char getStyleLandscape() const { return mStyleLandscape; };
    char getStylePortrait() const { return mStylePortrait; };
    char getStyleFill() const { return mStyleFill; };

private:
    int mMapWidth;
    int mMapHeight;
    char mStyleLandscape; //width
    char mStylePortrait;
    char mStyleFill;
};

#endif

player.h

#ifndef __CPPS_PLAYER_H__
#define __CPPS_PLAYER_H__

#include <vector>

using namespace std;

struct CPPSPlayerCoordinate
{
public:
    CPPSPlayerCoordinate(int _x, int _y) {
        x = _x;
        y = _y;
    };
    int x;
    int y;
};

class CPPSPlayer
{
public:
    CPPSPlayer();
    ~CPPSPlayer() {};

    enum PLAYER_MOVE_DIRECTION {
        PLAYER_MOVE_DIRECTION_UP = 5,
        PLAYER_MOVE_DIRECTION_DOWN = -5,
        PLAYER_MOVE_DIRECTION_LEFT = 10,
        PLAYER_MOVE_DIRECTION_RIGHT = -10,
        PLAYER_MOVE_DIRECTION_INVALID = -1,
    };

    enum PLAYER_EAT_STATE {
        PLAYER_EAT_STATE_PROGRESS = 1,
        PLAYER_EAT_STATE_FINISHED,
    };

    void eat();
    int getPlayerLength() const { return mvecCoordinate.size(); };
    vector<CPPSPlayerCoordinate> getCoordinate() const { return mvecCoordinate; };
    bool setMoveDirection(PLAYER_MOVE_DIRECTION direction);
    PLAYER_MOVE_DIRECTION getMoveDirection() const { return mMoveDirection; };
    char getStyleHead() const { return mStyleHead; };
    char getStyleBody() const { return mStyleBody; };


private:
    char mStyleHead;
    char mStyleBody;
    PLAYER_MOVE_DIRECTION mMoveDirection;
    // index 0 means head
    vector<CPPSPlayerCoordinate> mvecCoordinate;
    PLAYER_EAT_STATE mEatState;

    void initCoordinate();
    void updateCoordinate();
    void eatInternal();
};

#endif

director.h

#ifndef __CPPS_DIRECTOR_H__
#define __CPPS_DIRECTOR_H__

#include "egg.h"
#include "map.h"
#include "player.h"

#include <vector>
#include <map>
#include <string>
#include <pthread.h>

class CPPSDirector
{
public:
    CPPSDirector();
    ~CPPSDirector();

    void start();
    void refresh();

    enum CPPSSTATE {
        CPPSSTATE_WAIT_START = 1,
        CPPSSTATE_RUNNING,
        CPPSSTATE_STOP,
        CPPSSTATE_COLLISION_WALL        
    };

private:
    //map
    map<int, map<int, string>> mmapRealMapData;
    CPPSMap* mMap;

    //player
    CPPSPlayer* mPlayer;

    //egg
    CPPSEgg* mEgg;
    int mEggX;
    int mEggY;

    // game
    // game-display
    string mstrFormat;
    bool mNeedToCleanScreen;
    pthread_t mthUI;
    CPPSPlayer::PLAYER_MOVE_DIRECTION mPlyaerMoveDirection;
    bool mExitThreadUI;
    CPPSSTATE mGameState;


private:
    // map
    void initMapInternal();
    // player
    void initPlayerInternal();
    // egg
    void initEggInternal();
    void resetEggCoordinateInternal();

    // game
    // return true is Collision
    bool mathCollisionPlayerAndWallInternal();
    // return true is Collision
    bool mathCollisionPlayerAndEggInternal();

    void formatInternal();
    void updateAllCoordinateDataInternal();
    void resetCoordinateInternal(short x, short y);
    void cleanScreenInternal();
    void initUIThreadInternal();
    void refreshInternal();
    void setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION direction);
    CPPSPlayer::PLAYER_MOVE_DIRECTION getPlyaerMoveDirection() const;
};

#endif

egg.cpp

#include "include/egg.h"

CPPSEgg::CPPSEgg()
{
    mX = 0;
    mY = 0;
    mStyle = 'X';
}

map.cpp

#include "include/map.h"

CPPSMap::CPPSMap()
{
    mMapWidth = 50;
    mMapHeight = 10;

    mStyleLandscape = '-';
    mStylePortrait = '|';
    mStyleFill = ' ';
}

CPPSMap::CPPSMap(int width, int height)
{
    mMapWidth = width;
    mMapHeight = height;

    mStyleLandscape = '-';
    mStylePortrait = '|';
    mStyleFill = ' ';
}

player.cpp

#include "include/player.h"

CPPSPlayer::CPPSPlayer()
{
    mMoveDirection = PLAYER_MOVE_DIRECTION_RIGHT;
    mEatState = PLAYER_EAT_STATE_FINISHED;
    mStyleHead = 'O';
    mStyleBody = 'o';
    initCoordinate();
}

void CPPSPlayer::initCoordinate()
{
    mvecCoordinate.clear();
    mvecCoordinate.push_back(CPPSPlayerCoordinate(2, 0));
    mvecCoordinate.push_back(CPPSPlayerCoordinate(1, 0));
    mvecCoordinate.push_back(CPPSPlayerCoordinate(0, 0));
}

bool CPPSPlayer::setMoveDirection(PLAYER_MOVE_DIRECTION direction)
{
    if (direction != PLAYER_MOVE_DIRECTION_INVALID &&
        (mMoveDirection + direction != 0)) {
        mMoveDirection = direction;
    }
    updateCoordinate();
    return true;
}

void CPPSPlayer::updateCoordinate()
{
    auto maxSize = mvecCoordinate.size();
    if (mEatState == PLAYER_EAT_STATE_PROGRESS) {
        mvecCoordinate.push_back(mvecCoordinate[mvecCoordinate.size() - 1]);
        mEatState = PLAYER_EAT_STATE_FINISHED;
    }

    for (auto i = maxSize - 1; i > 0; --i) {
        mvecCoordinate[i].x = mvecCoordinate[i - 1].x;
        mvecCoordinate[i].y = mvecCoordinate[i - 1].y;
    }

    switch (mMoveDirection) {
        case PLAYER_MOVE_DIRECTION_UP:
            mvecCoordinate[0].y -= 1;
            break;
        case PLAYER_MOVE_DIRECTION_DOWN:
            mvecCoordinate[0].y += 1;
            break;
        case PLAYER_MOVE_DIRECTION_LEFT:
            mvecCoordinate[0].x -= 1;
            break;
        case PLAYER_MOVE_DIRECTION_RIGHT:
            mvecCoordinate[0].x += 1;
            break;                                                                                           
    }
}

void CPPSPlayer::eat()
{
    eatInternal();
}

void CPPSPlayer::eatInternal()
{
    mEatState = PLAYER_EAT_STATE_PROGRESS;
}

director.cpp

#include "include/director.h"
#include "include/player.h"

#include <Windows.h>
#include <conio.h>
#include <ctime>
#include <cstdlib>
#include <iostream>

void* refreshThreadFun(void* arg)
{
    CPPSDirector* driector = (CPPSDirector*)arg;
    driector->refresh();
    return NULL;
}

CPPSDirector::CPPSDirector()
{
#define DEFAULT_MAP_WIDTH   50
#define DEFAULT_MAP_HEIGHT  10
// 0 means free
#define DEFAULT_MAP_DATA_VALUE  0

    initMapInternal();
    initPlayerInternal();
    initEggInternal();
    
    mGameState = CPPSSTATE_WAIT_START;
    mPlyaerMoveDirection = mPlayer->getMoveDirection();
    mNeedToCleanScreen = true;

    updateAllCoordinateDataInternal();

    srand(unsigned(time(NULL)));

    // last init ui thread 
    mExitThreadUI = false;
    initUIThreadInternal();
}

void CPPSDirector::initMapInternal()
{
    mMap = new CPPSMap(DEFAULT_MAP_WIDTH, DEFAULT_MAP_HEIGHT);
}

void CPPSDirector::initPlayerInternal()
{
    mPlayer = new CPPSPlayer();
}

void CPPSDirector::initEggInternal()
{
#define DEFAULT_EGG_COORDINATE_X    5
#define DEFAULT_EGG_COORDINATE_Y    5
    mEgg = new CPPSEgg();
    mEggX = DEFAULT_EGG_COORDINATE_X + DEFAULT_MAP_WALL_X_THICKNESS;
    mEggY = DEFAULT_EGG_COORDINATE_Y + DEFAULT_MAP_WALL_Y_THICKNESS;
}

void CPPSDirector::resetEggCoordinateInternal()
{
    while (1) {
        mEggX = 1 + (mMap->getWidth() - 1) * rand() / RAND_MAX;
        mEggY = 1 + (mMap->getHeight() - 1) * rand() / RAND_MAX;
        if ((mmapRealMapData[mEggY])[mEggX] == " ") {
            //cout << mEggX << "+" << mEggY << endl;
            break;
        }
    }
}

void CPPSDirector::initUIThreadInternal()
{
    int ret = pthread_create(&mthUI, NULL, refreshThreadFun, this);
    if (ret != 0) {
        cout << "[error]pthread_create failed, errno="<< ret << endl;
    }
}

void CPPSDirector::start()
{
    // wait for start
    while (1) {
        if (mGameState == CPPSSTATE_WAIT_START) {
            Sleep(1000);
            continue;
        } else {
            break;
        }
    }

    // wait for input
    char input;
    while (1) {
        if (mGameState == CPPSSTATE_STOP ||
            mGameState == CPPSSTATE_COLLISION_WALL) {
            break;
        }
        input = getch();
        if ((int)input == -32) {
            input = getch();
        }
        switch (int(input)) {
            case 72://up
                setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION_UP);
                break;
            case 80://down
                setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION_DOWN);
                break;
            case 75://left
                setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION_LEFT);
                break;
            case 77://right
                setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION_RIGHT);
                break;
            case int('q'):
                mGameState = CPPSSTATE_STOP;
                mExitThreadUI = true;
                goto END;
                break;
            default :
                setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION_INVALID);
                break;
        };
    }
    END:;
}

void CPPSDirector::updateAllCoordinateDataInternal()
{
    // update map Coordinate
    for (auto i = 0; i < DEFAULT_MAP_HEIGHT; ++i) {
        map<int, string> mapData;
        for (auto j = 0; j < DEFAULT_MAP_WIDTH; ++j) {
            if ((i == 0) || (i == DEFAULT_MAP_HEIGHT - 1)) {
                if (j == 0) {
                    mapData[j] = mMap->getStylePortrait();
                    continue;
                } else if (j > 0 && j < DEFAULT_MAP_WIDTH - 1) {
                    mapData[j] = mMap->getStyleLandscape();
                    continue;
                } else if (j == DEFAULT_MAP_WIDTH - 1) {
                    mapData[j] = mMap->getStylePortrait();
                    continue;
                } else {
                    mapData[j] = mMap->getStyleFill();
                    continue;
                }
            } else if (i > 0 && i < DEFAULT_MAP_HEIGHT - 1) {
                if (j == 0) {
                    mapData[j] = mMap->getStylePortrait();
                    continue;
                } else if (j == DEFAULT_MAP_WIDTH - 1) {
                    mapData[j] = mMap->getStylePortrait();
                    continue;
                } else {
                    mapData[j] = mMap->getStyleFill();
                    continue;
                }
            } else {
                mapData[j] = mMap->getStyleFill();
            }
        }
        mmapRealMapData[i] = mapData;
    }

    // update egg Coordinate
    (mmapRealMapData[mEggY])[mEggX] = mEgg->getStyle();

    // update player Coordinate
    for (auto i = 0; i < mPlayer->getPlayerLength(); ++i) {
        if (i == 0) {
            (mmapRealMapData[mPlayer->getCoordinate()[i].y +
                1])[mPlayer->getCoordinate()[i].x + 1] = mPlayer->getStyleHead();//"^";//"T";//"鈽?;
        } else {
            (mmapRealMapData[mPlayer->getCoordinate()[i].y +
                1])[mPlayer->getCoordinate()[i].x + 1] = mPlayer->getStyleBody();
        }
    }
}

CPPSDirector::~CPPSDirector()
{
    pthread_join(mthUI, NULL);
    if (!mMap) {
        delete mMap;
        mMap = NULL;
    }
    if (!mPlayer) {
        delete mPlayer;
        mPlayer = NULL;
    }
    if (!mEgg) {
        delete mEgg;
        mEgg = NULL;
    }
}

void CPPSDirector::formatInternal()
{
    mstrFormat = "";
    auto height = mMap->getHeight();
    auto width  = mMap->getWidth();

    for (auto i = 0; i < mmapRealMapData.size();  ++i) {
        for (auto j = 0; j < (mmapRealMapData[i]).size(); ++j) {
            mstrFormat.append((mmapRealMapData[i])[j]);
        }
        mstrFormat.append("\n");
    }
}

void CPPSDirector::resetCoordinateInternal(short x, short y) {
    COORD pos;
    pos.X = x;
    pos.Y = y;
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hOut, pos);
    cout << std::flush;
}

void CPPSDirector::cleanScreenInternal()
{
    if (mNeedToCleanScreen) {
        system("cls");
        mNeedToCleanScreen = false;
    }
}

void CPPSDirector::refreshInternal()
{
// control move speed
#define DEFAULT_REFRESH_RATE 200
    unsigned long time_start, time_end, time_sleep;
    mGameState = CPPSSTATE_RUNNING;
    cleanScreenInternal();
    while (1) {
        if (mExitThreadUI) {
            break;
        }
        time_start = GetTickCount();
        updateAllCoordinateDataInternal();
        formatInternal();
        resetCoordinateInternal(0, 2);
        cout << mstrFormat << std::flush;

        if (mathCollisionPlayerAndWallInternal()) {
            mGameState = CPPSSTATE_COLLISION_WALL;
            cout << "game over" << endl;
            cout << "game over" << endl;
            cout << "game over" << endl;
            cout << std::flush;
            break;
        }
        if (mathCollisionPlayerAndEggInternal()) {
            mPlayer->eat();
            resetEggCoordinateInternal();
        }

        time_end = GetTickCount();
        time_sleep = (time_end - time_start) > DEFAULT_REFRESH_RATE ?
            0 : DEFAULT_REFRESH_RATE - (time_end - time_start);

        Sleep(time_sleep);
        mPlayer->setMoveDirection(getPlyaerMoveDirection());
        if (mExitThreadUI) {
            break;
        }
    }
}

void CPPSDirector::refresh()
{
    refreshInternal();
}

void CPPSDirector::setPlyaerMoveDirection(CPPSPlayer::PLAYER_MOVE_DIRECTION direction)
{
    mPlyaerMoveDirection = direction;
}

CPPSPlayer::PLAYER_MOVE_DIRECTION CPPSDirector::getPlyaerMoveDirection() const
{
    return mPlyaerMoveDirection;
}

bool CPPSDirector::mathCollisionPlayerAndWallInternal()
{
    if ((mPlayer->getCoordinate()[0].x + DEFAULT_MAP_WALL_X_THICKNESS == 0 ||
            mPlayer->getCoordinate()[0].x + DEFAULT_MAP_WALL_X_THICKNESS ==
            DEFAULT_MAP_WIDTH - DEFAULT_MAP_WALL_X_THICKNESS) ||
            (mPlayer->getCoordinate()[0].y + DEFAULT_MAP_WALL_Y_THICKNESS == 0 ||
            mPlayer->getCoordinate()[0].y + DEFAULT_MAP_WALL_Y_THICKNESS ==
            DEFAULT_MAP_HEIGHT - DEFAULT_MAP_WALL_Y_THICKNESS)) {
        return true;
    }

    return false;
}

bool CPPSDirector::mathCollisionPlayerAndEggInternal()
{
    if (mPlayer->getCoordinate()[0].x + 1 == mEggX &&
        mPlayer->getCoordinate()[0].y + 1 == mEggY) {
        return true;
    }

    return false;
}

main.cpp

#include "include/director.h"

#include <windows.h>
#include <stdio.h>

int main(int /*argc*/, char** /*argv*/)
{
    CPPSDirector director;
    director.start();

    system("pause");
    return 0;
}

三、编译

我本地是windows+mingw32的环境。编译命令是：

g++ src/main.cpp src/map.cpp src/egg.cpp src/director.cpp src/player.cpp -lpthread

总结

今年学校的科技活动总算应付过去了，本来想写的好一点的，再增加线程用来控制速度，再封装一个消息在几个线程之间传递控制。cout输出的时候也有优化的空间，不需要全部重新输出，代码也需要整理整理。奈何学校要的急，凑合着赶快交上去吧。等有空了再优化优化吧。

程序员小W
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言编译贪吃蛇游戏
01-31
请在win xp 系统或 windows sever 2003系统下运行vc6 c++编译本程序，否则可能出现为止错误！
C++贪吃蛇.cpp
05-06
C++实现贪吃蛇
linux下怎么编译贪吃蛇,在 Linux 终端中玩贪吃蛇
weixin_35795512的博客
05-02 123
原标题：在 Linux 终端中玩贪吃蛇 译自： https://opensource.com/article/18/12/linux-toy-snake作者： Jason Baker译者： geekpi有了这个 20 世纪 70 年代的经典重制游戏，Python 将不再是你在 Linux 终端能发现的唯一的“蛇”。欢迎回到 Linux 命令行玩具日历。如果这是你第一次访问该系列，你可能会问什么是命...
贪吃蛇的简单实现.cpp
04-21
简单实现贪吃蛇的功能既简单又耐玩。该游戏通过控制蛇头方向吃蛋，从而使得蛇变得越来越长。 小时候都玩过贪吃蛇这个经典的小游戏，在我们的普通手机里似乎都是必备的。它伴随着我们的童年，经历了好多好多时光。它带给我们了许多的乐趣。
【历史遗留】存一下中学时期玩的贪吃蛇cpp源代码
Teloy_041的博客
12-26 388
【历史遗留】存一下中学时期玩的贪吃蛇cpp源代码 #include <iostream> #include <stdio.h> #include <stdlib.h> #include <math.h> #include <algorithm> #include <climits> // INT_MAX 2147483647 #include <string> #include <string.h> /
devc++贪吃蛇 源码
06-14
devc++贪吃蛇源码，经典贪吃蛇代码，包括众多模式，开始游戏，游戏说明，结束游戏等模块。
c++贪吃蛇源码—附带注释.zip
07-22
在这个C++版本的贪吃蛇游戏中，我们将会探讨如何利用面向对象编程的思想来实现这个经典游戏。 【C++语言基础】 C++是一种强大的、通用的编程语言，它支持面向过程和面向对象的编程范式。在创建贪吃蛇游戏时，我们...
贪吃蛇C++源码
04-19
在本项目中，"贪吃蛇C++源码"是一个基于C++编程语言实现的经典游戏——贪吃蛇。贪吃蛇游戏自上个世纪80年代以来就深受玩家喜爱，其基本规则是控制一条蛇在有限的空间内移动，吃食物以增长，同时避免碰撞到自身或边界...
贪吃蛇C++程序源码
11-28
贪吃蛇c++.vcxproj 这是使用应用程序向导生成的 VC++ 项目的主项目文件， 其中包含生成该文件的 Visual C++ 的版本信息，以及有关使用应用程序向导选择的平台、配置和项目功能的信息。
c++贪吃蛇游戏程序源码
01-17
《C++贪吃蛇游戏程序源码解析》 在编程世界中，开发一款经典的游戏是学习新语言或技术的良好实践。C++作为一种强大的面向对象编程语言，被广泛应用于游戏开发。"C++贪吃蛇游戏程序源码"就是一个非常适合C++初学者的...
贪吃蛇(C/CPP)实现
weixin_44169596的博客
07-14 540
文末会将源代码公布，仅供大家一起学习，感谢网络上的各种学习资源及B站UP主们，有了你们的分享，我们才能更好更快地学习进步！！！ 效果如下图所展示： /* 贪吃蛇 snake.cpp 涉及内容：结构体、控制语句、循环、+easyx图形库 */ #include<stdio.h> #include<graphics.h> #include<conio.h> #include<mmsystem.h> //播放音乐 #pragma comment(lib,"
贪吃蛇（c++版）
寻梦&之璐
12-24 305
这个小游戏是博主一年前写的，大概是2020年1月份左右，现在发在csdn里面记录一下生活 第一步：墙的cpp代码 #include"wall.h" void Wall::initWall() { for (int i = 0; i < ROW; i++) { for (int j = 0; j < COL; j++) { if (i == 0 || j == 0 || i == ROW - 1 || j == COL -
贪吃蛇程序（c/Linux）
mjk1929425的博客
08-23 1444
很早就有了这个想法，只是一直没有践行，经过零零碎碎地小作业，慢慢就做了出来，看起来还行。 下面说一下我的思路： a 通过画一个二维数组显示游戏框图 b 创建蛇，单向链表最合适了 c 蛇的行动，撞墙、吃自己：游戏结束，移动、吃食物：游戏进行 d 蛇的控制，一开始用简单的getchar模拟，后面从网上找了按键识别，做出来了，还有待学习 e 游戏步骤：恢复空图-&amp;gt;写入蛇-&amp;gt;写入食...
贪吃蛇的C++实现
qq_56341866的博客
08-15 7823
一、实现的功能 1、介绍程序内容 2、选择控制方式（WASD或者方向键盘） 3、地图选择 4、速度选择 二、实现思路 既然刚学完C++，我们就要使用面向对象的方法来编程实现。创建唯一也是核心的类CentralWork，在其中实现所有功能。 贪吃蛇实现主要有四个步骤：食物的随机产生、蛇的移动显示、蛇移动方向的控制、蛇吃到食物与牺牲的判定。现在阐述实现思路。 1、食物的随机产生： 食物只存在一个，一个被吃后才会产生下一个随机食物。所以食物是否...
小白入门——“贪吃蛇”的C语言实现（详细）
热门推荐
隔壁家的二大爷
02-12 19万+
C语言实现，编译环境VS２０１７ 附：easyx图形化(文章末尾） 效果图如下 （有一些函数kbhit，getch，在这表示为_kbhit与_getch）//不同编译器原因 注意在Dev等集成开发软件下可能会CE o(*￣▽￣*)o 一、引言 作为一个小白，相信大家的心情都是一样的，渴望写一个人生的第一个“贪吃蛇”。 ...
贪吃蛇（一）--用C++编写一个简单的贪吃蛇
weixin_43918046的博客
09-29 1万+
#include<iostream> #include<windows.h> #include<conio.h> #include<time.h> using namespace std; #define random(a,b) (rand()%(b-a+1)+a) const int N=1e3+100;//蛇的最大长度 int X[N],Y[N];//记录蛇的每个节点的坐标 int Snake_length;//蛇的当前长度 int X1=1,Y1=1;
vscode这个报错该怎么解决PS D:\vscode＞ cd “d:\vscode\“ ； if ($?) { g++ tempCodeRunnerFile.cpp -o tempCodeRunn
m0_51242690的博客
11-17 8268
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
C++课程设计贪吃蛇小游戏(内附完整源码及附件)-(18918).pdf
07-02
"C++课程设计贪吃蛇小游戏(内附完整源码及附件)-(18918).pdf" 是一份详细的课程设计指南，旨在教授如何使用C++编程语言实现经典游戏“贪吃蛇”。这份资源包括了完整的源代码和相关的附件，适合于计算机科学与技术...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值