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

    2014-01-10 17:39:21
    skyblue_Snake 贪吃蛇
  • 贪吃蛇贪吃蛇贪吃蛇贪吃蛇
  • 贪吃蛇贪吃蛇

    2014-07-07 20:01:35
    贪吃蛇贪吃蛇
  • 小白入门——“贪吃蛇”的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语言】贪吃蛇游戏的实现(一)

    万次阅读 多人点赞 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

    GitHub:https://github.com/testAccount1024/snake

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

     

    好了,让我们进入正题。

    贪吃蛇游戏是一款经典的益智游戏,有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语言写个贪吃蛇游戏

    万次阅读 多人点赞 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语言代码

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

    贪吃蛇C语言代码

    1.手动贪吃蛇

    /*蛇越长跑得越快*/
    /*作者:SGAFPZ*/
    #include <stdio.h>
    #include <windows.h>
    #include <stdlib.h>
    #include <math.h>
    //#include <unistd.h>
    #include <conio.h>
    #include <string.h>
    #include <time.h>
    void food();
    void show();
    void move();
    void turn();
    void check();
    void ini();
    //void calculate();
    //int movable[4] = { 0, 1, 1, 0 };  //数组的下标表示方向,0123分别表示上下左右,下同
    //int distance[4] = { 9999, 9999, 9999, 9999 };
    int  dy[4] = { 0, 1, 0, -1 };
    int  dx[4] = { -1, 0, 1, 0 };
    int sum = 5;  //蛇总长度
    int over = 0;
    int speed;   
    //int foodx, foody;  //食物的坐标
    char map[17][17];
    
    struct snake {
        int x, y;  //身体坐标 
        int dir;  //方向(只有蛇头的方向是有用的) 
    } A[100];
    
    void ini() {  //初始化界面
        speed = 500;
        over = 0;
        sum = 5;
        //movable[0] = 0; movable[1] = 1; movable[2] = 1; movable[3] = 0;
        //distance[0] = 9999; distance[1] = 9999; distance[2] = 9999; distance[3] = 9999;
        int i, j;
        for (i = 0; i < 100; i++) {  //初始化蛇头和蛇身的数据
            A[i].dir = 0;
            A[i].x = 0;
            A[i].y = 0;
        }
        A[0].x = 1; A[0].y = 1;  //地图左上角设置一条长度为5的蛇
        A[1].x = 1; A[1].y = 2;
        A[2].x = 1; A[2].y = 3;
        A[3].x = 1; A[3].y = 4;
        A[4].x = 1; A[4].y = 5; A[4].dir = 1;
        srand(time(0));
        for (i = 0; i < 17; i++) {  //设置地图
            for (j = 0; j < 17; j++) {
                map[i][j] = '*';
            }
        }
        for (i = 1; i < 16; i++) {
            for (j = 1; j < 16; j++) {
                map[i][j] = ' ';
            }
        }
        //map[6][5] = '*'; map[6][6] = '*'; map[6][7] = '*';
        //map[7][5] = '*'; map[7][7] = '*';
        map[A[4].x][A[4].y] = 'H';  //设置蛇头
        for (i = 0; i < sum - 1; i++) {  //设置蛇身
            map[A[i].x][A[i].y] = 'X';
        }
        food();
        //calculate();
    }
    
    
    void show() {  //显示界面 
        int i, j, x, y;
        for (i = 0; i < 17; i++) {  //显示界面
            for (j = 0; j < 17; j++) {
                printf("%c", map[i][j]);
            }
            printf("\n");
        }
        while (1) {
            Sleep(speed);  //界面刷新速度
            turn();
            move();
            if (over) {  //设置蛇死掉后可以进行的操作 
                while (1) {
                    char ch = _getch();
                    if (ch == 113) {  //输入‘q’结束 
                        return;
                    }
                    else if (ch == 114) {  //输入‘r’重新开始 
                        ini();
                        break;
                    }
                }
            }
            system("cls");  //清屏 
            for (i = 0; i < 17; i++) {  //重新显示界面
                for (j = 0; j < 17; j++) {
                    printf("%c", map[i][j]);
                }
                printf("\n");
            }
            //calculate(); //计算并记录蛇头与食物距离
        }
    }
    
    void food() {  //生成食物
        int x, y;
        while (1) {
            x = (int)(15 * rand() / (RAND_MAX + 1.0));  //随机产生一组食物坐标
            y = (int)(15 * rand() / (RAND_MAX + 1.0));
            if (map[x][y] == ' ') {  //如果是空格则在该处生成食物
                map[x][y] = 'O';
                //foodx = x;  //记录食物坐标 
                //foody = y;
                break;
            }
        }
    }
    
    
    void move() {  //蛇移动
        int i, x, y;
        int t = sum;  //t记录当前蛇总长度 
        check();  //移动前检查按当前方向移动一步后的情况
        if (t == sum) {  //没有吃到苹果
            for (i = 0; i < sum - 1; i++) {
                if (i == 0) {  //蛇尾坐标处变成空格,把蛇尾坐标变成前一个蛇身的坐标 
                    map[A[i].x][A[i].y] = ' ';
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                else {  //每个蛇身坐标都变为它前一个蛇身的坐标
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                map[A[i].x][A[i].y] = 'X';  //把地图上蛇身坐标处的字符设置成‘X’
            }
            A[sum - 1].x = A[sum - 1].x + dx[A[sum - 1].dir];  //蛇头按当前方向移动一格 
            A[sum - 1].y = A[sum - 1].y + dy[A[sum - 1].dir];
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
        }
        else {  //吃到苹果(sum会加1)
            map[A[sum - 2].x][A[sum - 2].y] = 'X';  //把地图上原蛇头坐标处的字符设置成‘X’
            A[sum - 1].x = A[sum - 2].x + dx[A[sum - 2].dir];  //新蛇头的坐标是原蛇头沿当前方向移动一格后的坐标 
            A[sum - 1].y = A[sum - 2].y + dy[A[sum - 2].dir];
            A[sum - 1].dir = A[sum - 2].dir;  //新蛇头方向为原蛇头的方向
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
            food();
        }
        /*for(i = 0; i < 4; i++) {  //记录下能走的方向
            x = A[sum - 1].x + dx[i];
            y = A[sum - 1].y + dy[i];
            if(map[x][y] == ' ' || map[x][y] == 'O') {
                movable[i] = 1;  //能走就把对应方向的值设置为1 
            } else {
                if(x != A[0].x || y != A[0].y) {
                    movable[i] = 0;  //不能走就把对应方向的值设置为0 
                } else {
                    movable[i] = 1;
                }
            }
        }*/
    }
    
    void check() {  //检查是否死亡或者吃到食物
        int x, y, i, j;
        x = A[sum - 1].x + dx[A[sum - 1].dir];  //记录按当前方向移动一格后蛇头的坐标 
        y = A[sum - 1].y + dy[A[sum - 1].dir];
        if (map[x][y] == '*' || map[x][y] == 'X') {  //如果地图上该坐标处字符为‘*’或‘X’就死亡 
            if (x != A[0].x || y != A[0].y) {  //蛇尾除外 
                map[8][4] = 'G'; map[8][5] = 'A'; map[8][6] = 'M'; map[8][7] = 'E';  //输出“GAME OVER” 
                map[8][9] = 'O'; map[8][10] = 'V'; map[8][11] = 'E'; map[8][12] = 'R';
                map[8][8] = ' ';
                system("cls");
                for (i = 0; i < 17; i++) {
                    for (j = 0; j < 17; j++) {
                        printf("%c", map[i][j]);
                    }
                    printf("\n");
                }
                printf("Input 'r' to restart\nInput 'q' to quit\n");
                over = 1;
            }
        }
        else if (map[x][y] == 'O') {  //吃到苹果 
            sum++;  //蛇身总长加1 
            speed = ((600 - sum * 20)>100) ? (600 - sum * 20) : 100; //速度加快 
        }
    }
    
    void turn() {  //转弯
        if (_kbhit()) {
            char dir = _getch();  //读取输入的键 
            switch (dir) {  //改变方向 
            case 119: A[sum - 1].dir = (A[sum - 1].dir == 2)?2:0; break;
            case 100: A[sum - 1].dir = (A[sum - 1].dir == 3)?3:1; break;
            case 115: A[sum - 1].dir = (A[sum - 1].dir == 0)?0:2; break;
            case 97: A[sum - 1].dir = (A[sum - 1].dir == 1)?1:3; break;
            }
        }
    }
    
    /*void calculate() {  //计算并记录蛇头与食物距离
        int i = 0, x, y;
        for(i = 0; i < 4; i++) {
            if(movable[i] == 1) {  //如果该方向能走,则记录下沿该方向走一步后与食物的距离 
                x = A[sum - 1].x + dx[i];
                y = A[sum - 1].y + dy[i];
                distance[i] = abs(foodx-x)+abs(foody-y);
            } else {  //如果不能走则把距离设置为9999 
                distance[i] = 9999;
            }
        }
    }*/
    
    int main() {
        printf("'w''s''a''d'控制上下左右\n蛇越长跑得越快~~~\n");
        printf("按任意键开始\n");
        char ch = _getch();
        system("cls");
        ini();
        show();
        return 0;
    }
    

    2.智能贪吃蛇

    虽然说是智能但是可能并没有你想象中那么智能==。
    基本思路是按照上、右、下、左的顺序搜索方向,使得沿该方向前进能够靠近食物,前进过程中遇到障碍会自动绕开,可是不能避免蛇头被蛇身包围的情况。

    /*蛇越长跑得越快*/
    /*蛇能自己找食物*/
    /*作者:SGAFPZ*/
    #include <stdio.h>
    #include <windows.h>
    #include <stdlib.h>
    #include <math.h>
    //#include <unistd.h>
    #include <conio.h>
    #include <string.h>
    #include <time.h>
    void food();
    void show();
    void move();
    void turn();
    void check();
    void ini();
    void calculate();
    int movable[4] = { 0, 1, 1, 0 };  //数组的下标表示方向,0123分别表示上下左右,下同
    int distance[4] = { 9999, 9999, 9999, 9999 };
    int  dy[4] = { 0, 1, 0, -1 };
    int  dx[4] = { -1, 0, 1, 0 };
    int sum = 5;  //蛇总长度
    int over = 0;
    int speed;   
    int foodx, foody;  //食物的坐标
    char map[17][17];
    
    struct snake {
        int x, y;  //身体坐标 
        int dir;  //方向(只有蛇头的方向是有用的) 
    } A[100];
    
    void ini() {  //初始化界面
        speed = 500;
        over = 0;
        sum = 5;
        movable[0] = 0; movable[1] = 1; movable[2] = 1; movable[3] = 0;
        distance[0] = 9999; distance[1] = 9999; distance[2] = 9999; distance[3] = 9999;
        int i, j;
        for (i = 0; i < 100; i++) {  //初始化蛇头和蛇身的数据
            A[i].dir = 0;
            A[i].x = 0;
            A[i].y = 0;
        }
        A[0].x = 1; A[0].y = 1;  //地图左上角设置一条长度为5的蛇
        A[1].x = 1; A[1].y = 2;
        A[2].x = 1; A[2].y = 3;
        A[3].x = 1; A[3].y = 4;
        A[4].x = 1; A[4].y = 5; A[4].dir = 1;
        srand(time(0));
        for (i = 0; i < 17; i++) {  //设置地图
            for (j = 0; j < 17; j++) {
                map[i][j] = '*';
            }
        }
        for (i = 1; i < 16; i++) {
            for (j = 1; j < 16; j++) {
                map[i][j] = ' ';
            }
        }
        //map[6][5] = '*'; map[6][6] = '*'; map[6][7] = '*';
        //map[7][5] = '*'; map[7][7] = '*';
        map[A[4].x][A[4].y] = 'H';  //设置蛇头
        for (i = 0; i < sum - 1; i++) {  //设置蛇身
            map[A[i].x][A[i].y] = 'X';
        }
        food();
        calculate();
    }
    
    
    void show() {  //显示界面 
        int i, j, x, y;
        for (i = 0; i < 17; i++) {  //显示界面
            for (j = 0; j < 17; j++) {
                printf("%c", map[i][j]);
            }
            printf("\n");
        }
        while (1) {
            Sleep(speed);  //界面刷新速度
            turn();
            move();
            if (over) {  //设置蛇死掉后可以进行的操作 
                while (1) {
                    char ch = _getch();
                    if (ch == 113) {  //输入‘q’结束 
                        return;
                    }
                    else if (ch == 114) {  //输入‘r’重新开始 
                        ini();
                        break;
                    }
                }
            }
            system("cls");  //清屏 
            for (i = 0; i < 17; i++) {  //重新显示界面
                for (j = 0; j < 17; j++) {
                    printf("%c", map[i][j]);
                }
                printf("\n");
            }
            calculate(); //计算并记录蛇头与食物距离
        }
    }
    
    void food() {  //生成食物
        int x, y;
        while (1) {
            x = (int)(15 * rand() / (RAND_MAX + 1.0));  //随机产生一组食物坐标
            y = (int)(15 * rand() / (RAND_MAX + 1.0));
            if (map[x][y] == ' ') {  //如果是空格则在该处生成食物
                map[x][y] = 'O';
                foodx = x;  //记录食物坐标 
                foody = y;
                break;
            }
        }
    }
    
    
    void move() {  //蛇移动
        int i, x, y;
        int t = sum;  //t记录当前蛇总长度 
        check();  //移动前检查按当前方向移动一步后的情况
        if (t == sum) {  //没有吃到苹果
            for (i = 0; i < sum - 1; i++) {
                if (i == 0) {  //蛇尾坐标处变成空格,把蛇尾坐标变成前一个蛇身的坐标 
                    map[A[i].x][A[i].y] = ' ';
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                else {  //每个蛇身坐标都变为它前一个蛇身的坐标
                    A[i].x = A[i + 1].x;
                    A[i].y = A[i + 1].y;
                }
                map[A[i].x][A[i].y] = 'X';  //把地图上蛇身坐标处的字符设置成‘X’
            }
            A[sum - 1].x = A[sum - 1].x + dx[A[sum - 1].dir];  //蛇头按当前方向移动一格 
            A[sum - 1].y = A[sum - 1].y + dy[A[sum - 1].dir];
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
        }
        else {  //吃到苹果(sum会加1)
            map[A[sum - 2].x][A[sum - 2].y] = 'X';  //把地图上原蛇头坐标处的字符设置成‘X’
            A[sum - 1].x = A[sum - 2].x + dx[A[sum - 2].dir];  //新蛇头的坐标是原蛇头沿当前方向移动一格后的坐标 
            A[sum - 1].y = A[sum - 2].y + dy[A[sum - 2].dir];
            A[sum - 1].dir = A[sum - 2].dir;  //新蛇头方向为原蛇头的方向
            map[A[sum - 1].x][A[sum - 1].y] = 'H';  //把地图上蛇头坐标处的字符设置成‘H’
            food();
        }
        for(i = 0; i < 4; i++) {  //记录下能走的方向
            x = A[sum - 1].x + dx[i];
            y = A[sum - 1].y + dy[i];
            if(map[x][y] == ' ' || map[x][y] == 'O') {
                movable[i] = 1;  //能走就把对应方向的值设置为1 
            } else {
                if(x != A[0].x || y != A[0].y) {
                    movable[i] = 0;  //不能走就把对应方向的值设置为0 
                } else {
                    movable[i] = 1;
                }
            }
        }
    }
    
    void check() {  //检查是否死亡或者吃到食物
        int x, y, i, j;
        x = A[sum - 1].x + dx[A[sum - 1].dir];  //记录按当前方向移动一格后蛇头的坐标 
        y = A[sum - 1].y + dy[A[sum - 1].dir];
        if (map[x][y] == '*' || map[x][y] == 'X') {  //如果地图上该坐标处字符为‘*’或‘X’就死亡 
            if (x != A[0].x || y != A[0].y) {  //蛇尾除外 
                map[8][4] = 'G'; map[8][5] = 'A'; map[8][6] = 'M'; map[8][7] = 'E';  //输出“GAME OVER” 
                map[8][9] = 'O'; map[8][10] = 'V'; map[8][11] = 'E'; map[8][12] = 'R';
                map[8][8] = ' ';
                system("cls");
                for (i = 0; i < 17; i++) {
                    for (j = 0; j < 17; j++) {
                        printf("%c", map[i][j]);
                    }
                    printf("\n");
                }
                printf("Input 'r' to restart\nInput 'q' to quit\n");
                over = 1;
            }
        }
        else if (map[x][y] == 'O') {  //吃到苹果 
            sum++;  //蛇身总长加1 
            speed = ((600 - sum * 20)>100) ? (600 - sum * 20) : 100; //速度加快 
        }
    }
    
    void turn() {  //转弯
        int i, k = 0;
        for(i = 1; i < 4; i++) {  //找到走一步后离食物距离最短的方向
            if(distance[k] > distance[i]) {
                k = i;
            }
        }
        switch (k) {  //把把蛇头方向改为该方向 
            case 0: A[sum - 1].dir = (A[sum - 1].dir == 2)?2:0; break;
            case 1: A[sum - 1].dir = (A[sum - 1].dir == 3)?3:1; break;
            case 2: A[sum - 1].dir = (A[sum - 1].dir == 0)?0:2; break;
            case 3: A[sum - 1].dir = (A[sum - 1].dir == 1)?1:3; break;
        }
    }
    
    void calculate() {  //计算并记录蛇头与食物距离
        int i = 0, x, y;
        for(i = 0; i < 4; i++) {
            if(movable[i] == 1) {  //如果该方向能走,则记录下沿该方向走一步后与食物的距离 
                x = A[sum - 1].x + dx[i];
                y = A[sum - 1].y + dy[i];
                distance[i] = abs(foodx-x)+abs(foody-y);
            } else {  //如果不能走则把距离设置为9999 
                distance[i] = 9999;
            }
        }
    }
    
    int main() {
        printf("你只需要静静地看着它跑\n");
        printf("按任意键开始\n");
        char ch = _getch();
        system("cls");
        ini();
        show();
        return 0;
    }
    
    展开全文
  • 贪吃蛇游戏

    2017-03-26 22:53:09
    贪吃蛇
  • c++贪吃蛇贪吃蛇.zip

    2020-03-28 18:18:03
    c++贪吃蛇
  • 贪吃蛇C语言

    2018-01-13 14:35:05
    贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇贪吃蛇
  • DEMO 贪吃蛇贪吃蛇

    2010-01-21 16:50:21
    DEMO 贪吃蛇贪吃蛇DEMO 贪吃蛇贪吃蛇DEMO 贪吃蛇贪吃蛇
  • 贪吃蛇游戏 贪吃蛇

    2010-01-05 12:27:56
    贪吃蛇游戏 贪吃蛇贪吃蛇游戏 贪吃蛇贪吃蛇游戏 贪吃蛇
  • 贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码贪吃蛇代码
  • 贪吃蛇源码

    2013-06-08 13:53:51
    贪吃蛇
  • 贪吃蛇源码版

    2017-07-08 10:38:49
    贪吃蛇
  • c语言 贪吃蛇贪吃蛇 c语言贪吃蛇,c语言 贪吃蛇贪吃蛇 c语言贪吃蛇,c语言 贪吃蛇贪吃蛇 c语言贪吃蛇
  • c++ 贪吃蛇
  • c++贪吃蛇

    2018-03-27 09:41:45
    c++贪吃蛇c++贪吃蛇c++贪吃蛇c++贪吃蛇c++贪吃蛇c++贪吃蛇c++贪吃蛇
  • 贪吃蛇Python

    2018-04-14 11:25:44
    贪吃蛇Python 贪吃蛇Python 贪吃蛇Python 贪吃蛇Python
  • Snake 贪吃蛇

    2018-03-08 10:47:08
    贪吃蛇 java 贪吃蛇 java 贪吃蛇 java 贪吃蛇 java 贪吃蛇 java
  • 汇编贪吃蛇汇编贪吃蛇汇编贪吃蛇汇编贪吃蛇汇编贪吃蛇汇编贪吃蛇
  • 贪吃蛇源码&&贪吃蛇的图片
  • c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的贪吃蛇游戏c#做的...
  • Flash 贪吃蛇

    2018-08-02 08:50:56
    flash贪吃蛇
  • C语言 贪吃蛇

    万次阅读 多人点赞 2018-09-16 14:55:01
    C语言 贪吃蛇 一、简述 记--用C语言简单实现贪吃蛇小游戏。 二、效果 使用上下左右方向键控制方向,按ESC退出游戏。 三、代码结构 四、源代码 #include <stdio.h> //标准输入输出函数库 #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,025
精华内容 9,210
关键字:

贪吃蛇