这次来分享一个我写的贪吃蛇小游戏程序（C语言）

最近无事开始用C语言写一些小游戏小游戏程序，这个贪吃蛇当然是经典中的经典，所以先开始写。

文件引用
  1. #include<redio.h>//输入输出
  2. #include<time.h>//用于获取随机数
  3. #include<windows.h>//控制DOS界面
  4. #include<stdlib.h>//定义了一些宏和通用工具函数
  5. #include<conio.h>  //     接收键盘输入输出
函数声明
  1.     /**************************函数声明***************************/
  2.    
  3.   void gotoxy(int x,int y);                        //设置光标位置
  4. int  color(int c);                                        //更改文字颜色
  5. void printsnake();                                        //字符画--蛇
  6. void welcome();                                                //开始界面
  7. void createMap();                                        //绘制地图
  8. void scoreandtips();                                //游戏界面右侧的积分和小提示
  9. void initsnake();                                        //初始化蛇身，花蛇身
  10. void createfood();                                        //创建并随机出现食物
  11. int  biteself();                                        //判断是否咬到自己
  12. void cantcrosswall();                                //设置蛇撞到墙的情况
  13. void speedup();                                                //加速
  14. void speeddown();                                        //减速
  15. void snakemove();                                        //控制蛇前进方向
  16. void keyjianpan();                                        //控制键盘按键
  17. void Lostdraw();                                                //游戏结束界面
  18. void endgame();                                            //游戏结束
  19. void choose();                                                //游戏失败之后的选择
  20. void File_out();                                        //在文件中读取最高分
  21. void File_in();                                                //储存最高分文件
  22. void explation();                                        //游戏说明
游戏欢迎界面
  1. /********************游戏欢迎界面***********************/
  2. int color(int c)      //颜色函数
  3. {
  4.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),c);//更改文字颜色
  5.         return 0;
  6. }
  8. void gotoxy(int x,int y)    //设置光标位置
  9. {
  10.         COORD c;
  11.         c.X=x;
  12.         c.Y=y;
  13.         SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),c);
  14. }
  15. void printsnake()
  16. {
  17.         int i,j=10;
  18.     gotoxy(37,21);
  19.         color(14);
  20.         printf("        张        洋        贪        吃        蛇\n                                                欢        迎        你！");
  21.         gotoxy(19-1,9);
  22.         color(12);
  23.         printf("张洋");
  24.         gotoxy(23-1,9);
  25.         color(12);
  26.         printf("张洋");       
  27.         gotoxy(27-1,9);
  28.         color(12);
  29.         printf("张洋");       
  30.         gotoxy(27-1,11);
  31.         color(12);
  32.         printf("张洋");
  33.         gotoxy(19-1,13);
  34.         color(12);
  35.         printf("张洋");
  36.         gotoxy(23-1,13);
  37.         color(12);
  38.         printf("张洋");       
  39.         gotoxy(27-1,13);
  40.         color(12);
  41.         printf("张洋");       
  42.         for(i=20;i<28;i++)
  43.         {
  44.         gotoxy(i+10,j);
  45.         color(j-10);
  46.         printf("张洋");
  47.     j++;       
  48.         }
  49.         for(i=30;i<38;i++)
  50.         {
  51.         gotoxy(i+10,j);
  52.         color(j-10);
  53.         printf("张洋");
  54.     j--;
  55.         }
  56.         for(i=40;i<48;i++)
  57.         {
  58.         gotoxy(i+10,j);
  59.         color(j-10);
  60.         printf("张洋");
  61.     j++;       
  62.         }
  63.         for(i=50;i<58;i++)
  64.         {
  65.         gotoxy(i+10,j);
  66.         color(j-10);
  67.         printf("张洋");
  68.     j--;
  69.         }
  70.         for(i=60;i<68;i++)
  71.         {
  72.         gotoxy(i+10,j);
  73.         color(j-10);
  74.         printf("张洋");
  75.     j++;       
  76.         }
  77.         for(i=70;i<77;i++)
  78.         {
  79.         gotoxy(i+10,j);
  80.         color(j-10);
  81.         printf("张洋");
  82.     j--;
  83.         }
  84.         gotoxy(87,11);
  85.         color(11);
  86.         printf("张洋");
  87.     gotoxy(91,11);
  88.         color(11);
  89.         printf("张洋");
  90.         gotoxy(95,11);
  91.         color(11);
  92.         printf("张洋");
  93.         gotoxy(99,11);
  94.         color(11);
  95.         printf("张洋");
  96.           
  97. }
  98.     /*************************主函数******************************************/
  99.     int main()
  100. {
  101.         system("mode con cols=140 lines=40");//设置控制台的宽高
  102.         printsnake();//绘制字符蛇
  103.         return 0;
  104. }
欢迎界面
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg
/************************* 每个人可根据自己的创意，设计不同的欢迎界面。 **********************/

/************************************************ 开始界面 ********************************************/
  1. void welcome()
  2. {
  3.         int n;
  4.         int i,j=1;
  5.         color(14);
  6.         for (i=24;i<=30;i++)
  7.         {
  8.                 for (j=35;j<=82;j++)
  9.                 {
  10.                         gotoxy(j,i);
  11.                         if(i==24||i==30)
  12.                         {
  13.                                 printf("-");
  14.                         }
  15.                         else if(j==35||j==82)
  16.                         {
  17.                                 printf("|");
  18.                         }
  19.                 }
  20.         }
  21.         color(12);
  22.         gotoxy(45,26);
  23.         printf("1.开始游戏");
  24.         gotoxy(65,26);
  25.         printf("2.游戏说明");
  26.         gotoxy(45,28);
  27.         printf("3.退出游戏");
  28.         gotoxy(48,32);
  29.         color(3);
  30.         printf("请选择[1 2 3]:[ ]\b\b");
  31.         color(14);
  32.         scanf("%d",&n);
  33.         switch(n)
  34.         {
  35.         case 1 :
  36.                 system("cls");//清屏
  37.                 break;
  38.         case 2:
  40.                 break;
  41.         case 3:
  42.                 exit(0);
  43.                 break;
  44.         default:
  45.                 color(12);
  46.                 gotoxy(40,38);
  47.                 printf("请输入1-3之间的数！");
  48.                 getch();  //输入任意键
  49.                 system("cls");  //清屏
  50.                 printsnake();
  51.                 welcome();
  52.         }
  53. }
  54. int main()
  55. {
  56.         system("mode con cols=140 lines=40");//设置控制台的宽高
  57.         printsnake();//绘制字符蛇
  58.         welcome();
  59.         return 0;
  60. }
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg
两个结合在一起，就构成了开始的主界面
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg
游戏主窗体设计
  1. /****************************游戏主窗体设计*********************************/
  2. void createMap()           //创建地图
  3. {
  4.         int i,j;
  5.         for (i=0;i<58;i+=2)
  6.         {
  7.                 gotoxy(i,0);
  8.                 color(5);
  9.                 printf("□");
  10.                 gotoxy(i,26);
  11.                 printf("□");
  12.         }
  13.         for (i=1;i<26;i++)
  14.         {
  15.                 gotoxy(0,i);
  16.                 printf("□");
  17.                 gotoxy(56,i);
  18.                 printf("□");
  19.         }
  20.         for (i=2;i<56;i+=2)
  21.         {
  22.                 for (j=1;j<26;j++)
  23.                 {
  24.                         gotoxy(i,j);
  25.                         color(3);
  26.                         printf("■\n\n");
  27.                 }
  28.         }
  29. }
  30. /*********************游戏右侧的得分和小提示******************/
  31. void scoreandtips()
  32. {
  33.         int i;
  34.         File_out();                                                         //调用File_out(),读取文件中的内容
  35.         gotoxy(74,4);
  36.         color(11);
  37.         printf("▂▄▅最高纪录▄▃▂:%d",HighScore);//打印游戏最高分
  38.         gotoxy(74,8);
  39.         color(14);
  40.         printf("得分: %d  ",score);
  41.         color(13);
  42.         gotoxy(83,11);
  43.         printf("小 提 示");
  44.         gotoxy(70,13);
  45.         color(6);
  46.         printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓");
  47.         for (i=15;i<25;i=i+2)
  48.         {
  49.                 gotoxy(70,i);
  50.                 printf("┃");
  51.         }
  52.         for (i=15;i<25;i=i+2)
  53.         {
  54.                 gotoxy(103,i);
  55.                 printf("┃");
  56.         }
  57.         gotoxy(70,25);
  58.         printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛");
  59.         color(3);
  60.         gotoxy(74,14);
  61.         printf("每个事物得分:%d 分",add);
  62.         gotoxy(74,16);
  63.         printf("不能穿墙，不能咬到自己");
  64.         gotoxy(74,18);
  65.         printf("用↑↓←→分别控制蛇的移动");
  66.         gotoxy(74,20);
  67.         printf("F1加速，F2减速");
  68.         gotoxy(74,22);
  69.         printf("space:暂停游戏");
  70.         gotoxy(74,24);
  71.         printf("ESC:退出游戏");
  72. }
  73. /***************在文件中读取最高分*******************/
  74. void File_out()
  75. {
  76.         FALSE *fp;
  77.         fp=fopen("save.txt","a+");                //打开文件save.txt
  78.         fscanf(fp,"%d",&HighScore);
  79.         fclose(fp);
  80. }
  81. /*****************主函数****************************/
  82. int main()
  83. {
  84.         system("mode con cols=120 lines=40");//设置控制台的宽高
  85.         printsnake();//绘制字符蛇
  86.         welcome();//欢迎界面
  87.         File_out()；
  88.         return 0;
  89. }
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg

在C语言中的文件调用，保存一定要学好，才能在这里灵活运用。

绘制蛇身和蛇食物

  1. /******************* 绘制蛇身************************/
  2.     void initsnake()
  3.     {
  4.             snake *tail;
  5.             int i;
  6.             tail=(snake*)malloc(sizeof(snake));  //从蛇尾开始，头插法，以X,Y设定开始的位置
  7.             tail->x=24;                          //蛇的初始位置（24，5）
  8.             tail->y=5;
  9.             tail->next=NULL;
  10.             for (i=1;i<=4;i++)                     //初始长度为5
  11.             {
  12.                     head=(snake*)malloc(sizeof(snake));//初始化蛇头
  13.                     head->next=tail;                   //蛇头的下一位为蛇尾
  14.                     head->x=24+2*i;                    //设置蛇头位置
  15.                     head->y=5;
  16.                     tail=head;                         //蛇头变成蛇尾，然后重复循环
  17.             }
  18.             while (tail!=NULL)                     //从头到尾，输出蛇身
  19.             {
  20.                     gotoxy(tail->x,tail->y);
  21.                     color(14);
  22.                     printf("⊕");               //输出蛇身
  23.                     tail=tail->next;           //蛇头输出完毕，输出蛇头的下一位，一直输出到蛇尾
  24.             }
  25.     }
  27. /*************绘制食物******************************/
  28. void createfood()
  29. {
  30.         snake *food_1;
  31.         srand((unsigned)time(NULL));                                //初始化随机数
  32.         food_1=(snake*)malloc(sizeof(snake));       //初始化food_1
  33.         //保证其为偶数，使得食物能与蛇头对齐，然后食物会出现在网格线上
  34.         while ((food_1->x%2)!=0)
  35.         {
  36.                 food_1->x=rand()%52+2;           //设置食物的X坐标随机出现，食物的x坐标在2-53
  37.         }
  38.         food_1->y=rand()%24+1;             //食物的Y坐标在1-24
  39.         q=head;
  40.         while (q->next==NULL)
  41.         {
  42.                 if (q->x==food_1->x&&q->y==food_1->y)  //判断蛇身是否与食物重合
  43.                 {
  44.                         free(food_1);           //如果食物与蛇身重合，那么释放食物指针
  45.                         createfood ();          //重新创建食物
  46.                 }
  47.                 q=q->next;
  48.         }
  49.         gotoxy(food_1->x,food_1->y);    //设置食物位置
  50.         food=food_1;
  51.         color(12);
  52.         printf("▼");             //输出食物
  54. }

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg



此时贪吃蛇的游戏界面就已经大致做好，剩下的是进行游戏需要的逻辑等；

游戏逻辑
  1. /**********************************游戏逻辑**********************************/
  2.    
  3.     /*********************判断是否咬到自己*****************/
  4.     int biteself()
  5.     {
  6.             snake *self;                                                                //定义self为蛇身上的一个节点
  7.             self=head->next;                                                        //self是蛇头之外的蛇身上的节点
  8.             while(self!=NULL)
  9.             {
  10.                     if (self->x==head->x&&self->y==head->y)   //如果self和蛇头上的节点重合
  11.                     {
  12.                             return 1；                                                      //返回1
  13.                     }
  14.                     self=self->next;                                             //循环蛇上的每一个节点
  15.             }
  16.             return 0;
  17.     }
  18.     /************判断蛇是否撞到墙******************/
  19.     void cantcrosswall()
  20.     {
  21.             if (head->x==0||head->x==56||head->y==0||head->y==26)//如果蛇头碰到了墙壁
  22.             {
  23.                     endgamestatus=1;                                              //返回第一种情况
  24.             }
  25.     }
  26.     /*******************设置蛇加速前进**********/
  27.     void speedup()
  28.     {
  29.             if (sleeptime>=50)                                                   //如果时间间隔大于等于50
  30.             {
  31.                     sleeptime=sleeptime-10;                                   //时间间隔减10
  32.                      add=add+2;                               //每吃一次食物的得分加2
  33.                     if(sleeptime==320)
  34.                     {
  35.                             add=2;                                //防止减到1之后再加回来有错
  36.                     }
  37.             }
  38.     }
  39.     /*******************设置蛇减速前进************/
  40.     void speeddown()
  41.     {
  42.             if (sleeptime<350)                                       //如果时间间隔小于350
  43.             {
  44.                     sleeptime=sleeptime+30;                               //时间间隔加上30
  45.                     add=add-2;                                                 //没吃一次食物的得分减2
  46.                     if (sleeptime==350)
  47.                     {
  48.                             add=1;                                                 //保证最低分为1
  49.                     }
  50.             }
  51.     }
  52.     /******************控制方向*************************/
  53. void  snakemove()
  54. {
  55.         snake *nexthead;
  56.         cantcrosswall();
  57.         nexthead=(snake*)malloc(sizeof(snake));  //为下一步开辟空间
  58.         if (status==W)
  59.         {
  60.                 nexthead->x=head->x;    //向上前进时，x坐标不变，y坐标-1
  61.                 nexthead->y=head->y-1;
  62.                 nexthead->next=head;
  63.                 q=head;                //指针q指向蛇头
  64.                 //如果下一个有食物，下一个位置的坐标和食物的坐标相同
  65.                 if (nexthead->x==food->x&&nexthead->y==food->y)
  66.                 {
  67.                         while (q!=NULL)
  68.                         {
  69.                                 gotoxy(q->x,q->y);
  70.                                 color(14);
  71.                                 printf("⊕");    //原来食物的位置，从▼变成⊕
  72.                                 q=q->next;       //指针q指向的蛇身的下一位也执行循环里的操作
  73.                         }
  74.                         score=score+add;      //吃了一个食物，在总分上加上食物的分
  75.                         speedup();
  76.                         createfood();         //创建食物
  77.                 }
  78.                 else
  79.                 {
  80.                         while (q->next->next!=NULL)
  81.                         {
  82.                                 gotoxy(q->x,q->y);
  83.                                 color(14);
  84.                                 printf("⊕");    //蛇正常往前走，输出当前位置的蛇身
  85.                                 q=q->next;       //继续输出整个蛇身
  86.                                
  87.                         }
  88.                         //经过上面的循环，q指向蛇尾，蛇尾的下一位，就是蛇走过去的位置
  89.                         gotoxy(q->next->x,q->next->y);
  90.                         color(3);
  91.                         printf("■");
  92.                         free(q->next);     //进行输出▼之后，释放指向下一位的指针
  93.                         q->next=NULL;     //指针下一位指向空
  94.                 }
  95.         }
  96.         ///
  97.         if (status==S)                 
  98.         {
  99.                 nexthead->x=head->x;    //向上前进时，x坐标不变，y坐标+1
  100.                 nexthead->y=head->y+1;
  101.                 nexthead->next=head;
  102.                 q=head;                //指针q指向蛇头
  103.                 //如果下一个有食物，下一个位置的坐标和食物的坐标相同
  104.                 if (nexthead->x==food->x&&nexthead->y==food->y)
  105.                 {
  106.                         while (q!=NULL)
  107.                         {
  108.                                 gotoxy(q->x,q->y);
  109.                                 color(14);
  110.                                 printf("⊕");    //原来食物的位置，从▼变成⊕
  111.                                 q=q->next;       //指针q指向的蛇身的下一位也执行循环里的操作
  112.                         }
  113.                         score=score+add;      //吃了一个食物，在总分上加上食物的分
  114.                         speedup();
  115.                         createfood();         //创建食物
  116.                 }
  117.                 else
  118.                 {
  119.                         while (q->next->next!=NULL)
  120.                         {
  121.                                 gotoxy(q->x,q->y);
  122.                                 color(14);
  123.                                 printf("⊕");    //蛇正常往前走，输出当前位置的蛇身
  124.                                 q=q->next;       //继续输出整个蛇身
  125.                                
  126.                         }
  127.                         //经过上面的循环，q指向蛇尾，蛇尾的下一位，就是蛇走过去的位置
  128.                         gotoxy(q->next->x,q->next->y);
  129.                         color(3);
  130.                         printf("■");
  131.                         free(q->next);     //进行输出▼之后，释放指向下一位的指针
  132.                         q->next=NULL;     //指针下一位指向空
  133.                 }
  134.         }
  135.         /
  136.         if (status==A)
  137.         {
  138.                 nexthead->x=head->x-2;    //向左前进时，x坐标向左移动-2，y坐标不变
  139.                 nexthead->y=head->y;
  140.                 nexthead->next=head;
  141.                 q=head;                //指针q指向蛇头
  142.                 //如果下一个有食物，下一个位置的坐标和食物的坐标相同
  143.                 if (nexthead->x==food->x&&nexthead->y==food->y)
  144.                 {
  145.                         while (q!=NULL)
  146.                         {
  147.                                 gotoxy(q->x,q->y);
  148.                                 color(14);
  149.                                 printf("⊕");    //原来食物的位置，从▼变成⊕
  150.                                 q=q->next;       //指针q指向的蛇身的下一位也执行循环里的操作
  151.                         }
  152.                         score=score+add;      //吃了一个食物，在总分上加上食物的分
  153.                         speedup();
  154.                         createfood();         //创建食物
  155.                 }
  156.                 else
  157.                 {
  158.                         while (q->next->next!=NULL)
  159.                         {
  160.                                 gotoxy(q->x,q->y);
  161.                                 color(14);
  162.                                 printf("⊕");    //蛇正常往前走，输出当前位置的蛇身
  163.                                 q=q->next;       //继续输出整个蛇身
  164.                                
  165.                         }
  166.                         //经过上面的循环，q指向蛇尾，蛇尾的下一位，就是蛇走过去的位置
  167.                         gotoxy(q->next->x,q->next->y);
  168.                         color(3);
  169.                         printf("■");
  170.                         free(q->next);     //进行输出▼之后，释放指向下一位的指针
  171.                         q->next=NULL;     //指针下一位指向空
  172.                 }
  173.         }
  174.         /
  175.         if (status==D)
  176.         {
  177.                 nexthead->x=head->x+2;    //向右前进时，x坐标向左移动+2，y坐标不变
  178.                 nexthead->y=head->y;
  179.                 nexthead->next=head;
  180.                 q=head;                //指针q指向蛇头
  181.                 //如果下一个有食物，下一个位置的坐标和食物的坐标相同
  182.                 if (nexthead->x==food->x&&nexthead->y==food->y)
  183.                 {
  184.                         while (q!=NULL)
  185.                         {
  186.                                 gotoxy(q->x,q->y);
  187.                                 color(14);
  188.                                 printf("⊕");    //原来食物的位置，从▼变成⊕
  189.                                 q=q->next;       //指针q指向的蛇身的下一位也执行循环里的操作
  190.                         }
  191.                         score=score+add;      //吃了一个食物，在总分上加上食物的分
  192.                         speedup();
  193.                         createfood();         //创建食物
  194.                 }
  195.                 else
  196.                 {
  197.                         while (q->next->next!=NULL)
  198.                         {
  199.                                 gotoxy(q->x,q->y);
  200.                                 color(14);
  201.                                 printf("⊕");    //蛇正常往前走，输出当前位置的蛇身
  202.                                 q=q->next;       //继续输出整个蛇身
  203.                                
  204.                         }
  205.                         //经过上面的循环，q指向蛇尾，蛇尾的下一位，就是蛇走过去的位置
  206.                         gotoxy(q->next->x,q->next->y);
  207.                         color(3);
  208.                         printf("■");
  209.                         free(q->next);     //进行输出▼之后，释放指向下一位的指针
  210.                         q->next=NULL;     //指针下一位指向空
  211.                 }
  212.         }
  213.         if (biteself()==1)                        //判断是否会咬到自己
  214.         {
  215.                 endgamestatus=2;
  216.         }
  217. }
  218. /******************************* 键盘 ************************************/
  219. void key()
  220. {
  221.         status=R;                                        //初始蛇向右移动
  222.         while (1)
  223.         {
  224.                 scoreandtips();           //游戏界面右侧的得分和小提醒
  225. //GetAsyncKeyState函数 用来判断函数调用时指定虚拟键的状态
  226.                 if (GetAsyncKeyState(VK_UP)&&status!=S)
  227.                 {
  228.                         status=W;      //如果蛇不是向下前进的时候，按向上键，执行向上前进操作
  229.                 }
  230.                 else if (GetAsyncKeyState(VK_DOWN)&&status!=W)
  231.                 {
  232.                         status=S;      //如果蛇不是向上前进的时候，按向下键，执行向下前进操作
  233.                 }
  234.                 else if (GetAsyncKeyState(VK_LEFT)&&status!=D)
  235.                 {
  236.                         status=A;      //如果蛇不是向右前进的时候，按向左键，执行向左前进操作
  237.                 }
  238.                 else if (GetAsyncKeyState(VK_RIGHT)&&status!=A)
  239.                 {
  240.                         status=D;      //如果蛇不是向左前进的时候，按向右键，执行向右前进操作
  241.                 }
  242.                 if (GetAsyncKeyState(VK_SPACE))     //按下暂停键，执行pause暂停函数
  243.                 {
  244.                         while (1)
  245.                         {
  246.         //Sleep()函数，头文件#include <unistd.h>另进程暂停，直到达到里面设定参数的时间
  247.                                 Sleep(300);
  248.                                 if (GetAsyncKeyState(VK_SPACE))  //按下空格键暂停
  249.                                 {
  250.                                         break;
  251.                                 }
  252.                         }
  253.                 }
  254.                 else if (GetAsyncKeyState(VK_ESCAPE))
  255.                 {
  256.                         endgamestatus=3;   //按ESC,直接到结束界面
  257.                         break;
  258.                 }
  259.                 else if (GetAsyncKeyState(VK_F1))   //按F1，加速
  260.                 {
  261.                         speedup();
  262.                 }
  263.                 else if (GetAsyncKeyState(VK_F2))   //按F2，减速
  264.                 {
  265.                         if (sleeptime<350)            //如果时间间隔小于350
  266.                         {
  267.                                 sleeptime=sleeptime+30;  //时间间隔加上30
  268.                                 add=add-2;                //没吃一次食物的得分减2
  269.                                 if (sleeptime==350)
  270.                                 {
  271.                                         add=1;                //保证最低分为1
  272.                                 }
  273.                         }
  274.                 }
  275.                 Sleep(sleeptime);                 //不按键时，蛇保持前行
  276.                 snakemove();
  277.         }
  278. }
  279. /*****************主函数****************************/
  280. int main()
  281. {
  282.         system("mode con cols=120 lines=40");        //设置控制台的宽高
  283.         printsnake();                                                        //绘制字符蛇
  284.         welcome();                                                                //欢迎界面
  285.         File_out()；
  286.         key();
  287.         return 0;
  288. }
游戏失败界面
  1. /************************失败界面*********************/
  2. void Lostdraw()
  3. {   
  4.         int k;
  5.         system("cls");
  6.         gotoxy(50,2);
  7.         printf("∑游戏结果");
  8.         gotoxy(17,5);
  9.         color(11);
  10.         printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
  11.         printf("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓");
  12.         for (k=7;k<=18;k++)  //竖边框
  13.         {
  14.                 gotoxy(17,k);
  15.                 printf("┃");
  16.                 gotoxy(82,k);
  17.                 printf("┃");
  18.         }
  19.         gotoxy(17,20);
  20.         printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
  21.         printf("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛");
  22. }
  23. /****************************结束游戏*****************/
  24. void endgame()
  25. {
  26.         system("cls");
  27.         if (endgamestatus==1)   //如果蛇撞到了墙
  28.         {
  29.                 Lostdraw();
  30.                 gotoxy(35,9);
  31.                 color(12);
  32.                 printf("对不起，你头铁也撞不烂墙。游戏结束");
  33.         }
  34.         else if (endgamestatus==2)  //如果蛇咬到了自己
  35.         {
  36.                 Lostdraw();
  37.                 gotoxy(35,9);
  38.                 color(12);
  39.                 printf("对不起，你咬到了自己，游戏结束！");
  40.         }
  41.         else if (endgamestatus==3)  //如果按ESC键退出
  42.         {
  43.                 Lostdraw();
  44.                 gotoxy(40,9);
  45.                 color(12);
  46.                 printf("你已经结束了游戏！");
  47.         }
  48.         gotoxy(43,12);
  49.         color(13);
  50.         printf("你的得分是 %d",score);
  51.         if (score>=HighScore)
  52.         {
  53.                 color(10);
  54.                 gotoxy(40,16);
  55.                 printf("牛逼，创纪录了！!");
  56.                 File_in();     //把最高分写进文件
  57.         }
  58.         else                  //如果低于最高分
  59.         {
  60.                 color(10);
  61.                 gotoxy(35,16);
  62.                 printf("继续努力啊，你离最高分还差：%d",HighScore-score);
  63.         }
  64.         choose();    //边框下面的分支选项
  65. }
  66. /********************边框下面的分支选项************/
  67. void choose()
  68. {
  69.         int m;
  70.         gotoxy(25,23);
  71.         color(12);
  72.         printf("我要重新玩一把-------- 1");
  73.         gotoxy(52,23);
  74.         printf("不玩了，退出-------- 2");
  75.         gotoxy(46,25);
  76.         color(11);
  77.         printf("选择： ");
  78.         scanf("%d",&m);
  79.         switch(m)
  80.         {
  81.         case 1:
  82.                 system("cls");   //清屏
  83.                 score=0;        //分数归零
  84.                 sleeptime=200;   //设定初始速度
  85.                 add=10;         //使add设为初值，吃一个食物得十分，然后累加
  86.                 printsnake();   //返回欢迎界面
  87.                 welcome();
  88.                 break;
  89.         case 2:
  90.                 exit(0);             //退出游戏
  91.                 break;
  92.         default:           //输入1或2以外的数字
  93.                 gotoxy(35,27);
  94.                 color(12);
  95.                 printf("不要瞎输入，请重新输入");
  96.                 system("pause>nul");     //按任意键
  97.                 endgame();
  98.                 choose();  //边框下面的分支语句
  99.                 break;
  100.         }
  101. }
  103. /*****************主函数****************************/
  104. int main()
  105. {
  106.         system("mode con cols=120 lines=40");        //设置控制台的宽高
  107.         printsnake();                                                        //绘制字符蛇
  108.         welcome();                                                                //欢迎界面
  109.         File_out();                             //读取文件信息
  110.         keyjianpan();                           //控制键盘按键
  111.         endgame();                              //游戏结束
  112.         return 0;       
  113. }
注：此时还要记住在前面蛇不同的失败函数里加上endgame（）；
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg
游戏说明
  1. /*********************游戏说明************************/
  2. void explation()
  3. {
  4.         int i,j=1;
  5.         system("cls");
  6.         color(13);
  7.         gotoxy(52,3);
  8.         printf("游戏说明");
  9.         color(2);
  10.         for (i=6;i<=22;i++)     //输出上下边框
  11.         {
  12.                 for (j=20;j<=75;j++)
  13.                 {
  14.                         gotoxy(j+10,i);
  15.                         if (i==6||i==22)
  16.                         {
  17.                                 printf("||");
  18.                         }
  19.                 }
  20.         }
  21.         color(3);
  22.         gotoxy(40,8);
  23.         printf("一：不能穿墙，不能咬到自己");
  24.         color(10);
  25.         gotoxy(40,11);
  26.         printf("二：用↑↓←→分别控制蛇的移动");
  27.         color(14);
  28.         gotoxy(40,14);
  29.         printf("三：F1加速，F2减速");
  30.         color(11);
  31.         gotoxy(40,17);
  32.         printf("四：安空格键暂停，再按空格键继续");
  33.         color(4);
  34.         gotoxy(40,20);
  35.         printf("五：ESC：退出游戏，space:暂停游戏");
  36.         getch();//按任意键返回主界面
  37.         system("cls");
  38.         printsnake();
  39.         welcome();
  40. }
watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjI5MTA5,size_16,color_FFFFFF,t_70.jpg