<address id="9zrpt"></address>

      c语言贪吃蛇

      c语言贪吃蛇

      平台用户的互动中精选与c语言贪吃蛇相关的:1、c语言 贪吃蛇 程序 2、C语言的贪吃蛇源代码 3、C语言编写贪吃蛇需要用哪些函数?? 4、贪吃蛇怎么用C语言编写 5、c语言贪吃蛇怎么让蛇自己动起来啊? 6、用c语言编写的贪食蛇游戏 7、求C语言贪吃蛇代码能在DEV上运行通过的贪吃蛇,不要TC上的啊我们老师上课给在DEV我们运行了一次 8、求 贪吃蛇C语言代码 9、c语言贪吃蛇的速度控制程序怎么编 10、c语言贪吃蛇源代码怎么用?
      c语言贪吃蛇
      平台用户 2018-06-06 16:49:07

      下面是精选平台用户互动时的最佳讨论

      匿名
      匿名


      匿名:c语言 贪吃蛇 程序

      主要内容: 设计并实现一个类似于手机游戏“贪吃蛇”的程序。一条蛇在密闭的围墙内运动,通过键盘上的四个箭头键控制蛇向上下左右四个方向移动。在围墙内随机出现一个食物,蛇头撞到食物,则表示食物被蛇吃掉,这时蛇的身体长一节,同时加分,接着又出现食物... 主要内容:
      设计并实现一个类似于手机游戏“贪吃蛇”的程序。一条蛇在密闭的围墙内运动,通过键盘上的四个箭头键控制蛇向上下左右四个方向移动。在围墙内随机出现一个食物,蛇头撞到食物,则表示食物被蛇吃掉,这时蛇的身体长一节,同时加分,接着又出现食物,等待被蛇吃掉。如果蛇在移动过程中,撞到墙壁、身体交叉或蛇头撞到自己的身体则游戏结束。

      基本要求:
      课程设计中要求掌握和实现如下功能和方法:
      1、掌握基本绘图原理和图形函数的使用方法;
      2、掌握游戏中基本的动画实现方法;
      3、掌握键盘响应的主要函数和方法;
      4、了解游戏中碰撞检测的方法;
      5、实现游戏加速功能,包括加速键功能和逐步加速功能;

      扩展要求:
      1、 实现随机出现障碍物功能;
      2、 实现迷宫式围墙;
      3、 实现过关式的游戏方式;

      文档要求:
      系统完成后,要提交格式规范的文档,包含如下内容:
      1、 程序的功能;
      2、 游戏界面设计和图形函数的使用;
      3、 整体设计思路;
      4、 程序中的数据结构;
      5、 程序中碰撞检测的实现方法;
      6、 程序核心算法的流程图;
      7、 程序改进的设想;
      8、 总结。
      1、 程序的功能
      设计并实现一个类似于手机游戏“贪吃蛇”的程序。一条蛇在密闭的围墙内运动,通过键盘上的四个箭头键控制蛇向上下左右四个方向移动。在围墙内随机出现一个食物,蛇头撞到食物,则表示食物被蛇吃掉,这时蛇的身体长一节,同时加分,接着又出现食物,等待被蛇吃掉。如果蛇在移动过程中,撞到墙壁或蛇头撞到自己的身体则游戏结束。

      2、 游戏界面设计和图形函数的使用
      /* 参考指导书中1.3.1和画界面函数部分 */
      3、 整体设计思路
      /* 参考指导书中1.3.2部分 */
      4、 程序中的数据结构
      /* 参考指导书中1.3.2部分 */
      5、 程序中碰撞检测的实现方法
      /* 参考指导书中游戏具体过程函数部分 */
      6、 程序核心算法的流程图
      /* 参考别人的 囧 */
      7、 程序改进的设想
      /* 自己瞎琢磨吧! */
      8、 总结
      通过本次课程设计,强化了我对C语言相关知识的掌握,学会了基本的游戏编程方法,加深了我复杂程序设计的能力,初步掌握了高级语言程序调试技能 ......(此处删节三百字,你就随便编吧!)
      下面的解答已被5107人点赞
      /* 贪吃蛇程序 by champking */

      #define N 200

      #include <graphics.h>
      #include <stdlib.h>
      #include <dos.h>

      #define LEFT 0x4b00
      #define RIGHT 0x4d00
      #define DOWN 0x5000
      #define UP 0x4800
      #define ESC 0x011b

      int i,key;
      int score = 0;/*得分*/
      int gamespeed = 100000;/*游戏速度自己调整*/

      struct Food
      {
      int x;/*食物的横坐标*/
      int y;/*食物的纵坐标*/
      int yes;/*判断是否要出现食物的变量*/
      }food;/*食物的结构体*/

      struct Snake
      {
      int x[N];
      int y[N];
      int node;/*蛇的节数*/
      int direction;/*蛇移动方向*/
      int life;/* 蛇的生命,0活着,1死亡*/
      }snake;

      void Init(void);/*图形驱动*/
      void Close(void);/*图形结束*/
      void DrawK(void);/*开始画面*/
      void GameOver(void);/*结束游戏*/
      void GamePlay(void);/*玩游戏具体过程*/
      void PrScore(void);/*输出成绩*/

      /*主函数*/
      void main(void)
      {
      Init();/*图形驱动*/
      DrawK();/*开始画面*/
      GamePlay();/*玩游戏具体过程*/
      Close();/*图形结束*/
      }

      /*图形驱动*/
      void Init(void)
      {
      int gd = DETECT, gm;
      initgraph(&gd, &gm, "c:\\tc");
      cleardevice();
      }
      /*开始画面,左上角坐标为(50,40),右下角坐标为(610,460)的围墙*/
      void DrawK(void)
      {
      /*setbkcolor(LIGHTGREEN);*/
      setcolor(11);
      setlinestyle(SOLID_LINE, 0, THICK_WIDTH);/*设置线型*/

      for(i = 50; i <= 600; i += 10)/*画围墙*/
      {
      rectangle(i, 40, i + 10, 49); /*上边*/
      rectangle(i, 451, i + 10, 460);/*下边*/
      }

      for(i = 40; i <= 450; i += 10)
      {
      rectangle(50, i, 59, i + 10); /*左边*/
      rectangle(601, i, 610, i + 10);/*右边*/
      }
      }
      /*玩游戏具体过程*/
      void GamePlay(void)
      {
      randomize();/*随机数发生器*/
      food.yes = 1;/*1表示需要出现新食物,0表示已经存在食物*/
      snake.life = 0;/*活着*/
      snake.direction = 1;/*方向往右*/
      snake.x[0] = 100; snake.y[0] = 100;/*蛇头*/
      snake.x[1] = 110; snake.y[1] = 100;
      snake.node = 2;/*节数*/
      PrScore();/*输出得分*/

      while(1)/*可以重复玩游戏,压ESC键结束*/
      {
      while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/
      {
      if(food.yes == 1)/*需要出现新食物*/
      {
      food.x = rand() % 400 + 60;
      food.y = rand() % 350 + 60;

      while(food.x % 10 != 0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
      food.x++;
      while(food.y % 10 != 0)
      food.y++;
      food.yes = 0;/*画面上有食物了*/
      }

      if(food.yes == 0)/*画面上有食物了就要显示*/
      {
      setcolor(GREEN);
      rectangle(food.x, food.y, food.x + 10, food.y - 10);
      }

      for(i = snake.node - 1; i > 0; i--)/*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/
      {
      snake.x[i] = snake.x[i-1];
      snake.y[i] = snake.y[i-1];
      }

      /*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
      switch(snake.direction)
      {
      case 1: snake.x[0] += 10; break;
      case 2: snake.x[0] -= 10; break;
      case 3: snake.y[0] -= 10; break;
      case 4: snake.y[0] += 10; break;
      }

      for(i = 3; i < snake.node; i++)/*从蛇的第四节开始判断是否撞到自己了,因为蛇头为两节,第三节不可能拐过来*/
      {
      if(snake.x[i] == snake.x[0] && snake.y[i] == snake.y[0])
      {
      GameOver();/*显示失败*/
      snake.life = 1;
      break;
      }
      }

      if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<55||
      snake.y[0]>455)/*蛇是否撞到墙壁*/
      {
      GameOver();/*本次游戏结束*/
      snake.life=1; /*蛇死*/
      }

      if(snake.life == 1)/*以上两种判断以后,如果蛇死就跳出内循环,重新开始*/
      break;

      if(snake.x[0] == food.x && snake.y[0] == food.y)/*吃到食物以后*/
      {
      setcolor(0);/*把画面上的食物东西去掉*/
      rectangle(food.x, food.y, food.x + 10, food.y - 10);
      snake.x[snake.node] =- 20; snake.y[snake.node] =- 20;
      /*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
      snake.node++;/*蛇的身体长一节*/
      food.yes = 1;/*画面上需要出现新的食物*/
      score += 10;
      PrScore();/*输出新得分*/
      }

      setcolor(4);/*画出蛇*/

      for(i = 0; i < snake.node; i++)
      rectangle(snake.x[i], snake.y[i], snake.x[i] + 10,
      snake.y[i] - 10);

      delay(gamespeed);

      setcolor(0);/*用黑色去除蛇的的最后一节*/
      rectangle(snake.x[snake.node-1], snake.y[snake.node-1],
      snake.x[snake.node-1] + 10, snake.y[snake.node - 1] - 10);
      } /*endwhile(!kbhit)*/

      if(snake.life == 1)/*如果蛇死就跳出循环*/
      break;

      key = bioskey(0);/*接收按键*/

      if(key == ESC)/*按ESC键退出*/
      break;
      else
      if(key == UP&&snake.direction!=4)
      /*判断是否往相反的方向移动*/
      snake.direction=3;
      else
      if(key == RIGHT &&snake.direction != 2)
      snake.direction=1;
      else
      if(key == LEFT && snake.direction != 1)
      snake.direction = 2;
      else
      if(key == DOWN && snake.direction != 3)
      snake.direction = 4;
      }/*endwhile(1)*/
      }

      /*游戏结束*/
      void GameOver(void)
      {
      cleardevice();
      PrScore();
      setcolor(RED);
      settextstyle(0, 0, 4);
      outtextxy(200, 200, "GAME OVER");
      getch();
      }

      /*输出成绩*/
      void PrScore(void)
      {
      char str[10];
      setfillstyle(SOLID_FILL, YELLOW);
      bar(50, 15, 220, 35);
      setcolor(6);
      settextstyle(0,0,2);
      sprintf(str, "score:%d", score);
      outtextxy(55, 20, str);
      }

      /*图形结束*/
      void Close(void)
      {
      getch();
      closegraph();
      }
      
      最后一次编辑时间 推荐于2017-09-18 05:24:38
      7302159
      7302159


      7302159:C语言的贪吃蛇源代码

      可以的话追加55分。。我最后的分数~~希望以前自己写过程序的朋友发个给我,时间不多了 我有用!! 邮箱471929895@qq.com 百度很多的那种不用发来了~~
      下面的解答已被4014人点赞

       
      //******友情提示:如想速度快点,请改小_sleep(500)函数中参数*****  

      #include <stdio.h>  
      #include <stdlib.h>  
      #include <conio.h>  
      #include <string.h>  
      #include <time.h>  
      const int H = 8;   //地图的高  
      const int L = 16;  //地图的长  
      char GameMap[H][L];   //游戏地图  
      int  key;  //按键保存  
      int  sum = 1, over = 0;  //蛇的长度, 游戏结束(自吃或碰墙)  
      int  dx[4] = {0, 0, -1, 1};  //左、右、上、下的方向  
      int  dy[4] = {-1, 1, 0, 0};  
      struct Snake   //蛇的每个节点的数据类型  
      {  
       int x, y;  //左边位置  
       int now;   //保存当前节点的方向, 0,1,2,3分别为左右上下  
      }Snake[H*L];  
      const char Shead = '@';  //蛇头  
      const char Sbody = '#';  //蛇身  
      const char Sfood = '*';  //食物  
      const char Snode = '.';  //'.'在地图上标示为空  
      void Initial();  //地图的初始化  
      void Create_Food(); //在地图上随机产生食物  
      void Show();   //刷新显示地图  
      void Button();  //取出按键,并判断方向  
      void Move();   //蛇的移动  
      void Check_Border();  //检查蛇头是否越界  
      void Check_Head(int x, int y);   //检查蛇头移动后的位置情况  
      int main()   
      {  
       Initial();  
       Show();  
       return 0;  
      }  
      void Initial()  //地图的初始化  
      {  
       int i, j;  
       int hx, hy;  
       system("title 贪吃蛇");  //控制台的标题  
       memset(GameMap, '.', sizeof(GameMap));  //初始化地图全部为空'.'  
       system("cls");  
       srand(time(0));   //随机种子  
       hx = rand()%H;    //产生蛇头  
       hy = rand()%L;  
       GameMap[hx][hy] = Shead;  
       Snake[0].x = hx;  Snake[0].y = hy;  
       Snake[0].now = -1;  
       Create_Food();   //随机产生食物  
       for(i = 0; i < H; i++)   //地图显示  
       {   
        for(j = 0; j < L; j++)  
         printf("%c", GameMap[i][j]);  
        printf("\n");  
       }  
           
       printf("\n小小C语言贪吃蛇\n");  
       printf("按任意方向键开始游戏\n");  
          
       getch();   //先接受一个按键,使蛇开始往该方向走  
       Button();  //取出按键,并判断方向  
      }  
      void Create_Food()  //在地图上随机产生食物  
      {  
       int fx, fy;  
       while(1)  
       {  
        fx = rand()%H;  
           fy = rand()%L;  
           
        if(GameMap[fx][fy] == '.')  //不能出现在蛇所占有的位置  
        {   
         GameMap[fx][fy] = Sfood;  
            break;  
        }  
       }  
      }  
      void Show()  //刷新显示地图  
      {  
       int i, j;  
       while(1)  
       {    
        _sleep(500); //延迟半秒(1000为1s),即每半秒刷新一次地图  
        Button();   //先判断按键在移动  
        Move();  
        if(over)  //自吃或碰墙即游戏结束  
        {   
         printf("\n**游戏结束**\n");  
         printf("     >_<\n");  
         getchar();  
            break;  
        }  
        system("cls");   //清空地图再显示刷新吼的地图  
        for(i = 0; i < H; i++)   
        {   
         for(j = 0; j < L; j++)  
          printf("%c", GameMap[i][j]);  
         printf("\n");  
        }  
           
        printf("\n小小C语言贪吃蛇\n");  
        printf("按任意方向键开始游戏\n");  
       }  
      }  
      void Button()  //取出按键,并判断方向  
      {  
       if(kbhit() != 0) //检查当前是否有键盘输入,若有则返回一个非0值,否则返回0  
       {   
        while(kbhit() != 0)  //可能存在多个按键,要全部取完,以最后一个为主  
            key = getch(); //将按键从控制台中取出并保存到key中  
        switch(key)  
        {   //左  
         case 75:  Snake[0].now = 0;  
                break;  
                  //右  
                  case 77:  Snake[0].now = 1;       
                break;  
                  //上  
         case 72:  Snake[0].now = 2;  
                break;  
                  //下  
         case 80:  Snake[0].now = 3;  
                break;  
        }  
       }  
      }  
      void Move()   //蛇的移动  
      {  
       int i, x, y;  
          int t = sum;  //保存当前蛇的长度  
       //记录当前蛇头的位置,并设置为空,蛇头先移动  
       x = Snake[0].x;  y = Snake[0].y;  GameMap[x][y] = '.';  
       Snake[0].x = Snake[0].x + dx[ Snake[0].now ];  
       Snake[0].y = Snake[0].y + dy[ Snake[0].now ];  
       Check_Border();   //蛇头是否越界  
       Check_Head(x, y);  //蛇头移动后的位置情况,参数为: 蛇头的开始位置  
       if(sum == t)  //未吃到食物即蛇身移动哦  
          for(i = 1; i < sum; i++)  //要从蛇尾节点向前移动哦,前一个节点作为参照  
       {  
        if(i == 1)   //尾节点设置为空再移动  
         GameMap[ Snake[i].x ][ Snake[i].y ] = '.';  
           
        if(i == sum-1)  //为蛇头后面的蛇身节点,特殊处理  
        {  
         Snake[i].x = x;  
               Snake[i].y = y;  
            Snake[i].now = Snake[0].now;  
        }  
        else   //其他蛇身即走到前一个蛇身位置  
        {  
         Snake[i].x = Snake[i+1].x;  
               Snake[i].y = Snake[i+1].y;  
            Snake[i].now = Snake[i+1].now;  
        }  
            
        GameMap[ Snake[i].x ][ Snake[i].y ] = '#'; //移动后要置为'#'蛇身   
       }  
      }  
      void Check_Border()  //检查蛇头是否越界  
      {  
       if(Snake[0].x < 0 || Snake[0].x >= H  
       || Snake[0].y < 0 || Snake[0].y >= L)  
           over = 1;  
      }  
      void Check_Head(int x, int y)  //检查蛇头移动后的位置情况  
      {  
          
       if(GameMap[ Snake[0].x ][ Snake[0].y ] == '.')  //为空  
        GameMap[ Snake[0].x ][ Snake[0].y ] = '@';  
       else 
        if(GameMap[ Snake[0].x ][ Snake[0].y ] == '*')  //为食物  
        {  
         GameMap[ Snake[0].x ][ Snake[0].y ] = '@';    
         Snake[sum].x = x;   //新增加的蛇身为蛇头后面的那个  
            Snake[sum].y = y;  
            Snake[sum].now = Snake[0].now;  
               GameMap[ Snake[sum].x ][ Snake[sum].y ] = '#';   
         sum++;  
         Create_Food();  //食物吃完了马上再产生一个食物  
        }  
        else 
         over = 1;  
      }

      最后一次编辑时间 推荐于2017-11-17 20:26:41
      平凡的白I光
      平凡的白I光


      平凡的白I光:C语言编写贪吃蛇需要用哪些函数??

      不要源代码,不要思路,只要告诉我需要用到哪些知道就行了,谢谢了。
      下面的解答已被9171人点赞
      先写个
      #include <stdio.h>

      int main(void)
      {
      return 0;
      }
      然后考虑接下来该怎么填这个空
      你的控制:左右上下
      状态:整条蛇的全体所占坐标排成一个向量,蛇当前方向
      矩形坐标范围
      障碍坐标
      死亡条件:当蛇头超过矩形坐标范围或者撞击障碍、蛇身
      加长条件:吃到食物的时候,蛇全身其他坐标不变,只是尾巴上长了一个。
      定时:每当定时时间到,尾巴上的蛇身那一格消失,其他坐标不变,多了一个格,为头部坐标+方向,此为新的蛇头。
      再组织成一个程序就可以了
      echo '++++++++++[>++++++++++[>+<-]<-]>>-.+++++++.---------.++++++++.>>++++[<++++[<+>-]>-]<<+.-------..' | sed '
      s/\([-+]\)/\1\1*p;/g
      s/</p--;/g
      s/>/p++;/g
      s/\./putchar(*p);/g
      s/\[/while(*p){/g
      s/\]/}/g
      1s/^/main(){char*p=calloc(1,6);/
      $s/$/}/
      /./!d'|gcc -xc - 2>/dev/null&&./a.out
      最后一次编辑时间 2015-07-04
      °迷岛0RM
      °迷岛0RM


      °迷岛0RM:贪吃蛇怎么用C语言编写

      下面的解答已被2383人点赞
      #include <stdio.h>
      #include <graphics.h>
      #include <stdlib.h>
      #include <dos.h> /*引用的库函数*/
      #define LEFT 0x4b00
      #define RIGHT 0x4d00
      #define DOWN 0x5000
      #define UP 0x4800
      #define ESC 0x011b/*宏定义键名*/
      #define N 200
      int i,key;
      int level;/*游戏等级*/
      int score=0;/*得分*/
      int gamespeed;/*游戏速度*/
      struct Food
      {
      int x;/*食物的横坐标*/
      int y;/*食物的纵坐标*/
      int yes;/*判断是否要出现食物的变量*/
      }food;/*食物的结构体*/
      struct Snake
      {
      int x[N];
      int y[N];
      int node;/*蛇的节数*/
      int direction;/*蛇移动方向*/
      int life;/* 蛇的生命,0活着,1死亡*/
      }snake;/*蛇的结构体*/
      void Choicelevle(void);/*选择游戏等级*/
      void Init(void);/*图形驱动*/
      void Close(void);/*图形结束*/
      void DRAW(void);/*游戏区域*/
      void GameOver(void);/*结束游戏*/
      void GamePlay(void);/*玩游戏具体过程*/
      void PrScore(void);/*输出成绩*/
      /*主函数*/
      void main(void)
      {
      Init();/*图形驱动*/
      Choicelevle();/*选择游戏等级*/
      DRAW();/*游戏区域*/
      GamePlay();/*玩游戏具体过程*/
      Close();/*图形结束*/
      }

      /*图形驱动*/
      void Init(void)
      {
      int gd=DETECT,gm;
      initgraph(&gd,&gm,"\\turboc2"); /*初始化图形系统*/
      cleardevice(); /*清除图形界面*/
      }
      /*选择游戏等级*/
      void Choicelevle(void)
      {char name[20];setcolor(YELLOW);settextstyle(0,0,6);outtextxy(150,150,"Snake");setcolor(GREEN);settextstyle(0,0,1);outtextxy(200,250,"please put in your English name:");outtextxy(200,270,"Choice levle from 1-9.");outtextxy(300,320,"name:yangzilong");/*制作人姓名*/outtextxy(300,350,"number:0902060226");/*制作人学号*/outtextxy(300,380,"class:computer science 0602");/*制作人班级*/getch();printf("please putin your name:");gets(name);printf("please choice levle:");scanf("%d",&level);gamespeed=100000-400*level-300*level*level;if(level>9||level<1){cleardevice(); /*清除图形界面*/setcolor(YELLOW); /*设置字体颜色*/settextstyle(0,0,2); /*设置字体类型*/outtextxy(150,200,"level input error"); /*显示文本*/getch();level=1;}
      }
      void DRAW(void)
      {cleardevice(); /*清屏*/setcolor(2);setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/rectangle(45,45,465,325);}
      /*玩游戏具体过程*/
      void GamePlay(void)
      {setcolor(5);setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/randomize();/*随机数发生器*/food.yes=1;/*1表示需要出现新食物,0表示已经存在食物*/snake.life=0;/*活着*/snake.direction=1;/*方向往右*/snake.x[0]=320;snake.y[0]=240;/*蛇头*/snake.x[1]=330;snake.y[1]=240; /*蛇的第二节位置*/snake.node=3;/*节数*/PrScore();/*输出得分*/while(1)/*可以重复玩游戏,压ESC键结束*/{while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/{if(food.yes==1)/*需要出现新食物*/{food.x=rand()%360+70;food.y=rand()%250+60;while(food.x%10!=0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/food.x++;while(food.y%10!=0)food.y++;food.yes=0;/*画面上有食物了*/}
      if(food.yes==0)/*画面上有食物了就要显示*/
      {
      setcolor(GREEN);
      rectangle(food.x,food.y,food.x+10,food.y-10);
      }
      for(i=snake.node-1;i>0;i--)/*蛇的每个环节往前移动*/
      {
      snake.x[i]=snake.x[i-1];
      snake.y[i]=snake.y[i-1];
      }
      /*1,2,3,4表示右,左,上,下四个方向,通过这个控制来移动蛇头*/
      switch(snake.direction)
      {
      case 1: snake.x[0]+=10;break;
      case 2: snake.x[0]-=10;break;
      case 3: snake.y[0]-=10;break;
      case 4: snake.y[0]+=10;break;
      }
      for(i=3;i<snake.node;i++)/*从蛇的第四节开始判断是否撞到自己了,因为蛇头为两节,第三节不可能拐过来*/
      {
      if(snake.x[i]==snake.x[0]&&snake.y[i]==snake.y[0])
      {
      GameOver();/*显示失败*/
      snake.life=1; /*蛇死*/
      break;
      }
      }

      /*如果蛇头碰到墙壁,蛇头从对面墙出来*/
      if(snake.x[0]<50)
      {snake.x[0]=450;/*如果蛇头越过左边界,则从右边界进入*/snake.y[0]=snake.y[0];/*纵坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
      {
      setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
      bar(50,55,455,315);/*bar是表示填充的范围的函数*/
      }
      }
      else
      if(snake.x[0]>450)
      {snake.x[0]=50;/*如果蛇头越过右边界,则蛇头从左边界进入*/snake.y[0]=snake.y[0];/*纵坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
      {
      setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
      bar(50,55,455,315);/*bar是表示填充的范围的函数*/
      }
      }
      else
      if(snake.y[0]<60)
      {snake.y[0]=320;/*如果蛇头越过上边界,则从下边界进入*/snake.x[0]=snake.x[0];/*横坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
      {
      setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
      bar(50,55,455,315);/*bar是表示填充的范围的函数*/
      }
      }
      else
      if(snake.y[0]>320)
      {snake.y[0]=60;/*如果蛇头越过下边界,则从上边界进入*/snake.x[0]=snake.x[0];/*横坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
      {
      setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
      bar(50,55,455,315);/*bar是表示填充的范围的函数*/
      }
      }
      if(snake.life==1)/*如果蛇死就跳出内循环,重新开始*/
      break;
      if(snake.x[0]==food.x&&snake.y[0]==food.y)/*吃到食物以后*/
      {
      setcolor(0);/*把画面上的食物东西去掉*/
      rectangle(food.x,food.y,food.x+10,food.y-10); /*用当前线型和颜色画一矩形*/
      snake.x[snake.node]=-20;snake.y[snake.node]=-20;
      /*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
      snake.node++;/*蛇的身体长一节*/
      food.yes=1;/*画面上需要出现新的食物*/
      score+=10; /*每吃掉一食物,得分累加10分*/
      if(score%100==0)
      {level++;gamespeed=100000-400*level-300*level*level;/*每吃掉10食物提升一级,速度加快*/PrScore();/*输出新得分*/setcolor(YELLOW); /*设置字体颜色*/settextstyle(0,0,4); /*设置字体类型*/outtextxy(150,200,"LEVEL UP"); /*显示文本*/if(level==10){level=1,gamespeed=100000-400*level-300*level*level;}
      delay(6000000);
      delay(6000000);
      delay(6000000);
      delay(6000000);
      delay(6000000);
      delay(6000000);
      delay(6000000);
      bar(50,55,455,315);/*bar是表示填充的范围的函数*/
      }
      PrScore();/*输出新得分*/
      }
      setcolor(4);/*画出蛇*/
      for(i=0;i<snake.node;i++)
      rectangle(snake.x[i],snake.y[i],snake.x[i]+10,
      snake.y[i]-10);
      delay(gamespeed); /*控制游戏速度*/
      setcolor(0);
      rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
      snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
      } /*endwhile(!kbhit)*/ /*用黑色去除蛇的的最后一节*/
      if(snake.life==1)/*如果蛇死就跳出循环*/
      break;
      key=bioskey(0);/*接收按键*/
      if(key==ESC)/*按ESC键退出*/
      break;
      else
      if(key==UP&&snake.direction!=4)
      /*判断是否往相反的方向移动*/
      snake.direction=3;
      else
      if(key==RIGHT&&snake.direction!=2)
      snake.direction=1;
      else
      if(key==LEFT&&snake.direction!=1)
      snake.direction=2;
      else
      if(key==DOWN&&snake.direction!=3)
      snake.direction=4;
      }/*endwhile(1)*/
      }
      /*游戏结束*/
      void GameOver(void)
      {
      cleardevice(); /*清屏*/
      PrScore();
      setcolor(RED); /*设置字体颜色*/
      settextstyle(0,0,4); /*设置字体类型*/
      outtextxy(200,200,"GAME OVER"); /*显示文本*/
      getch();
      }
      /*输出成绩及游戏等级*/
      void PrScore(void)
      {
      char str1[20];/*设置字符型数组*/
      setfillstyle(SOLID_FILL,0);
      bar(50,15,390,35); /*填充矩形框*/
      setcolor(6); /*设置文本颜色*/
      settextstyle(0,0,2); /*设置数组显示位置*/
      sprintf(str1,"score %d level %d",score,level);/*显示数组内容*/
      outtextxy(55,20,str1);
      setcolor(YELLOW); /*设置字体颜色*/
      settextstyle(0,0,2); /*设置字体类型*/
      outtextxy(250,400,"EXIT=ESC ");/*显示文本*/
      }
      void Close(void)
      {
      closegraph();
      }
      最后一次编辑时间 推荐于2017-09-15 03:14:25
      li455381165
      li455381165


      li455381165:c语言贪吃蛇怎么让蛇自己动起来啊?

      刚学完谭浩强的c语言
      尽量详细点
      下面的解答已被3683人点赞
      死循环+Sleep可以完成这个功能的
      比如说我现在定义了一个小方块,让他自动移动
      int i,j;
      int a[25][80]={0};
      //用数组来覆盖整个运行界面
      int x=10,y=0;
      //定义一个x,y表示方块当前的位置
      while(1)
      {
      //清楚之前的输出信息
      system("cls");//这是调用的命令行,作用是清屏
      a[x][y]=1;
      //数组元素为1就表示在界面上的这个位置显示方块
      //在屏幕上相应位置输出方块
      for( i = 0; i<25 ; i++)
      for( j=0; j<80 ;j++)
      if(a[i][j]==0) printf(" ");
      //等于0就表示该位置不是方块,输出一个空格
      else printf("%c",2);
      //否则就输出这个方块
      //然后重置这个数组,这个可以和上一个循环合并在一起
      for( i = 0; i<25 ; i++)
      for( j=0; j<80 ;j++)
      a[i][j]=0;
      // 更改方块所在的位置
      //向上 x=x-1;
      //向下 x=x+1;
      //向左 y=y-1;
      //向右 y=y-1;
      //上面的四句保留一句就可以了
      //然后休息休息
      Sleep(300);
      }
      基本算法就如代码所示
      具体的肯定和你向做的效果不一样
      比如说你要控制蛇的方向
      那改变位置的时候就需要判断
      而且,改变一条蛇和改变一个方块也不一样
      不过总体思路是这样子的
      仅作参考
      注意一点,Sleep函数是window头文件里面的
      需要导入window头文件
      如果不是Windows系统,请替换为相应的函数
      最后一次编辑时间 推荐于2017-09-30 10:23:06
      bianchenggaosh
      bianchenggaosh


      bianchenggaosh:用c语言编写的贪食蛇游戏

      麻烦你注释详细点,最好注明每一句话的意思
      下面的解答已被4041人点赞
      这是一个成功的贪吃蛇代码(c语言编写的),希望你能看懂!慢慢看:
      #define N 200
      #include <graphics.h>
      #include <stdlib.h>
      #include <dos.h>
      #define LEFT 0x4b00
      #define RIGHT 0x4d00
      #define DOWN 0x5000
      #define UP 0x4800
      #define ESC 0x011b
      int i,key;
      int score=0;/*得分*/
      int gamespeed=50000;/*游戏速度自己调整*/
      struct Food
      {
      int x;/*食物的横坐标*/
      int y;/*食物的纵坐标*/
      int yes;/*判断是否要出现食物的变量*/
      }food;/*食物的结构体*/
      struct Snake
      {
      int x[N];
      int y[N];
      int node;/*蛇的节数*/
      int direction;/*蛇移动方向*/
      int life;/* 蛇的生命,0活着,1死亡*/
      }snake;
      void Init(void);/*图形驱动*/
      void Close(void);/*图形结束*/
      void DrawK(void);/*开始画面*/
      void GameOver(void);/*结束游戏*/
      void GamePlay(void);/*玩游戏具体过程*/
      void PrScore(void);/*输出成绩*/
      /*主函数*/
      void main(void)
      {
      Init();/*图形驱动*/
      DrawK();/*开始画面*/
      GamePlay();/*玩游戏具体过程*/
      Close();/*图形结束*/
      }
      /*图形驱动*/
      void Init(void)
      {
      int gd=DETECT,gm;
      initgraph(&gd,&gm,"c:\\tc");
      cleardevice();
      }
      /*开始画面,左上角坐标为(50,40),右下角坐标为(610,460)的围墙*/
      void DrawK(void)
      {
      /*setbkcolor(LIGHTGREEN);*/
      setcolor(11);
      setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/
      for(i=50;i<=600;i+=10)/*画围墙*/
      {
      rectangle(i,40,i+10,49); /*上边*/
      rectangle(i,451,i+10,460);/*下边*/
      }
      for(i=40;i<=450;i+=10)
      {
      rectangle(50,i,59,i+10); /*左边*/
      rectangle(601,i,610,i+10);/*右边*/
      }
      }
      /*玩游戏具体过程*/
      void GamePlay(void)
      {
      randomize();/*随机数发生器*/
      food.yes=1;/*1表示需要出现新食物,0表示已经存在食物*/
      snake.life=0;/*活着*/
      snake.direction=1;/*方向往右*/
      snake.x[0]=100;snake.y[0]=100;/*蛇头*/
      snake.x[1]=110;snake.y[1]=100;
      snake.node=2;/*节数*/
      PrScore();/*输出得分*/
      while(1)/*可以重复玩游戏,压ESC键结束*/
      {
      while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/
      {
      if(food.yes==1)/*需要出现新食物*/
      {
      food.x=rand()%400+60;
      food.y=rand()%350+60;
      while(food.x%10!=0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
      food.x++;
      while(food.y%10!=0)
      food.y++;
      food.yes=0;/*画面上有食物了*/
      }
      if(food.yes==0)/*画面上有食物了就要显示*/
      {
      setcolor(GREEN);
      rectangle(food.x,food.y,food.x+10,food.y-10);
      }
      for(i=snake.node-1;i>0;i--)/*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/
      {
      snake.x[i]=snake.x[i-1];
      snake.y[i]=snake.y[i-1];
      }
      /*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
      switch(snake.direction)
      {
      case 1:snake.x[0]+=10;break;
      case 2: snake.x[0]-=10;break;
      case 3: snake.y[0]-=10;break;
      case 4: snake.y[0]+=10;break;
      }
      for(i=3;i<snake.node;i++)/*从蛇的第四节开始判断是否撞到自己了,因为蛇头为两节,第三节不可能拐过来*/
      {
      if(snake.x[i]==snake.x[0]&&snake.y[i]==snake.y[0])
      {
      GameOver();/*显示失败*/
      snake.life=1;
      break;
      }
      }
      if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<55||
      snake.y[0]>455)/*蛇是否撞到墙壁*/
      {
      GameOver();/*本次游戏结束*/
      snake.life=1; /*蛇死*/
      }
      if(snake.life==1)/*以上两种判断以后,如果蛇死就跳出内循环,重新开始*/
      break;
      if(snake.x[0]==food.x&&snake.y[0]==food.y)/*吃到食物以后*/
      {
      setcolor(0);/*把画面上的食物东西去掉*/
      rectangle(food.x,food.y,food.x+10,food.y-10);
      snake.x[snake.node]=-20;snake.y[snake.node]=-20;
      /*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
      snake.node++;/*蛇的身体长一节*/
      food.yes=1;/*画面上需要出现新的食物*/
      score+=10;
      PrScore();/*输出新得分*/
      }
      setcolor(4);/*画出蛇*/
      for(i=0;i<snake.node;i++)
      rectangle(snake.x[i],snake.y[i],snake.x[i]+10,
      snake.y[i]-10);
      delay(gamespeed);
      setcolor(0);/*用黑色去除蛇的的最后一节*/
      rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
      snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
      } /*endwhile(!kbhit)*/
      if(snake.life==1)/*如果蛇死就跳出循环*/
      break;
      key=bioskey(0);/*接收按键*/
      if(key==ESC)/*按ESC键退出*/
      break;
      else
      if(key==UP&&snake.direction!=4)
      /*判断是否往相反的方向移动*/
      snake.direction=3;
      else
      if(key==RIGHT&&snake.direction!=2)
      snake.direction=1;
      else
      if(key==LEFT&&snake.direction!=1)
      snake.direction=2;
      else
      if(key==DOWN&&snake.direction!=3)
      snake.direction=4;
      }/*endwhile(1)*/
      }
      /*游戏结束*/
      void GameOver(void)
      {
      cleardevice();
      PrScore();
      setcolor(RED);
      settextstyle(0,0,4);
      outtextxy(200,200,"GAME OVER");
      getch();
      }
      /*输出成绩*/
      void PrScore(void)
      {
      char str[10];
      setfillstyle(SOLID_FILL,YELLOW);
      bar(50,15,220,35);
      setcolor(6);
      settextstyle(0,0,2);
      sprintf(str,"score:%d",score);
      outtextxy(55,20,str);
      }
      /*图形结束*/
      void Close(void)
      {
      getch();
      closegraph();
      }
      最后一次编辑时间 推荐于2017-09-18 11:51:53
      爹你爸来了
      爹你爸来了


      爹你爸来了:求C语言贪吃蛇代码能在DEV上运行通过的贪吃蛇,不要TC上的啊我们老师上课给在DEV我们运行了一次

      求C语言贪吃蛇代码能在DEV上运行通过的贪吃蛇,不要TC上的啊我们老师上课给在DEV我们运行了一次跪求跪求😭😭😭😭😭
      下面的解答已被7378人点赞

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


      #define U 1
      #define D 2
      #define L 3
      #define R 4       //蛇的状态,U:上 ;D:下;L:左 R:右

      typedef struct SNAKE { //蛇身的一个节点
          int x;
          int y;
          struct SNAKE *next;
      } snake;

      //全局变量//
      int score=0,add=10;//总得分与每次吃食物得分。
      int status,sleeptime=200;//每次运行的时间间隔
      snake *head, *food;//蛇头指针,食物指针
      snake *q;//遍历蛇的时候用到的指针
      int endgamestatus=0; //游戏结束的情况,1:撞到墙;2:咬到自己;3:主动退出游戏。

      //声明全部函数//
      void Pos();
      void creatMap();
      void initsnake();
      int biteself();
      void createfood();
      void cantcrosswall();
      void snakemove();
      void pause();
      void gamecircle();
      void welcometogame();
      void endgame();
      void gamestart();

      void Pos(int x,int y)//设置光标位置
      {
          COORD pos;
          HANDLE hOutput;
          pos.X=x;
          pos.Y=y;
          hOutput=GetStdHandle(STD_OUTPUT_HANDLE);
          SetConsoleCursorPosition(hOutput,pos);
      }

      void creatMap()//创建地图
      {
          int i;
          for(i=0; i<58; i+=2) { //打印上下边框
              Pos(i,0);
              printf("■");
              Pos(i,26);
              printf("■");
          }
          for(i=1; i<26; i++) { //打印左右边框
              Pos(0,i);
              printf("■");
              Pos(56,i);
              printf("■");
          }
      }

      void initsnake()//初始化蛇身
      {
          snake *tail;
          int i;
          tail=(snake*)malloc(sizeof(snake));//从蛇尾开始,头插法,以x,y设定开始的位置//
          tail->x=24;
          tail->y=5;
          tail->next=NULL;
          for(i=1; i<=4; i++) {
              head=(snake*)malloc(sizeof(snake));
              head->next=tail;
              head->x=24+2*i;
              head->y=5;
              tail=head;
          }
          while(tail!=NULL) { //从头到为,输出蛇身
              Pos(tail->x,tail->y);
              printf("■");
              tail=tail->next;
          }
      }

      int biteself()//判断是否咬到了自己
      {
          snake *self;
          self=head->next;
          while(self!=NULL) {
              if(self->x==head->x && self->y==head->y) {
                  return 1;
              }
              self=self->next;
          }
          return 0;
      }

      void createfood()//随机出现食物
      {
          snake *food_1;
          srand((unsigned)time(NULL));
          food_1=(snake*)malloc(sizeof(snake));
          while((food_1->x%2)!=0) {  //保证其为偶数,使得食物能与蛇头对其
              food_1->x=rand()%52+2;
          }
          food_1->y=rand()%24+1;
          q=head;
          while(q->next==NULL) {
              if(q->x==food_1->x && q->y==food_1->y) { //判断蛇身是否与食物重合
                  free(food_1);
                  createfood();
              }
              q=q->next;
          }
          Pos(food_1->x,food_1->y);
          food=food_1;
          printf("■");
      }

      void cantcrosswall()//不能穿墙
      {
          if(head->x==0 || head->x==56 ||head->y==0 || head->y==26) {
              endgamestatus=1;
              endgame();
          }
      }

      void snakemove()//蛇前进,上U,下D,左L,右R
      {
          snake * nexthead;
          cantcrosswall();

          nexthead=(snake*)malloc(sizeof(snake));
          if(status==U) {
              nexthead->x=head->x;
              nexthead->y=head->y-1;
              if(nexthead->x==food->x && nexthead->y==food->y) { //如果下一个有食物//
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  score=score+add;
                  createfood();
              } else {                                           //如果没有食物//
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q->next->next!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  Pos(q->next->x,q->next->y);
                  printf("  ");
                  free(q->next);
                  q->next=NULL;
              }
          }
          if(status==D) {
              nexthead->x=head->x;
              nexthead->y=head->y+1;
              if(nexthead->x==food->x && nexthead->y==food->y) { //有食物
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  score=score+add;
                  createfood();
              } else {                           //没有食物
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q->next->next!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  Pos(q->next->x,q->next->y);
                  printf("  ");
                  free(q->next);
                  q->next=NULL;
              }
          }
          if(status==L) {
              nexthead->x=head->x-2;
              nexthead->y=head->y;
              if(nexthead->x==food->x && nexthead->y==food->y) { //有食物
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  score=score+add;
                  createfood();
              } else {                            //没有食物
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q->next->next!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  Pos(q->next->x,q->next->y);
                  printf("  ");
                  free(q->next);
                  q->next=NULL;
              }
          }
          if(status==R) {
              nexthead->x=head->x+2;
              nexthead->y=head->y;
              if(nexthead->x==food->x && nexthead->y==food->y) { //有食物
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  score=score+add;
                  createfood();
              } else {                                     //没有食物
                  nexthead->next=head;
                  head=nexthead;
                  q=head;
                  while(q->next->next!=NULL) {
                      Pos(q->x,q->y);
                      printf("■");
                      q=q->next;
                  }
                  Pos(q->next->x,q->next->y);
                  printf("  ");
                  free(q->next);
                  q->next=NULL;
              }
          }
          if(biteself()==1) {     //判断是否会咬到自己
              endgamestatus=2;
              endgame();
          }
      }

      void pause()//暂停
      {
          while(1) {
              Sleep(300);
              if(GetAsyncKeyState(VK_SPACE)) {
                  break;
              }

          }
      }

      void gamecircle()//控制游戏
      {

          Pos(64,15);
          printf("不能穿墙,不能咬到自己\n");
          Pos(64,16);
          printf("用↑.↓.←.→分别控制蛇的移动.");
          Pos(64,17);
          printf("F1 为加速,F2 为减速\n");
          Pos(64,18);
          printf("ESC :退出游戏.space:暂停游戏.");
          Pos(64,20);
          //
          status=R;
          while(1) {
              Pos(64,10);
              printf("得分:%d  ",score);
              Pos(64,11);
              printf("每个食物得分:%d分",add);
              if(GetAsyncKeyState(VK_UP) && status!=D) {
                  status=U;
              } else if(GetAsyncKeyState(VK_DOWN) && status!=U) {
                  status=D;
              } else if(GetAsyncKeyState(VK_LEFT)&& status!=R) {
                  status=L;
              } else if(GetAsyncKeyState(VK_RIGHT)&& status!=L) {
                  status=R;
              } else if(GetAsyncKeyState(VK_SPACE)) {
                  pause();
              } else if(GetAsyncKeyState(VK_ESCAPE)) {
                  endgamestatus=3;
                  break;
              } else if(GetAsyncKeyState(VK_F1)) {
                  if(sleeptime>=50) {
                      sleeptime=sleeptime-30;
                      add=add+2;
                      if(sleeptime==320) {
                          add=2;//防止减到1之后再加回来有错
                      }
                  }
              } else if(GetAsyncKeyState(VK_F2)) {
                  if(sleeptime<350) {
                      sleeptime=sleeptime+30;
                      add=add-2;
                      if(sleeptime==350) {
                          add=1;  //保证最低分为1
                      }
                  }
              }
              Sleep(sleeptime);
              snakemove();
          }
      }

      void welcometogame()//开始界面
      {
          Pos(40,12);

          //
          printf("欢迎来到贪食蛇游戏!");
          Pos(40,25);
          //
          system("pause");
          system("cls");
          Pos(25,12);
          printf("用↑.↓.←.→分别控制蛇的移动, F1 为加速,2 为减速\n");
          Pos(25,13);
          printf("加速将能得到更高的分数。\n");
          system("pause");
          system("cls");
      }

      void endgame()//结束游戏
      {

          system("cls");
          Pos(24,12);
          if(endgamestatus==1) {
              printf("对不起,您撞到墙了。游戏结束.");
          } else if(endgamestatus==2) {
              printf("对不起,您咬到自己了。游戏结束.");
          } else if(endgamestatus==3) {
              printf("您的已经结束了游戏。");
          }
          Pos(24,13);
          printf("您的得分是%d\n",score);
          exit(0);
      }

      void gamestart()//游戏初始化
      {
          system("mode con cols=100 lines=30");
          welcometogame();
          creatMap();
          initsnake();
          createfood();
      }

      int main()
      {
          gamestart();
          gamecircle();
          endgame();
          return 0;
      }

      最后一次编辑时间 推荐于2017-11-22 20:12:24
      lck32578
      lck32578


      lck32578:求 贪吃蛇C语言代码

      求大神给我一份贪吃蛇的代码,不要用到图形库函数的,只用time,stlib,stdio就好了,谢谢!
      下面的解答已被6960人点赞
      #include <windows.h>
      #include <stdlib.h>
      #include <time.h>
      #include <stdio.h>
      #include <string.h>
      #include <conio.h>
      #define N 21

      int apple[3],num;
      char score[3];
      char tail[3];

      void gotoxy(int x, int y) //输出坐标
      {
      COORD pos;
      pos.X = x;
      pos.Y = y;
      SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
      }

      void color(int b) //颜色函数
      {
      HANDLE hConsole = GetStdHandle((STD_OUTPUT_HANDLE)) ;
      SetConsoleTextAttribute(hConsole,b) ;
      }

      int Block(char head[2]) //判断出界
      {
      if ((head[0] < 1) || (head[0] > N) || (head[1] < 1) || (head[1] > N))
      return 1;
      return 0;
      }

      int Eat(char snake[2]) //吃了苹果
      {
      if ((snake[0] == apple[0]) && (snake[1] == apple[1]))
      {
      apple[0] = apple[1] = apple[2] = 0;
      gotoxy(N+44,10);
      color(13);
      printf("%d",score[0]*10);
      color(11);
      return 1;
      }
      return 0;
      }

      void Draw(char **snake, int len) //蛇移动
      {
      if (apple[2])
      {
      gotoxy(apple[1] * 2, apple[0]);
      color(12);
      printf("●");
      color(11);
      }
      gotoxy(tail[1] * 2, tail[0]);
      if (tail[2])
      {
      color(num);
      printf("★");
      color(num);
      }
      else
      printf("■");
      gotoxy(snake[0][1] * 2, snake[0][0]);
      color(num);
      printf("★");
      color(num);
      putchar('\n');
      }

      char** Move(char **snake, char dirx, int *len) //控制方向
      {
      int i, full = Eat(snake[0]);
      memcpy(tail, snake[(*len)-1], 2);
      for (i = (*len) - 1; i > 0; --i)
      memcpy(snake[i], snake[i-1], 2);
      switch (dirx)
      {
      case 'w': case 'W': --snake[0][0]; break;
      case 's': case 'S': ++snake[0][0]; break;
      case 'a': case 'A': --snake[0][1]; break;
      case 'd': case 'D': ++snake[0][1]; break;
      default: ;
      }
      if (full)
      {
      snake = (char **)realloc(snake, sizeof(char *) * ((*len) + 1));
      snake[(*len)] = (char *)malloc(sizeof(char) * 2);
      memcpy(snake[(*len)], tail, 2);
      ++(*len);
      ++score[0];
      if(score[3] < 16)
      ++score[3];
      tail[2] = 1;
      }
      else
      tail[2] = 0;
      return snake;
      }

      void init(char plate[N+2][N+2], char ***snake_x, int *len) //初始化
      {
      int i, j;
      char **snake = NULL;

      *len = 3;
      score[0] = score[3] =3;
      snake = (char **)realloc(snake, sizeof(char *) * (*len));
      for (i = 0; i < *len; ++i)
      snake[i] = (char *)malloc(sizeof(char) * 2);

      for (i = 0; i < 3; ++i)
      {
      snake[i][0] = N/2 + 1;
      snake[i][1] = N/2 + 1 + i;
      }

      for (i = 1; i <= N; ++i)
      for (j = 1; j <= N; ++j)
      plate[i][j] = 1;

      apple[0] = rand()%N + 1; apple[1] = rand()%N + 1;
      apple[2] = 1;

      for (i = 0; i < N + 2; ++i)
      {
      gotoxy(0, i);
      for (j = 0; j < N + 2; ++j)
      {
      switch (plate[i][j])
      {
      case 0:
      color(12);printf("□");color(11); continue;
      case 1: printf("■"); continue;
      default: ;
      }
      }
      putchar('\n');
      }
      for (i = 0; i < (*len); ++i)
      {
      gotoxy(snake[i][1] * 2, snake[i][0]);
      printf("★");
      }
      putchar('\n');
      *snake_x = snake;
      }

      void Manual()
      {
      gotoxy(N+30,2);
      color(10);
      printf("按 W S A D 移动方向");
      gotoxy(N+30,4);
      printf("按 space 键暂停");
      gotoxy(N+30,8);
      color(11);
      printf("历史最高分为: ");
      color(12);
      gotoxy(N+44,8);
      printf("%d",score[1]*10);
      color(11);
      gotoxy(N+30,12);
      printf("你现在得分为: 0");
      }

      int File_in() //取记录的分数
      {
      FILE *fp;
      if((fp = fopen("C:\\tcs.txt","a+")) == NULL)
      {
      gotoxy(N+18, N+2);
      printf("文件不能打开\n");
      exit(0);
      }
      if((score[1] = fgetc(fp)) != EOF);
      else
      score[1] = 0;
      return 0;
      }

      int File_out() //存数据
      {

      FILE *fp;
      if(score[1] > score[0])
      {gotoxy(10,10);
      color(12);
      puts("闯关失败 加油耶");
      gotoxy(0,N+2);
      return 0;
      }
      if((fp = fopen("C:\\tcs.txt","w+")) == NULL)
      {
      printf("文件不能打开\n");
      exit(0);
      }
      if(fputc(--score[0],fp)==EOF)
      printf("输出失败\n");
      gotoxy(10,10);
      color(12);
      puts("恭喜您打破记录");
      gotoxy(0,N+2);
      return 0;
      }

      void Free(char **snake, int len) //释放空间
      {
      int i;
      for (i = 0; i < len; ++i)
      free(snake[i]);
      free(snake);
      }

      int main(void)
      {
      int len;
      char ch = 'g';
      char a[N+2][N+2] = {{0}};
      char **snake;
      srand((unsigned)time(NULL));
      color(11);
      File_in();
      init(a, &snake, &len);
      Manual();
      while (ch != 0x1B) // 按 ESC 结束
      {
      Draw(snake, len);
      if (!apple[2]) {
      apple[0] = rand()%N + 1;
      apple[1] = rand()%N + 1;
      apple[2] = 1;
      num++;
      if(num>8)
      num=0;
      }
      Sleep(200-score[3]*10);
      setbuf(stdin, NULL);
      if (kbhit())
      {
      gotoxy(0, N+2);
      ch = getche();
      }
      snake = Move(snake, ch, &len);
      if (Block(snake[0])==1)
      {
      gotoxy(N+2, N+2);
      puts("你输了");
      File_out();
      Free(snake, len);
      getche();
      exit(0);
      }
      }
      Free(snake, len);
      exit(0);
      }

      追问

      这个在DEV可以编译,但打字出来文件不能打开
      而且我想只用三个库文件

      最后一次编辑时间 推荐于2017-09-16 17:48:18
      小燕子非非
      小燕子非非


      小燕子非非:c语言贪吃蛇的速度控制程序怎么编

      麻烦快些给我答案,谢谢了
      下面的解答已被3985人点赞

      1. 可以Sleep函数设置延时来控制贪吃蛇的速度。

        函数名: Sleep
        功 能: 执行挂起一段时间
        用 法: void Sleep(DWORD dwMilliseconds);
        在VC中使用带上头文件
        #include <windows.h>
        ( Sleep函数存放头文件:WinBase.h)
        在gcc编译器中,使用的头文件因gcc版本的不同而不同
        #include <unistd.h>
        Sleep()单位为毫秒,sleep()单位为秒(如果需要更精确可以用usleep单位为微秒)
        返回值
        若进程/线程挂起到参数所指定的时间则返回0,若有信号中断则返回剩余秒数。

      2. 例程:

        / *--------------------snake.h --------------------*/
        #ifndef SNAKE_H
        #define SNAKE_H
         
        #define LEFT 'a'
        #define RIGHT 'd'
        #define DOWN 's'
        #define UP 'w'
        #define ESC 27
         
        #define N 200               /*蛇的最大长度*/
         
        char key;                   /*控制按键*/
         
        struct Food
        {
             int x;                   /*食物的横坐标*/
             int y;                   /*食物的纵坐标*/
             int yes;                 /*判断是否要出现食物的变量*/
        }food;                        /*食物的结构体*/
         
        struct Snake
        {
             int x[N];
             int y[N];
             int node;                /*蛇的节数*/
             int direction;           /*蛇移动方向*/
             int life;                /* 蛇的生命,0活着,1死亡*/
        }snake;
        #endif



        / *--------------------snake.c --------------------*/
        #include <graphics.h>
        #include <stdlib.h>
        #include <conio.h>
        #include <time.h>
        #include <stdio.h>
        #include "snake.h"
         
        int score = 0;
        int gamespeed = 100;                //蛇运行速度
         
        static void Init(void);             /*图形驱动*/
        static void Close(void);            /*图形结束*/
        static void Game_interface(void);   /*游戏界面*/
        static void GameOver(void);         /*结束游戏*/
        static void GamePlay(void);         /*游戏过程*/
        static void PrScore(void);          /*输出成绩*/
         
        /*主函数*/
        int main(void)
        {
             Init();                
             Game_interface();                
             GamePlay();             
             Close();                
             return 0;
        }
         
        /*图形驱动*/
        static void Init(void)
        {
            int gd=9,gm=2;
         
            initgraph(&gd,&gm," ");
            cleardevice();
        }
         
        /* 开始画面,左上角坐标为(50,40),右下角坐标为(610,460)的围墙 */
        static void Game_interface(void)
        {
             int i;
         
             setcolor(LIGHTCYAN);                           /*setbkcolor(LIGHTGREEN);*/
             setlinestyle(PS_SOLID,0,1);                    /*设置线型*/
             for(i=50;i<=600;i+=10)                          /*画边框*/
             {
                 rectangle(i,40,i+10,49);                   /*上边框*/
                 rectangle(i,451,i+10,460);                 /*下边框*/
             }
             for(i=40;i<=450;i+=10)
             {
                 rectangle(50,i,59,i+10);                   /*左边框*/
                 rectangle(601,i,610,i+10);                 /*右边框*/
             }
        }
         
        /* 游戏主函数 */
        static void GamePlay(void)
        {
             int i;
              
             srand(time(NULL));                             /*随机数发生器*/
             food.yes = 1;                                  /*1表示需要出现新食物,0表示已经存在食物*/
             snake.life = 0;                                /*活着*/
             snake.direction = 1;                           /*方向往右*/
             snake.x[0] = 100;
             snake.y[0] = 100;                             
             snake.x[1] = 110;
             snake.y[1] = 100;
             snake.node = 2;                                /*节数*/
         
             PrScore();                                     /*输出得分*/
             while(1)                                       /*可以重复玩游戏,压ESC键结束*/
             {
                 while( !kbhit() )                          /*在没有按键的情况下,蛇自己移动*/
                 {
                     if(food.yes == 1)                      /*需要出现新食物*/
                     {
                         food.x = rand()%400 + 60;
                         food.y = rand()%350 + 60;
                         while(food.x%10 != 0)              /*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
                             food.x++;
                         while(food.y%10 != 0)
                             food.y++;
                         food.yes = 0;                      /*画面上有食物了*/
                     }
                     if(food.yes == 0)                      /*画面上有食物了就要显示*/
                     {
                         setcolor(GREEN);
                         rectangle(food.x,food.y,food.x + 10,food.y - 10);
                     }
         
         
                     for(i=snake.node-1;i>0;i--)          /*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/
                     {
                         snake.x[i] = snake.x[i-1];
                         snake.y[i] = snake.y[i-1];
                     }
                     /*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
                     switch(snake.direction)
                     {
                         case 1:
                             snake.x[0] += 10;
                             break;
                         case 2:
                             snake.x[0] -= 10;
                             break;
                         case 3:
                             snake.y[0] -= 10;
                             break;
                         case 4:
                             snake.y[0] += 10;
                             break;
                     }
                     /* 从蛇的第四节开始判断是否撞到自己 */
                     for(i=3;i<snake.node;i++)
                     {
                         if((snake.x[i] == snake.x[0]) && (snake.y[i] == snake.y[0]))
                         {
                             GameOver();                  /*显示失败*/
                             snake.life = 1;
                             break;
                         }
                     }
                     if((snake.x[0] < 55) || (snake.x[0] > 595) || (snake.y[0] < 55) || (snake.y[0] > 455))     /*蛇是否撞到墙壁*/
                     {
         
         
                         GameOver();                                            /*本次游戏结束*/
                         snake.life = 1;                                        /*蛇死*/
                     }
                     if(snake.life == 1)                                        /*以上两种判断以后,如果蛇死就跳出内循环,重新开始*/
                         break;
                     if((snake.x[0] == food.x) && (snake.y[0] == food.y))       /*吃到食物以后*/
                     {
                         setcolor(BLACK);                                       /*把画面上的食物东西去掉*/
                         rectangle(food.x,food.y,food.x+10,food.y-10);
                         snake.x[snake.node] = -20;
                         snake.y[snake.node] = -20;
         
                         /* 新的一节先放在看不见的位置,下次循环就取前一节的位置 */
         
                         snake.node++;                      /*蛇的身体长一节*/
                         food.yes = 1;                      /*画面上需要出现新的食物*/
                         score += 10;
                         PrScore();                         /*输出新得分*/
                     }
                     setcolor(RED);                         /*画出蛇*/
         
         
                     for(i=0;i<snake.node;i++)
                         rectangle(snake.x[i],snake.y[i],snake.x[i]+10,snake.y[i]-10);
                     Sleep(gamespeed);                        /*用延迟控制贪吃蛇速度*/                
                     setcolor(BLACK);                        /*用黑色去除蛇的的最后一节*/
                     rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
                               snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
                 }        /*endwhile(!kbhit)*/
                  
                 if(snake.life == 1)                        /*如果蛇死就跳出循环*/
                     break;
                  
                 key=getch();                          /*接收按键*/
                 if (key == ESC) break;                  /*按ESC键退出*/
                  
                 switch(key)
                 {                                
                     case UP:
                         if(snake.direction != 4)           /*判断是否往相反的方向移动*/
                             snake.direction = 3;
                         break;
                     case RIGHT:
                         if(snake.direction != 2)
                             snake.direction = 1;
                         break;
                     case LEFT:
                         if(snake.direction != 1)
                             snake.direction = 2;
                         break;
                     case DOWN:
                         if(snake.direction != 3)
                             snake.direction = 4;
                         break;
                 }
         
             }/*endwhile(1)*/
        }
         
        /*游戏结束*/
        static void GameOver(void)
        {
             cleardevice();
             PrScore();
             setcolor(RED);
             setfont(56,0,"黑体");
             outtextxy(200,200,"GAME OVER");
             getch();
        }
         
        /*输出成绩*/
        static void PrScore(void)
        {
             char str[10];
         
             setfillstyle(YELLOW);
             bar(50,15,220,35);
             setcolor(BROWN);
             setfont(16,0,"宋体");
             sprintf(str,"score:%d",score);
             outtextxy(55,16,str);
        }
         
        static void Close(void)
        {
             closegraph();
        }

      最后一次编辑时间 推荐于2017-09-01 20:05:54
      j78903
      j78903


      j78903:c语言贪吃蛇源代码怎么用?

      下面的解答已被1144人点赞

          C语言贪吃蛇源代码必须经过相应的C/C++编译器编译成EXE文件后才能运行。

          由于我们通常使用的操作系统是Windows系统,而在该系统下最长用的C/C++编译器是VC++编译器,目前在大专院校常用的版本还是VC++6.0

         下面就以VC++6.0来说明编译过程:

      1.在VC++6.0中通过“File”菜单下的 “Open”子菜单打开贪吃蛇代码

       

      2.在VC++6.0中通过“Build”菜单下的 “Compile xxxx.xx”子菜单编译贪吃蛇代码

       

      3.在VC++6.0中通过“Build”菜单下的 “Execute xxxx.exe”子菜单运行贪吃蛇程序

       

       

          附:在VC++6环境下可运行的C/C++贪吃蛇源代码(无版权,自己编写,欢迎任意修改拷贝)

      /*
      C/C++贪吃蛇游戏,zjlj,2015.3.16
      */
      #define DEBUG 0 //当程序在调试阶段时 DEBUG为 1
      #include<iostream>
      #include<windows.h>
      #include<time.h>
      #include<conio.h>
      using namespace std;
      void readini(FILE **fphead, int *score, char *argv[]) //创建或打开一个和运行文件对应的ini文件,读取最高纪录
      {
       char filename[200],*pfilename;
       int flag=-1,i;
          
          strcpy(filename,argv[0]);
          for(i=0;filename[i]!='\0';i++)
       {
        if ('.'==filename[i])flag=1;
       }
       
       if(1==flag)
       {
       filename[i-1]='i';
          filename[i-2]='n';
       filename[i-3]='i';
       }
       else
       {
        filename[i]='.';
       filename[i+1]='i';
       filename[i+2]='n';
          filename[i+3]='i';
          filename[i+4]='\0';
       }
       for(;filename[i]!='\\'&&i>=0;i--)pfilename=&filename[i];
          if ( (*fphead=fopen(pfilename, "rb+"))==NULL)
       {
              if ( (*fphead=fopen(pfilename, "wb+"))==NULL)
        {
          printf("无法创建或打开\"%s\"文件\n",pfilename);
          system("pause");
             exit(0);
        }
          }
       else
       {
        fread(score,sizeof(int),1,*fphead);
       }
      }
      void writeini(FILE **fphead, int *score, char *argv[])  //打开一个和运行文件对应的ini文件,写入最高纪录
      {
       char filename[200],*pfilename;
       int flag=-1,i;
         
          strcpy(filename,argv[0]);
          for(i=0;filename[i]!='\0';i++)
       {
        if ('.'==filename[i])flag=1;
       }
       
       if(1==flag)
       {
       filename[i-1]='i';
          filename[i-2]='n';
       filename[i-3]='i';
       }
       else
       {
        filename[i]='.';
       filename[i+1]='i';
       filename[i+2]='n';
          filename[i+3]='i';
          filename[i+4]='\0';
       }
       for(;filename[i]!='\\'&&i>=0;i--)pfilename=&filename[i];
          if ( (*fphead=fopen(pfilename, "wb+"))==NULL)
       {
                printf("无法写入\"%s\"文件,磁盘写保护!\n",pfilename);
          system("pause");
             exit(0);
       }
       else
       {
        rewind(*fphead);
        fwrite(score,sizeof(int),1,*fphead);
        fclose(*fphead);
       }
      }
      void gotoxy(int x,int y)//光标定位,光标定位函数SetConsoleCursorPosition是左上角位置是0,0然后向左向下延伸
      {
      COORD pos;
      pos.X=2*y;
      pos.Y=x;
      SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
      }
      void color(int a)//颜色函数
      {
      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),a);
      }

      void Refresh(int q[][22], int grade, int gamespeed, int length,int score) //  输出贪吃蛇棋盘
      {
       int i,j;
       for(i=0;i<22;i++)
       {
        for(j=0;j<22;j++)
        {
         if(q[i][j]==0)//输出棋盘空白
         {
          gotoxy(i,j);
          color(11);
          cout<<"■";
         }
         if(q[i][j]==1||q[i][j]==2)//输出棋盘墙壁
         {  
          gotoxy(i,j);
          color(11);
          cout<<"□";
         }
         if(q[i][j]==3)//输出蛇头
         {  
          gotoxy(i,j);
          color(14);
          cout<<"★";
         }
         if(q[i][j]==4)//输出蛇身
         {  
          gotoxy(i,j);
          color(12);
          cout<<"◆";
         }
           if(q[i][j]==5)//输出果子
         {  
          gotoxy(i,j);
          color(12);
          cout<<"●";
         }
        }
        if(i==0) cout << "\t***********************";
        if(i==1) cout << "\t等级为:" << grade;//显示等级
        if(i==3) cout << "\t自动前进时间";
        if(i==4) cout << "\t间隔为:" << gamespeed << "ms";//显示时间
           if(i==6) cout << "\t历史最高分为:" << score << "分";
        if(i==7) cout << "\t你现在得分为:" << (length+(grade-1)*8)*10 << "分";
        if(i==8) cout << "\t**********************";
           if(i==9) cout << "\t游戏说明:";
           if(i==10) cout << "\t(1)用小键盘方向键控制";
        if(i==11) cout << "\t蛇头运动方向;";
        if(i==12) cout << "\t(2)蛇每吃一个果子蛇身";
        if(i==13) cout << "\t增加一节;";
        if(i==14) cout << "\t(3)蛇咬到自己或碰到墙";
        if(i==15) cout << "\t壁游戏结束。";
        if(i==18) cout << "\t**********************";
           if(i==19) cout << "\tC/C++语言作业:";
           if(i==20) cout << "\tzjlj,2015.03.16 ";
       }
      }
       
      int main(int argc, char *argv[]){
          int tcsQipan[22][22];     //  贪吃蛇棋盘是一个二维数组(如22*22,包括墙壁)
          int i,j,score,directiontemp;
       FILE  *fpini;//*fpini 信息文件
       readini(&fpini, &score, argv);//读取ini文件的最高纪录
       if (score<0)//最高成绩小于零设置为零,初建文件会是负数
        score=0;
       while(1)
       {
        for(i=1;i<=20;i++)
         for(j=1;j<=20;j++)
          tcsQipan[i][j]=0;    //贪吃蛇棋盘相应坐标标上中间空白部分的标志0
        for(i=0;i<=21;i++)
         tcsQipan[0][i] = tcsQipan[21][i] = 1;      //贪吃蛇棋盘相应坐标标上上下墙壁的标志1
        for(i=1;i<=20;i++)
         tcsQipan[i][0] = tcsQipan[i][21] = 2;      //贪吃蛇棋盘相应坐标标上左右墙壁的标志2
        int tcsZuobiao[2][500];     //蛇的坐标数组
        for(i=0; i<4; i++)
        {
         tcsZuobiao[0][i] = 1;//蛇身和蛇头的x坐标
         tcsZuobiao[1][i] = i + 1;//蛇身和蛇头的y坐标
        }
        int head = 3,tail = 0;//标示蛇头和蛇尾的数组偏移量
        for(i=1;i<=3;i++)
         tcsQipan[1][i]=4;    //蛇身
        tcsQipan[1][4]=3;       //蛇头
        int x1, y1;           // 随机出果子
        srand(time(0));//设置随机种子
        do
        {
         x1=rand()%20+1;
         y1=rand()%20+1;
        }
        while(tcsQipan[x1][y1]!=0);//如果不是在空白处重新出果子
        tcsQipan[x1][y1]=5;//贪吃蛇棋盘相应坐标标上果子的标志5
        color(12);
        cout<<"\n\n\t\t\t\t贪吃蛇游戏即将开始 !"<<endl;//准备开始
        long start,starttemp;
        int grade = 1, length = 4;  //设置初始等级和蛇的初始长度
        int gamespeed = 500;  //设置初始前进时间间隔
        for(i=3;i>=0;i--)
        {
         start=clock();
         while(clock()-start<=1000);
         system("cls");
         if(i>0)
          cout << "\n\n\t\t\t\t进入倒计时:" << i << endl;  //倒计时显示
         else
          Refresh(tcsQipan,grade,gamespeed,length,score);  //初始棋盘显示
        }
        int timeover=1,otherkey=1;//初始化超时时间和按键判断参数
        char direction = 77;  // 设置初始情况下,向右运动
        int x=tcsZuobiao[0][head],y=tcsZuobiao[1][head];//保存蛇头坐标到x,y变量
        while(1)//运行一局游戏
        {
         start = clock();
         while((timeover=((starttemp=clock())-start<=gamespeed))&&!kbhit());//如果有键按下或时间超过自动前进时间间隔则终止循环
         if(direction==72||direction==80||direction==75 ||direction==77)
         directiontemp=direction;//保留上一次方向按键
                  //starttemp=gamespeed+start-starttemp;//保留停留时间
         if(timeover)
         {
          #if (DEBUG==1)
          direction = getch();//调试代码
                   #else
          if((direction =getch())==-32)
           direction = getch();
             #endif
         }
                   #if (DEBUG==1)//调试代码
             start=clock();
          while(clock()-start<=2000);
          gotoxy(24,4);
          cout << "\t按键ASCII代码"<<(int)direction<<"    "<<endl;
                   #endif
          if(!(direction==72||direction==80||direction==75 ||direction==77))
          {   
           otherkey=0;//  按键非方向键,otherkey设置为0
          }
          else
          {
           otherkey=1;//  按键为方向键,otherkey设置为1
          }
                   if(direction==72 && directiontemp==80)//忽略反方向按键
          {
              direction=32;
           otherkey=0;
                       //start = clock();
              //while(clock()-start<=starttemp);
          }
          else if(direction==80 && directiontemp==72)
         {
              direction=32;//设置按键为非方向键
            otherkey=0;//  按键为非方向键,otherkey设置为0
                      // start = clock();
             //while(clock()-start<=starttemp);//补偿等待时间
          }
          else if(direction==75 && directiontemp==77)
          {
              direction=32;
           otherkey=0;
                       //start = clock();
              //while(clock()-start<=starttemp);
          }
          else if(direction==77 && directiontemp==75)
          {
              direction=32;
           otherkey=0;
                       //start = clock();
              //while(clock()-start<=starttemp);
          }
          
          
          switch(direction)//判断方向键
          {
           case 72: x= tcsZuobiao[0][head]-1; y= tcsZuobiao[1][head];break;      // 向上
           case 80: x= tcsZuobiao[0][head]+1; y= tcsZuobiao[1][head];break;      // 向下
           case 75: x= tcsZuobiao[0][head]; y= tcsZuobiao[1][head]-1;break;      // 向左
           case 77: x= tcsZuobiao[0][head]; y= tcsZuobiao[1][head]+1;break;      // 向右
           default: break;
          }
         
       
          if(x==0 || x==21 ||y==0 || y==21)      // 蛇头碰到墙壁,结束本局游戏
          {  
           gotoxy(22,12);
           cout << "\t游戏已结束!" << endl;
           if(score>=(length+(grade-1)*8)*10)//判断是否破记录
           {
            gotoxy(10,7);
            color(12);
            cout << "闯关失败 加油耶!" << endl;
            fclose(fpini);//关闭ini文件
           }
           else
           {
            gotoxy(10,7);
            color(12);
            cout << "恭喜您打破记录" << endl;
            score=(length+(grade-1)*8)*10;
            writeini(&fpini, &score, argv);//写入ini文件的最高纪录
           }
           gotoxy(23,12);
              cout << "按回车键重新开始,按ESC退出游戏" << endl;//显示的提示
           break;//退出该局游戏
          }
          if(tcsQipan[x][y]!=0&&!(x==x1&&y==y1)&&tcsQipan[x][y]!=3) //   蛇头碰到蛇身,结束本局游戏
          {
           gotoxy(22,12);
           cout << "\t游戏已结束!" << endl;
           if(score>=(length+(grade-1)*8)*10)//判断是否破记录
           {
            gotoxy(10,7);
            color(12);
            cout << "闯关失败 加油耶!" << endl;
            fclose(fpini);//关闭ini文件
           }
           else
           {
            gotoxy(10,7);
            color(12);
            cout << "恭喜您打破记录" << endl;
            score=(length+(grade-1)*8)*10;
            writeini(&fpini, &score, argv);//写入ini文件的最高纪录
           }
           gotoxy(23,12);
           cout << "按回车键重新开始,按ESC退出游戏" << endl;//显示的提示
           break;//退出该局游戏
          }
          /*
          游戏运行时的核心算法开始
          */
          if(x==x1 && y==y1) //  吃果子,长度加1
          {   
           length ++;
           if(length>=8)//长度大于等于8重新计算长度,等级加1
           {
            length -= 8;//重新计算长度
            grade ++;//等级加1
            if(gamespeed>50)//控制最快速度为50
             gamespeed = 550 - grade * 50; // 改变自动前进时间间隔
           }
           tcsQipan[x][y]= 3;//贪吃蛇棋盘相应坐标现在蛇头标志改为蛇头标志3
           tcsQipan[tcsZuobiao[0][head]][tcsZuobiao[1][head]] = 4;//贪吃蛇棋盘相应坐标原来蛇头标志改为蛇身标志4
           head = (head+1)%400;//防止数组越界
           tcsZuobiao[0][head] = x;//蛇头的x坐标
           tcsZuobiao[1][head] = y;//蛇头的y坐标
           do//随机出果子
           {
            x1=rand()%20+1;
            y1=rand()%20+1;
           }
           while(tcsQipan[x1][y1]!=0);//如果不是在空白处重新出果子
           tcsQipan[x1][y1]=5;//贪吃蛇棋盘相应坐标标上果子的标志5
           gotoxy(22,12);
           cout << "\t游戏进行中!" << endl;
           Refresh(tcsQipan,grade,gamespeed,length,score);
          }
          else  //  不吃果子
          {  
           if(otherkey)
           {
            tcsQipan [tcsZuobiao[0][tail]][tcsZuobiao[1][tail]]=0;
            tail=(tail+1)%400;//防止数组越界
            tcsQipan [tcsZuobiao[0][head]][tcsZuobiao[1][head]]=4;
            head=(head+1)%400;//防止数组越界
            tcsZuobiao[0][head]=x;//蛇头的x坐标
            tcsZuobiao[1][head]=y;//蛇头的y坐标
            tcsQipan[tcsZuobiao[0][head]][tcsZuobiao[1][head]]=3;
            gotoxy(22,12);
            cout << "\t游戏进行中!" << endl;
            Refresh(tcsQipan,grade,gamespeed,length,score);
           }
           else
           {
            gotoxy(22,12);
            cout << "\t游戏暂停中!" << endl;
           }
          }
          /*
          游戏运行时的核心算法结束
          */
             }
          while(1)
          {
           while(!kbhit());
           if((direction =getch())==13)//按回车键开始下一局
            break;
           if(direction ==27)//按ESC退出游戏
            exit(0);
          }
             system("cls");//清除屏幕重新开始
       }
       return 0;
      }

      最后一次编辑时间 推荐于2017-09-10 07:05:52
      极速赛车6码,极速赛车6码技巧,极速赛车6码选号技巧