贪吃蛇 订阅
贪吃蛇游戏是一款休闲益智类游戏,有PC和手机等多平台版本。既简单又耐玩。该游戏通过控制蛇头方向吃蛋,从而使得蛇变得越来越长。 [1]  贪吃蛇游戏最初为单机模式,后续又陆续推出团战模式、赏金模式、挑战模式等多种玩法。 [2]  另外还有一种名为“贪吃蛇”钻井测井技术,是运用旋转导向系统、随钻测井系统等的油气田定向钻井、随钻测井技术,可完成海上“丛式井”和复杂油气层的开采需求,大幅降低油气田开发综合成本。 [3] 展开全文
贪吃蛇游戏是一款休闲益智类游戏,有PC和手机等多平台版本。既简单又耐玩。该游戏通过控制蛇头方向吃蛋,从而使得蛇变得越来越长。 [1]  贪吃蛇游戏最初为单机模式,后续又陆续推出团战模式、赏金模式、挑战模式等多种玩法。 [2]  另外还有一种名为“贪吃蛇”钻井测井技术,是运用旋转导向系统、随钻测井系统等的油气田定向钻井、随钻测井技术,可完成海上“丛式井”和复杂油气层的开采需求,大幅降低油气田开发综合成本。 [3]
信息
原版名称
Snake
游戏类型
益智
中文名
贪吃蛇
游戏平台
全平台
贪吃蛇游戏的玩法
用游戏把子上下左右控制蛇的方向,寻找吃的东西,每吃一口就能得到一定的积分,而且蛇的身子会越吃越长,身子越长玩的难度就越大,不能碰墙,不能咬到自己的身体,更不能咬自己的尾巴,等到了一定的分数,就能过关,然后继续玩下一关。贪吃蛇的唯一的目标就是长成最长的一条蛇!滑动摇杆控制小蛇走位,吃掉地图上彩色的小圆点,就会变长。小心!蛇头碰到其他蛇就会死亡,并且产生大量小圆点。长按加速键,用巧妙的走位让蛇身被别人撞上,就可以吃掉尸体迅速变长。 [2] 
收起全文
精华内容
参与话题
问答
  • 小白入门——“贪吃蛇”的C语言实现(详细)

    万次阅读 多人点赞 2018-02-12 11:15:32
    C语言实现,编译环境VS2017 附:easyx图形化(文章末尾) 效果图如下 (有一些函数kbhit,getch,在这表示为_kbhit与...作为一个小白,相信大家的心情都是一样的,渴望写一个人生的第一个“贪吃蛇”。 ...

    C语言实现,编译环境VS2017 附:easyx图形化(文章末尾)

     

     

    效果图如下

     

    (有一些函数kbhit,getch,在这表示为_kbhit与_getch)//不同编译器原因 注意在Dev等集成开发软件下可能会CE

     

    o(* ̄▽ ̄*)o

     

     

     

    一、引言

        作为一个小白,相信大家的心情都是一样的,渴望写一个人生的第一个“贪吃蛇”。

        在网上看了基本思路后,如果有一定的知识(链表的相关操作),写出这个应该是不难的。

        1、背景

            打印游戏背景框,以及一些初设的东西,如蛇的初始长度,可以的话可以自己加上出场界面

        2、食物产生

            通过srand,与rand 函数实现随机产生

        3、键盘信号获取

            由 _kbhit(),_getch() ,函数获取

        4、蛇的移动

            分为普通移动与吃到食物的移动

            ps.(许多网上通过刷屏实现,其实可以靠覆盖实现,将原来蛇覆盖用空格,然后重新打印蛇)

    二、一些必要函数

        打印这个并不是图形库实现,所以要通过光标跳转实现打印

        注:此方法我也不清楚是从网上查阅资料所得,目前还是小白(ง •_•)ง

        

    void gotoxy(int x, int y) 
    {
        // 更新光标位置 
    	COORD pos;
    	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    	pos.X = x;
    	pos.Y = y;
    	SetConsoleCursorPosition(hOutput, pos);
        // 隐藏光标 
        CONSOLE_CURSOR_INFO cursor;
    	cursor.bVisible = FALSE;    
    	cursor.dwSize = sizeof(cursor);
    	SetConsoleCursorInfo(hOutput, &cursor);
    }

        应该是获取窗口句柄

        详细可以参考

        https://baike.baidu.com/item/SetConsoleCursorPosition/575826

        https://baike.baidu.com/item/GetStdHandle/6909878?fr=aladdin

        https://baike.baidu.com/item/coord/4594820?fr=aladdin

    三、不多说,看代码

    以前写的太烂了 现在重新更新了

    /*
    @Author: Joke-Lin
    @Time: 2020-03-19
    @Encoding: GB 2312
    @IDE: VS2019
    */
    
    #include<stdio.h>
    #include<string.h>
    #include<windows.h>
    #include<time.h>
    #include<conio.h>
    
    #define up 'w'
    #define down 's'
    #define left 'a'
    #define right 'd'
    
    void welcome();               // 开始界面
    void Finish();                // 结束界面
    void creatgraph();            // 围墙打印
    void gotoxy(int x, int y);    // 光标跳转,横为X 0,1,2..
    void gotoprint(int x, int y); // 跳转打印
    void gotodelete(int x, int y);// 跳转删除
    void creatfood();             // 食物产生
    int ClickControl();           // 获取键盘信号
    int Judge();                  // 游戏结束判断
    void MovingBody();            // 蛇的移动 
    void Eating();                // 蛇吃到东西后的操作(伸长)
    void ChangeBody(int x, int y); // 蛇的坐标变换
    
    /*全局变量 + 预处理:*/
    typedef struct Snakes
    {
        int x;
        int y;
        struct Snakes* next;
    }snake;
    
    snake* head;    // 声明蛇头指针 
    
    // 申明并定义食物 
    struct Food
    {
        int x;
        int y;
    }food;
    
    char name[20];  // 保存用户名 有兴趣可以制作登录系统 
    int score = 0;  // 分数 
    char click = 1; // 记录敲下的键盘按键 
    int speed;      // 速度 其实是延迟的毫秒数 
    
    /************************************************************/
    
    int main()
    {
        system("color 0B"); // 设置控制台字体颜色 
        welcome();          // 欢迎界面 
        creatgraph();       // 创建地图 
        creatfood();        // 新建食物 
        // 捕获鼠标按键 ClickControl
        if (ClickControl() == 0) return 0;
        return 0;
    }
    
    /**********************************************************/
    void welcome()
    {
        gotoxy(15, 10);
        printf("/**********************************************/");
        gotoxy(15, 20);
        printf("/**********************************************/");
        gotoxy(20, 13);
        printf("WELCOME TO THE GAME OF RETRO SNAKE");
        gotoxy(14, 16);
        printf("请在英文输入法中操作,反向移动等同于吃到自己,wasd控制p暂停");
        gotoxy(20, 18);
        printf("PLEASE ENTER YOUR NAME:");
        scanf_s("%s", &name, 20);
        system("cls");
    }
    
    /**********************************************************/
    void creatgraph() {
        int i;
        /*
        注意这里横坐标是每次+2 因为控制台字符宽高比为1:2
        */
        for (i = 0; i < 58; i += 2)
        {
            gotoprint(i, 0);
            gotoprint(i, 26);
        }
        for (i = 1; i < 26; i++)
        {
            gotoprint(0, i);
            gotoprint(56, i);
        }
        gotoxy(63, 10);
        printf("hello %s,Welcome To Play", name);
        gotoxy(63, 15);
        printf("Your Score Is:%d    = ̄ω ̄= ", score);
        gotoxy(63, 20);
        printf("This Game Is Created By JOKER");
        head = (snake*)malloc(sizeof(snake));
        snake* p = (snake*)malloc(sizeof(snake));
        snake* q = (snake*)malloc(sizeof(snake));
        head->x = 16;
        head->y = 15;
        p->x = 16;
        p->y = 16;
        q->x = 16;
        q->y = 17;
        head->next = p;
        p->next = q;
        q->next = NULL;
    }
    /**********************************************************/
    void gotoxy(int x, int y)
    {
        // 更新光标位置 
        COORD pos;
        HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
        pos.X = x;
        pos.Y = y;
        SetConsoleCursorPosition(hOutput, pos);
        // 隐藏光标 
        CONSOLE_CURSOR_INFO cursor;
        cursor.bVisible = FALSE;
        cursor.dwSize = sizeof(cursor);
        SetConsoleCursorInfo(hOutput, &cursor);
    }
    
    /**********************************************************/
    void gotoprint(int x, int y)
    {
        gotoxy(x, y);
        printf("■");
    }
    
    /**********************************************************/
    void gotodelete(int x, int y)
    {
        gotoxy(x, y);
        printf("  ");
    }
    
    /**********************************************************/
    void creatfood()
    {
        // 随机产生一个食物 
        bool flag = false;
        while (!flag)
        {
            flag = true;
            srand((int)time(NULL));
            food.y = rand() % (25 - 1 + 1) + 1;
            food.x = rand() % (54 - 2 + 1) + 2;
            if (food.x % 2 != 0)
            {
                food.x = food.x + 1;
            }
            snake* judge = head;
            while (1)  //遍历排除蛇身重复
            {
                if (judge->next == NULL) break;
                if (food.x == judge->x && food.y == judge->y)
                {
                    flag = false;
                }
                judge = judge->next;
            }
        }
        gotoxy(food.x, food.y);
        printf("⊙");
    }
    
    /**********************************************************/
    // 捕获鼠标 游戏主循环 
    int ClickControl()
    {
        char c;
        while (1)
        {
            if (Judge() == 0) return 0;
            if (_kbhit())
            {
                click = _getch();
            }
            MovingBody();
            Eating();
        }
        return 1;
    }
    
    /**********************************************************/
    void MovingBody() {
        int x = head->x, y = head->y;
        snake* p = head;
        // 通过先清空后打印实现动画效果
        while (p->next != NULL) {
            p = p->next;
        }
        gotodelete(p->x, p->y); // 消除尾节点
        switch (click)
        {
        case up:
            y -= 1;
            break;
        case down:
            y += 1;
            break;
        case left:
            x -= 2;
            break;
        case right:
            x += 2;
            break;
        default:
            break;
        }
        if (x != head->x || y != head->y) {
            // 改变坐标时更新 暂停游戏停止更新蛇 
            ChangeBody(x, y);
        }
        p = head;
        // 打印蛇头
        gotoprint(p->x, p->y);
        // 蛇速度控制 
        int count = score / 10;
        if (count <= 10) speed = 150;
        else if (count > 10 && count <= 20) speed = 100;
        else if (count > 20 && count <= 40) speed = 50;
        else speed = 10;
        Sleep(speed);
    }
    
    /**********************************************************/
    // 吃到食物处理 添加一个尾巴 
    void Eating()
    {
        if (head->x == food.x && head->y == food.y)
        {
            creatfood();
            snake* _new = (snake*)malloc(sizeof(snake));
            snake* p;
            p = head;
            while (1)
            {
                if (p->next == NULL) break;
                p = p->next;
            }
            p->next = _new;
            _new->next = NULL;
            score += 10;
            gotoxy(77, 15);
            printf("%d", score);
        }
    }
    
    /**********************************************************/
    // 更新蛇体坐标 只需要消除尾结点 然后把新坐标结点置为头结点即可 
    void ChangeBody(int x, int y)
    {
        snake* p = head;
        while (p->next->next != NULL) {
            p = p->next;
        }
        free(p->next);
        p->next = NULL;
        snake* new_head = (snake*)malloc(sizeof(snake));
        new_head->x = x;
        new_head->y = y;
        new_head->next = head;
        head = new_head;
    }
    
    /**********************************************************/
    // 判断是否游戏结束 
    int Judge()
    {
        if (head->x == 0 || head->x == 56 || head->y == 0 || head->y == 26)
        {
            Finish();
            return 0;
        }
        snake* p = head->next;
        while (1)
        {
            if (p == NULL) break;
            if (head->x == p->x && head->y == p->y)
            {
                Finish();
                return 0;
            }
            p = p->next;
        }
        return 1;
    }
    
    /**********************************************************/
    void Finish()
    {
        system("cls");
        gotoxy(15, 10);
        printf("/**********************************************/");
        gotoxy(15, 20);
        printf("/**********************************************/");
        gotoxy(18, 14);
        printf("GAME   OVER      o(* ̄▽ ̄*)o");
        gotoxy(20, 16);
        printf("Your Score is %d    hiahiahia", score);
        gotoxy(18, 18);
        printf("还不错哦,     继续努力O(∩_∩)O");
        gotoxy(0, 27);
        // 释放空间 
        snake* p = head, * q;
        while (p != NULL) {
            q = p->next;
            free(p);
            p = q;
        }
        system("pause");
    }

    四、

       easyx 实现:链接地址

     效果如下:

         

    觉得好的话欢迎犒劳(ง •_•)ง (要恰饭的嘛嘿嘿)

    对评论里的重点问题,我有时间在博客里多加一些

    展开全文
  • C语言写个贪吃蛇游戏

    万次阅读 多人点赞 2020-02-19 08:24:09
    贪吃蛇是个非常经典的游戏,用C语言来实现也是一个好玩的事情。这个游戏我写完后放在知乎,竟然点赞的人数超级多。我觉得大家喜欢,一个方面是因为写得简单,大家都能看得懂,一个可扩展性还是非常强...

    贪吃蛇是个非常经典的游戏,用C语言来实现也是一个好玩的事情。这个游戏我写完后放在知乎,竟然点赞的人数超级多。我觉得大家喜欢,一个方面是因为写得简单,大家都能看得懂,一个可扩展性还是非常强的。

    我试了说一下这个代码 核心的三个函数

        menu();
        setup();
        draw();
    

    menu用来设置菜单,也就是我们一运行看到的那个。setup用来设置参数,我们需要设置高度和宽度,还有分数,食物的位置。draw也就是画,也就是画整个画面。

    还有一个枚举类型 这个结构体用来设置蛇的几个状态,我觉得这个也是面向对象编程的一个思想,把蛇的状态都封装成一个枚举类型。

    typedef enum
    {
            STOP = 0,
            LEFT,
            RIGHT,
            UP,
            DOWN
    }Direction;
    

    还有

    /*判断贪吃蛇的长度*/
    void logic()
    

    这个函数,这个函数应该是整个贪吃蛇的精髓了,要理解代码怎么把蛇给连接起来。用了点巧妙的东西。

    来看这里面的关键代码

    /*把上一个位置记下*/
        int lastX = tailX[0];
        int lastY = tailY[0];
        int last2X, last2Y;
        /*重新获取当前的位置*/
        tailX[0]=x;
        tailY[0]=y;
        int i=0;
        /*遍历整条蛇的长度 把 0 的位置空出来,其余蛇的位置往后面的空间移动*/
        for(i=1; i<ntail;i++)
        {
            last2X = tailX[i];
            last2Y = tailY[i];
            tailX[i]=lastX;
            tailY[i]=lastY;
            lastX = last2X;
            lastY = last2Y;
        }
    

    lastX lastY 用来存上一次的蛇头的位置。后面的 for 循环,通过tail 蛇的长度,把蛇上个状态给保存到数组tailX tailY里面。

    完整代码

    
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    #include <Windows.h>
    #include <time.h>
    #include <conio.h> /*键盘输入获取*/
    
    bool gameOver;
    bool stop = false;
    bool hit = false;
    /*游戏的边框大小*/
    const int width = 50;
    const int height = 20;
    /*蛇的坐标,食物的坐标还有分数*/
    int x,y,fruitX,fruitY,score;
    /*蛇每个点的坐标*/
    int tailX[200],tailY[200];
    /*蛇的默认长度*/
    int ntail=3;
    
    typedef enum
    {
            STOP = 0,
            LEFT,
            RIGHT,
            UP,
            DOWN
    }Direction;
    
    Direction Dir;
    /*开始菜单*/
    void menu()
    {
        int a;
        printf("------------------------------------------------------------------\n");
        printf("|                              贪吃蛇游戏                        |\n");
        printf("|                              1) 新游戏                         |\n");
        printf("|                              2) 开始边界                       |\n");
        printf("|                              3) 退出游戏                       |\n");
        printf("------------------------------------------------------------------\n");
        printf("---->请输入你的选择:");
        scanf("%d", &a);
    }
    
    /*初始化状态*/
    void setup()
    {
        gameOver = false;
        /*根据当前时间设置“随机数种子”*/
        srand(time(NULL));
        Dir = STOP;
        
        /*贪吃蛇的位置,固定在中间*/
        x= width/2;
        y= height/2;
        /*食物的位置,位置是随机的*/
        fruitX = rand()%width;
        fruitY = rand()%height;
        score = 0;
    }
    /*绘制界面*/
    void draw()
    {
            if(stop == true)
            {
                    return;
            }
        system("cls");/*清除屏幕*/
        printf("分数:%d",score);
        printf("\n");
        
            /*第一行*/
        int i;
        for(i= 0 ;i<width+1;i++)
            {
            printf("-");
        }
        printf("\n");
        
        /*画中间的画面*/
        int p;
        for(p= 0 ;p<height;p++)/*高度*/
            {
            int q;
            for(q= 0 ;q<width;q++)/*宽度*/
                    {
                            /*第一行最后已给字符*/
                if(q==0 || q==width-1)
                            {
                    printf("|");
                }
                
                            if(p == fruitY && q == fruitX)/*食物的随机坐标*/
                            {
                    printf("O");
                }
                            else
                            {
                        int k=0;
                        bool print = false;
                        /*贪吃蛇的长度 默认长度是 3*/
                                            for(k=0;k<ntail;k++)
                                            {
                            if(tailX[k]==q && tailY[k]==p)
                                                    {
                                printf("*");
                                print = true;
                            }
                        }
                        /*如果这个位置打印了 * 就不要打印空格了*/
                        if(!print)
                                            {
                                                    printf(" ");
                                            }
                }
            }
            printf("\n");
        }
    
            /*最后一行*/
        int j;
        for(j= 0 ;j<width+1;j++)
            {
            printf("-");
        }
    
    }
    /*按键输入控制*/
    void input()
    {
        if(_kbhit())
            {
                    /*获取键盘的输入字符*/
            switch(_getch())
                    {
                case '4':
                case 75:/*左键*/
                    Dir = LEFT;
                    hit= true;
                    break;
                case '8':
                case 72:/*上键*/
                    Dir = UP;
                    hit= true;
                    break;
                case '6':
                case 77:/*右键*/
                    Dir = RIGHT;
                    hit= true;
                    break;
                case '2':
                case 80:/*向下键盘键 */
                    Dir = DOWN;
                    hit= true;
                    break;
                case 'x':
                case 27:/*ESE*/
                    gameOver = true;
                    break;
                case 32:/*空格 暂停键*/
                                    stop = !stop;
                                    break;
            }
        }
            else if(!hit && stop == false)/*如果没有改变方向*/
            {
            x++;
        }
    }
    /*判断贪吃蛇的长度*/
    void logic()
    {
            if(stop == true)
            {
                    return;
            }
            
            /*把上一个位置记下*/
        int lastX = tailX[0];
        int lastY = tailY[0];
        int last2X, last2Y;
        /*重新获取当前的位置*/
            tailX[0]=x;
        tailY[0]=y;
        int i=0;
        /*遍历整条蛇的长度 把 0 的位置空出来,其余蛇的位置往后面的空间移动*/
        for(i=1; i<ntail;i++)
            {
            last2X = tailX[i];
            last2Y = tailY[i];
            tailX[i]=lastX;
            tailY[i]=lastY;
            lastX = last2X;
            lastY = last2Y;
        }
        /*根据方向来改变x y 的值*/
        switch(Dir)
            {
            case UP:
                y--;
                break;
            case DOWN:
                y++;
                break;
            case LEFT:
                x--;
                break;
            case RIGHT:
                x++;
                break;
        }
        if(x<0 || width<x || y<0 || height<y)
            {
            gameOver = true;
            /*清除屏幕*/
            system("cls");
            printf("------------------------------------------------------------------\n");
                printf("|                                                                |\n");
                printf("|                                                                |\n");
                printf("|                             游戏结束                           |\n");
                printf("|                                                                |\n");
                printf("|                                                                |\n");
                printf("------------------------------------------------------------------\n");
        }
        if(x==fruitX && y==fruitY)
            {
                    /*吃了一个食物,蛇的长度增加1*/
            ntail++;
            score+=10;
            /*更新下一个食物的位置*/
            fruitX = rand()%width;
            fruitY = rand()%height;
        }
    }
    int main()
    {
    #if 0
            while(1)
            {
                    printf("%d\n",_getch());
            }
    #endif
        menu();
        setup();
        draw();
        /*循环画贪吃蛇的界面*/
            while(!gameOver)
            {
            draw();
            input();
            logic();
            Sleep(70);
        }
    
        return 0;
    }
    

    上面这段代码直接在Dev C++上面应该是可以运行的,很多人在知乎上私信问我,为什么我的贪吃蛇执行不了呢,可能就是平台不同,少了这个头文件,少了那个头文件,但是你为什么不能跟我一样,用Dev C++呢,轻量级,简单。代码的精髓是什么?我认为精髓一定是思想,不是你写了多少行代码,用了什么高端的IDE。

    我自认为我的注释已经写得不错了,所以就没有什么好说明的了吧,有不明白的把代码过一下,至于屏幕刷新这个东西,如果只是用时间刷新就会闪屏,所以出现了一个双缓存,把要显示的东西送到一个buff里面去,另一个buff用来显示,这样就可以保证不会出现闪屏。除了写贪吃蛇,可以用这个方法写其他小程序,挺有意思的。

    在知乎上,发起了一个C语言 100 行代码之内实现贪吃蛇的问题。我觉得很不错,里面很多同学的回复都非常赞,特别是叶大神的回复。

    https://www.zhihu.com/question/360814879/answer/1013986215


    扫码或长按关注

    回复「 篮球的大肚子」进入技术群聊

    展开全文
  • 经典游戏---贪吃蛇从C++代码实现

    万次阅读 多人点赞 2014-05-31 00:09:10
    小时候都玩过贪吃蛇这个经典的小游戏,在我们的普通手机里似乎都是必备的。它伴随着我们的童年,经历了好多好多时光。它带给我们了许多的乐趣。 学习了c++这门编程语言后,我就想着能不能把它做出来,在我查看了相关...

    1.   题目描述

    小时候都玩过贪吃蛇这个经典的小游戏,在我们的普通手机里似乎都是必备的。它伴随着我们的童年,经历了好多好多时光。它带给我们了许多的乐趣。

    学习了c++这门编程语言后,我就想着能不能把它做出来,在我查看了相关知识后,明白了其中的道理,就尝试着自己写出这个小游戏来,而且加入了许多可玩性的东西,包括等级选择,暂停/继续和分数制。整个程序采用了类和数组的相关知识实现。

     

    2.   分析思路

    下面就来讲讲贪吃蛇的整个设计思路:

    一、

               贪吃蛇的特点是随机产生食物后,然后通过上下左右地方向键来控制贪吃蛇的移动,

    当碰到食物时,便把它吃掉,从而身体长度增加一个,这里便采用“#”作为蛇头,”*”作为蛇身和食物。

               因此我便想到,产生的食物,是如何达到随机的目的呢?通过查阅资料得知,在time.h头文件中,定义了通过rand()函数来产生随机数。下面是相关知识:

    概述

    rand()函数是产生随机数的一个随机函数C语言里还有srand()函数等。

    详述

    (1)使用该函数首先应在开头包含头文件stdlib.h

    #include<stdlib.h>(C++建议使用#include<cstdlib>,下同)

    (2)在标准的C库中函数rand()可以生成0~RAND_MAX之间的一个随机数,其中RAND_MAXstdlib.h 中定义的一个整数,它与系统有关。

    (3)rand()函数没有输入参数,直接通过表达式rand()来引用;例如可以用下面的语句来打印两个随机数:

    printf("Random numbers are: %i %i\n",rand(),rand());

    (4)因为rand()函数是按指定的顺序来产生整数,因此每次执行上面的语句都打印相同的两个值,所以说C语言的随机并不是真正意义上的随机,有时候也叫伪随机数

    (5)为了使程序在每次执行时都能生成一个新序列的随机值,我们通常通过为随机数生成器提供一粒新的随机种子。函数srand()(来自stdlib.h)可以为随机数生成器播散种子。只要种子不同rand()函数就会产生不同的随机数序列。srand()称为随机数生成器的初始化器

    由于一开始没有使用srand()函数,多次运行后发现,每次打开运行后产生的食物位置都是一致的,并没有真正达到随机的目的。因此使用srand()函数,又通过time()函数来每次调用一个系统时间来作为srand()的种子。由于每次调用的系统时间并不相同,所以每次的种子也就不相同,从而使得rand()函数达到了随机数的目的。下面是time()函数相关知识:

    time() 函数返回自 Unix 纪元(January 1 1970 00:00:00 GMT)起的当前时间的秒数。[1]

    主要用来获取当前的系统时间,返回的结果是一个time_t类型,其值表示从UTCCoordinated Universal Time)时间19701100:00:00(称为UNIX系统的Epoch时间)到当前时刻的秒数。然后调用localtime函数将time_t所表示的UTC时间转换为本地时间(我们是+8区,比UTC8个小时)并转成struct tm类型,该类型的各数据成员分别表示年月日时分秒。需要包含头文件<time.h>

    C标准库函数

    time_t time(time_t *t);

    如果t是空指针,直接返回当前时间。如果t不是空指针,返回当前时间的同时,将返回值赋予t指向的内存空间。

    这样便通过rand()函数产生了随机数,对其进行取模,便得到一定范围内的随机数了。

    二、

    然后便是吃食的问题了,当蛇头遇到一个食物时(食物在贪吃蛇前进的方向上),便将该食物变为蛇头,然后将原先的蛇头变为蛇身,从而达到了吃食的目的。

    那如果没有碰到食物呢?就按照原来的方向或者键盘按下的方向继续前进就是了。

     

    三、

             下面就是实现的问题了,如何将每个动态都展现出来呢?就是说贪吃蛇是一下一下往前移动的,这个又是如何实现的呢?

             这里我使用了clock()函数,下面是相关知识:

    clock()C/C++中的计时函数,而与其相关的数据类型clock_t。在MSDN中,查得对clock函数定义如下:

    clock_t clock(void) ;

    简单而言,就是该程序从启动到函数调用占用CPU的时间。这个函数返回从开启这个程序进程程序中调用clock()函数时之间的CPU时钟计时单元(clock tick)数,在MSDN中称之为挂钟时间(wal-clock);若挂钟时间不可取,则返回-1。其中clock_t是用来保存时间的数据类型

             因此,通过定义int start = clock();while(clock()-start<=gamespeed);这样一个方式来达到了延时的目的,延时的时间则根据gamespeed的值来确定,当gamespeed值越小时,延时时间越短。经过延时后,再执行下一步代码,从而实现了贪吃蛇自动前进的功能和控制其前进的速度啦。

             然而,仅仅有这些还是不行的,还需要解决输出问题。

             通过查阅资料得知,system(“cls”);具有清屏的功能,清除当前屏幕上的内容,进行下一步的输出,因此我便使用了每动一下都要进行清屏,然后将贪吃蛇棋盘整个画面进行输出。

     

     

    四、

             为了增加游戏的娱乐性,我又从中加入了等级选择功能,通过输入数字来选择等级,等级越高,贪吃蛇移动速度越快,而且得分越高。得分规则:score += grade*20;

             考虑到游戏的功能性,在游戏结束后输出得分情况,并提示是否继续游戏,而不是直接退出游戏,这样用户就不必每次游戏失败后重新打开程序进行游戏,而是通过选择的方式决定继续游戏或者退出游戏。

             而且加入暂停功能,当玩家玩累了,需要暂停的时候,按下空格(space)键实现暂停,

    但由于我的原因,无法解决需要按两下空格才能继续游戏的bug,就暂定为按两下空格键继续游戏吧。


    #include <windows.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <time.h>
    #include <cstring>
    #include <cstdio>
    #include <iostream>
    #define  N 22
    using namespace std;
    
        int gameover;
    
        int x1, y1; // 随机出米
    
        int x,y;
    
        long start;
    
    //=======================================
    //类的实现与应用initialize
    //=======================================
    
    //下面定义贪吃蛇的坐标类
    class snake_position
    {
    public:
    
        int x,y;      //x表示行,y表示列
    
        snake_position(){};
    
        void initialize(int &);//坐标初始化
    
    
    };
    
    snake_position position[(N-2)*(N-2)+1]; //定义贪吃蛇坐标类数组,有(N-2)*(N-2)个坐标
    
    void snake_position::initialize(int &j)
    {
            x = 1;
    
            y = j;
    }
    
    
    //下面定义贪吃蛇的棋盘图
    
    class snake_map
    {
    
    private:
    
        char s[N][N];//定义贪吃蛇棋盘,包括墙壁。
    
        int grade, length;
    
        int gamespeed; //前进时间间隔
    
        char direction; // 初始情况下,向右运动
    
        int head,tail;
    
        int score;
    
        bool gameauto;
    
    public:
    
        snake_map(int h=4,int t=1,int l=4,char d=77,int s=0):length(l),direction(d),head(h),tail(t),score(s){}
    
        void initialize();   //初始化函数
    
        void show_game();
    
        int updata_game();
    
        void setpoint();
    
        void getgrade();
    
        void display();
    
    
    };
    
    //定义初始化函数,将贪吃蛇的棋盘图进行初始化
    
    void snake_map::initialize()
    {
        int i,j;
    
        for(i=1;i<=3;i++)
    
            s[1][i] = '*';
    
        s[1][4] = '#';
    
        for(i=1;i<=N-2;i++)
    
            for(j=1;j<=N-2;j++)
    
                s[i][j]=' '; // 初始化贪吃蛇棋盘中间空白部分
    
        for(i=0;i<=N-1;i++)
    
            s[0][i] = s[N-1][i] = '-'; //初始化贪吃蛇棋盘上下墙壁
    
        for(i=1;i<=N-2;i++)
    
            s[i][0] = s[i][N-1] = '|'; //初始化贪吃蛇棋盘左右墙壁
    }
    
    
    //============================================
    //输出贪吃蛇棋盘信息
    
    void snake_map::show_game()
    
    {
    
        system("cls"); // 清屏
    
        int i,j;
    
        cout << endl;
    
        for(i=0;i<N;i++)
        {
    
            cout << '\t';
    
            for(j=0;j<N;j++)
    
                cout<<s[i][j]<<' '; // 输出贪吃蛇棋盘
    
            if(i==2) cout << "\t等级:" << grade;
    
            if(i==6) cout << "\t速度:" << gamespeed;
    
            if(i==10) cout << "\t得分:" << score << "分" ;
    
            if(i==14) cout << "\t暂停:按一下空格键" ;
    
            if(i==18) cout << "\t继续:按两下空格键" ;
    
            cout<<endl;
        }
    }
    
    //输入选择等级
    void snake_map::getgrade()
    {
        cin>>grade;
    
        while( grade>7 || grade<1 )
        {
            cout << "请输入数字1-7选择等级,输入其他数字无效" << endl;
    
            cin >> grade;
        }
        switch(grade)
        {
            case 1: gamespeed = 1000;gameauto = 0;break;
    
            case 2: gamespeed = 800;gameauto = 0;break;
    
            case 3: gamespeed = 600;gameauto = 0;break;
    
            case 4: gamespeed = 400;gameauto = 0;break;
    
            case 5: gamespeed = 200;gameauto = 0;break;
    
            case 6: gamespeed = 100;gameauto = 0;break;
    
            case 7: grade = 1;gamespeed = 1000;gameauto = 1;break;
    
        }
    
    }
    
    //输出等级,得分情况以及称号
    
    void snake_map::display()
    {
    
        cout << "\n\t\t\t\t等级:" << grade;
    
        cout << "\n\n\n\t\t\t\t速度:" << gamespeed;
    
        cout << "\n\n\n\t\t\t\t得分:" << score << "分" ;
    
    }
    
    //随机产生米
    void snake_map::setpoint()
    {
        srand(time(0));
    
        do
        {
    
            x1 = rand() % (N-2) + 1;
    
            y1 = rand() % (N-2) + 1;
    
        }while(s[x1][y1]!=' ');
    
        s[x1][y1]='*';
    }
    
    char key;
    
    int snake_map::updata_game()
    {
        gameover = 1;
    
        key = direction;
    
        start = clock();
    
        while((gameover=(clock()-start<=gamespeed))&&!kbhit());
    
        //如果有键按下或时间超过自动前进时间间隔则终止循环
    
    
    
            if(gameover)
            {
    
                getch();
    
                key = getch();
            }
    
            if(key == ' ')
    
            {
                while(getch()!=' '){};//这里实现的是按空格键暂停,按空格键继续的功能,但不知为何原因,需要按两下空格才能继续。这是个bug。
            }
    
            else
    
                direction = key;
    
            switch(direction)
            {
                case 72: x= position[head].x-1; y= position[head].y;break; // 向上
    
                case 80: x= position[head].x+1; y= position[head].y;break; // 向下
    
                case 75: x= position[head].x; y= position[head].y-1;break; // 向左
    
                case 77: x= position[head].x; y= position[head].y+1; // 向右
    
            }
    
            if(!(direction==72||direction==80||direction==75 ||direction==77))   // 按键非方向键
    
                gameover = 0;
    
            else if(x==0 || x==N-1 ||y==0 || y==N-1)   // 碰到墙壁
    
                gameover = 0;
    
            else if(s[x][y]!=' '&&!(x==x1&&y==y1))    // 蛇头碰到蛇身
    
                gameover = 0;
    
            else if(x==x1 && y==y1)
    
            { // 吃米,长度加1
    
                length ++;
    
                if(length>=8 && gameauto)
    
                {
    
                    length -= 8;
    
                    grade ++;
    
                    if(gamespeed>=200)
    
                        gamespeed -= 200; // 改变贪吃蛇前进速度
    
                    else
    
                        gamespeed = 100;
    
                }
    
                s[x][y]= '#';  //更新蛇头
    
                s[position[head].x][position[head].y] = '*'; //吃米后将原先蛇头变为蛇身
    
                head = (head+1) % ( (N-2)*(N-2) );   //取蛇头坐标
    
                position[head].x = x;
    
                position[head].y = y;
    
                show_game();
    
                gameover = 1;
    
                score += grade*20;  //加分
    
                setpoint();   //产生米
    
            }
    
            else
            { // 不吃米
    
                s[position[tail].x][position[tail].y]=' ';//将蛇尾置空
    
                tail= (tail+1) % ( (N-2) * (N-2) );//更新蛇尾坐标
    
                s[position[head].x][position[head].y]='*';  //将蛇头更为蛇身
    
                head= (head+1) % ( (N-2) * (N-2) );
    
                position[head].x = x;
    
                position[head].y = y;
    
                s[position[head].x][position[head].y]='#'; //更新蛇头
    
                gameover = 1;
    
            }
        return gameover;
    
    }
    //====================================
    //主函数部分
    //====================================
    int main()
    {
        char ctn = 'y';
    
        int nodead;
    
        cout<<"\n\n\n\n\n\t\t\t 欢迎进入贪吃蛇游戏!"<<endl;//欢迎界面;
    
        cout<<"\n\n\n\t\t\t 按任意键马上开始。。。"<<endl;//准备开始;;
    
        getch();
    
        while( ctn=='y' )
        {
            system("cls"); // 清屏
    
            snake_map snake;
    
            snake.initialize();
    
            cout << "\n\n请输入数字选择游戏等级:" << endl;
    
            cout << "\n\n\n\t\t\t1.等级一:速度 1000 \n\n\t\t\t2.等级二:速度 800 \n\n\t\t\t3.等级三:速度 600 ";
    
            cout << "\n\n\t\t\t4.等级四:速度 400 \n\n\t\t\t5.等级五:速度 200 \n\n\t\t\t6.等级六:速度 100 \n\n\t\t\t7.自动升级模式" << endl;
    
            snake.getgrade();//获取等级
    
            for(int i=1;i<=4;i++)
            {
                position[i].initialize(i);//初始化坐标
            }
    
            snake.setpoint();  // 产生第一个米
    
            do
            {
                snake.show_game();
    
                nodead = snake.updata_game();
    
            }while(nodead);
    
            system("cls"); //清屏
    
    
    
            cout << "\n\n\n\t\t\t\tGameover!\n\n"<<endl;
    
            snake.display();//输出等级/得分情况
    
            cout << "\n\n\n\t\t    是否选择继续游戏?输入 y 继续,n 退出" << endl;
    
            cin >> ctn;
    
        }
    
        return 0;
    }
    



    展开全文
  • 【C语言】贪吃蛇游戏的实现(一)

    万次阅读 多人点赞 2018-12-28 11:32:38
    最近由于小创需要,捣鼓了一个贪吃蛇游戏,系统由纯C语言开发,VC++6.0编译通过,具体的运行效果如下: 略显简陋的开始界面,图案是我一点一点拼的,因为有\需要转义,所以对齐也花了不少时间,足够繁杂和无聊的...

    (注意:本代码是在VC++6.0环境下编译的,在其他环境如codeblocks下运行可能会产生意想不到的问题,请尽量使用VC。至于为什么要使用VC编译,哦,我亲爱的朋友,这只有上帝才知道)

    最近由于小创需要,捣鼓了一个贪吃蛇游戏,系统由纯C语言开发,VC++6.0编译通过,具体的运行效果如下:

    略显简陋的开始界面,图案是我一点一点拼的,因为有\需要转义,所以对齐也花了不少时间,足够繁杂和无聊的工作。

    游戏界面如图所示,左侧方框是地图,菱形组成的线是蛇,红色圆点是食物,吃到加分。

    游戏结束界面可以选择再来一局或者退出。

    系统源码链接:https://download.csdn.net/download/includei/10878930

    为了给以后自己留个参考,记录心得体会,也希望能对做相同项目的人有所帮助或启发,我把这个游戏的开发过程整理成博客发布,陆续更新,不足之处恳请批评斧正。

     

    好了,让我们进入正题。

    贪吃蛇游戏是一款经典的益智游戏,有PC和手机等多平台版本。既简单又耐玩。该游戏通过控制蛇头方向吃食物,从而使得蛇变得越来越长。它的基本规则是:一条蛇出现在封闭空间中,空间中随机出现一个食物,通过键盘上下左右方向键控制蛇前进方向。蛇头撞到食物,食物消失,蛇身体增长一节,累计得分,刷新食物。如果蛇在前进过程中撞到墙或自己身体,则游戏失败。

    我们可以简单地画出游戏的大概流程图:

    贪吃蛇游戏分为四个界面,包括欢迎界面,游戏界面,游戏说明和游戏结束界面。实现的主要功能有:

    1.字符图案装饰。
               2.绘制游戏地图。
               3.绘制移动的贪吃蛇。
               4.随机绘制食物并且位置不与当前蛇身体重合。
               5.键盘按键控制蛇的前进方向。
               6.不按键时,蛇自动前进。
               7.文件读写,存入和读取最高分。

    我们列出为实现各个模块功能所需要的函数:

    暂且省略定义,下面依次介绍各个函数的功能,首先说明欢迎界面的函数,因为游戏说明界面其实只是打印字符较为简单,我们也一并列出。为了在窗口内合适位置打印字符,我们需要控制光标的位置,声明gotoxy()函数以实现设置光标位置。

    /*
    	设置光标位置
    */
    void gotoxy(int x,int y)
    {
        COORD c;
        c.X=x;
        c.Y=y;
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),c);
    }

    为了让显示的文字色彩多样,我们声明color()函数用于改变文字颜色。

    /*
    	文字颜色函数
    */
    int color(int c)
    {
    	//SetConsoleTextAttribute是API设置控制台窗口字体颜色和背景色的函数
    	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c);        //更改文字颜色
    	return 0;
    }

    接着声明printsnake()函数用于打印欢迎界面的字符装饰,color(2)设置文字颜色为绿色。

    /*
    	字符拼成英文图案
    */
    void printsnake()
    {
    	color(2);
    	printf("                                                                                         \n");
    	printf("                       __________       ___                                              \n");
    	printf("                      /          \\     / \\ \\    |____      __\\__                     \n");
    	printf("                     /  ________  \\   / ___ \\  _/ __     | |   /                       \n");
    	printf("                     |  |      |__|     _/_   |_|  /    [|] |/                           \n");
    	printf("                     |  |              | | |      /     _|_ \\__/                        \n");
    	printf("                     \\  \\_______        / \\      |___/        ____                    \n");
    	printf("                      \\         \\    ____ ____      ____   __ |  |  ___   ______       \n");
    	printf("                       \\_______  \\   |  |/    \\    /    \\_/ / |  | /  /  /      \\   \n");
    	printf("                               \\  \\  |    ___  \\  / ____   /  |  |/  /  /  ____  \\   \n");
    	printf("                     __        |  |  |   /   \\  \\ | |  |  /   |     /  |  /____\\  |   \n");
    	printf("                    \\  \\_______|  |  |  |    |  | | |__|  |   |     \\  |  ________/   \n");
    	printf("                     \\            /  |  |    |  |  \\       \\  |  |\\  \\  \\  \\____  \n");
    	printf("                      \\__________/   |__|    |__|   \\___/\\__\\ |__| \\__\\  \\______/ \n");	
    }

    然后我们声明welcometogame()函数绘制菜单选项并通过switch实现选择功能。

    /*
    	开始界面
    */
    void welcometogame()
    {
    	int n;
    	int i,j = 1;
    	gotoxy(43,18);
    	color(11);
    	printf("贪 吃 蛇 游 戏");
    	color(14);          			//黄色边框
    	for (i = 20; i <= 26; i++)   	//输出上下边框┅
    	{
    		for (j = 27; j <= 74; j++)  //输出左右边框┇
    		{
    			gotoxy(j, i);
    			if (i == 20 || i == 26)
    			{
    				printf("-");
                }
    			else if (j == 27 || j == 74)
                {
    				printf("|");
                }
    		}
    	}
    	color(10);
    	gotoxy(35, 22);
    	printf("1.开始游戏");
    	gotoxy(55, 22);
    	printf("2.游戏说明");
    	gotoxy(35, 24);
    	printf("3.退出游戏");
    	gotoxy(29,27);
    	color(3);
    	printf("请选择[1 2 3]:[ ]\b\b");        //\b为退格,使得光标处于[]中间
    	color(14);
        scanf("%d", &n);    		//输入选项
        switch (n)
        {
        	case 1:					//选择开始游戏
        		system("cls");
    			createMap();        //创建地图
    			initsnake();        //初始化蛇身
    			createfood();		//初始化食物
    			keyboardControl();	//控制键盘按钮
            	break;
        	case 2:					//选择游戏说明
            	explation();
            	break;
        	case 3:					//选择退出游戏
            	exit(0);     		//退出游戏
            	break;
    		default:				//输入非1~3之间的选项
    			color(12);
    			gotoxy(40,28);
    			printf("请输入1~3之间的数!");
    			getch();			//输入任意键
    			system("cls");		//清屏
    			printsnake();
    			welcometogame();
        }
    }

    游戏说明界面explation()函数实现打印说明文字的功能。

    /*
    	游戏说明
    */
    void explation()
    {
    	int i,j = 1;
        system("cls");
        color(15);
        gotoxy(44,3);
        printf("游戏说明");
        color(2);
        for (i = 6; i <= 22; i++)   //输出上下边框===
    	{
    		for (j = 20; j <= 76; j++)  //输出左右边框||
    		{
    			gotoxy(j, i);
    			if (i == 6 || i == 22) printf("=");
    			else if (j == 20 || j == 75) printf("||");
    		}
    	}
        color(3);
        gotoxy(30,8);
        printf("tip1: 不能撞墙,不能咬到自己");
        color(10);
        gotoxy(30,11);
        printf("tip2: 用↑.↓.←.→分别控制蛇的移动");
        color(14);
        gotoxy(30,14);
        printf("tip3: F1 为加速,F2 为减速");
        color(11);
        gotoxy(30,17);
        printf("tip4: 按空格键暂停游戏,再按空格键继续");
        color(4);
        gotoxy(30,20);
        printf("tip5: Esc :退出游戏");
        getch();                //按任意键返回主界面
        system("cls");
        printsnake();
        welcometogame();
    }

    以上便是欢迎界面和游戏说明界面的函数介绍,下一部分内容有空的时候继续更新(最后让我吐槽一下富文本编辑器这谜一样的代码对齐方式)。

    展开全文
  • 贪吃蛇(c实现)

    千次阅读 2019-04-28 10:40:44
    最近复习了结构体和链表,就想熟悉一下这些应用,因此观摩大佬写的贪吃蛇,自己照葫芦画瓢也写了一个出来.源博客地址为:https://blog.csdn.net/qq_40953281/article/details/79315254 不过我对此有一个方面的改动: 1.蛇...
  • 贪吃蛇

    2020-03-22 19:19:05
    文章目录贪吃蛇wall.hwall.cppfood.hfood.cppsnake.hsnake.cpp 贪吃蛇 wall.h #ifndef _WALL_HEAD #define _WALL_HEAD //#pragma once #include <iostream> using namespace std; class Wall { public: ...
  • 用c语言编写小游戏:贪吃蛇

    千次阅读 多人点赞 2017-04-28 23:10:34
    用c语言编写小游戏:贪吃蛇
  • JS贪吃蛇

    万次阅读 多人点赞 2020-08-21 00:33:45
    用JS代码实现网页版贪吃蛇小游戏 老规矩,代码自用自取,复制粘贴直接使用,喜欢的话可以查看博主其它文章,贡献一丢丢的浏览量,感激不尽。 <!DOCTYPE html> <html> <head> <title>...
  • 贪吃蛇C语言代码

    万次阅读 多人点赞 2016-04-18 15:37:59
    贪吃蛇C语言代码贪吃蛇C语言代码 手动贪吃蛇 智能贪吃蛇1.手动贪吃蛇/*蛇越长跑得越快*/ /*作者:SGAFPZ*/ #include #include #include #include //#include #include #include #
  • cmd版贪吃蛇

    万次阅读 2018-03-28 00:21:33
    import java.awt.*; import java.util.LinkedList; import java.util.Scanner; /** * @author aachen0 * @date 2018/3/27 13:56 * IDE:IntelliJ IDEA ...public class SnakeGame { static final int WIDTH = ...
  • C语言贪吃蛇代码

    千次阅读 2016-02-10 19:14:37
    #include #include #include #include #include typedef struct snake { int x, y;//坐标 int direction;//移动方向 上-1 左-2 下-3 右-4 snake * next; }*Msnake; struct food { int x, y;...c
  • C语言贪吃蛇完整代码

    万次阅读 多人点赞 2019-09-07 16:47:21
    #include <stdio.h> #include <stdlib.h> #include <Windows.h>//windows编程头文件 #include <time.h> #include <conio.h>//控制台输入输出头文件 #ifndef __cplusplus ...#define ...
  • java贪吃蛇源码

    万次阅读 多人点赞 2018-05-20 22:23:50
    学习java将近三个月了,一直在琢磨着“万物皆对象”的意义,却总是只知其表不知其意,做完这个java贪吃蛇后才有了那么一点的理解。直接上效果图。 游戏分为了六个类,分别为: Node类:蛇身都是由一个一个节点...
  • java贪吃蛇代码及详解

    2014-11-08 11:00:30
    这是一个完整的java贪吃蛇游戏,有六个文件,主函数启动游戏,另外有一个文件food是食物,worm是贪吃蛇,wormstage是管理贪吃蛇运动的文件
  • 贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码
  • C语言实现贪吃蛇代码

    2018-03-22 11:41:44
    c语言的贪吃蛇。。适合刚学完c语言的同学看看。。。。。
  • 贪吃蛇代码.txt

    2019-06-14 17:05:37
    编程语言使用C/c++,编辑工具啊哈C/C++。很好玩的一款小游戏
  • C#简单的贪吃蛇代码

    2017-08-11 14:18:03
    简单的贪吃蛇程序
  • C++贪吃蛇代码

    2016-02-12 16:57:45
    C++贪吃蛇代码,使用的dev c++测试,
  • c++贪吃蛇代码

    2020-01-22 13:38:02
    c++贪吃蛇代码 #include <windows.h> #include <stdlib.h> #include <conio.h> #include <time.h> #include <cstring> #include <cstdio> #include <iostream> #define N...

空空如也

1 2 3 4 5 ... 20
收藏数 21,765
精华内容 8,706
关键字:

贪吃蛇