devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言贪吃蛇（详解）——链表实现_c语言贪吃蛇链表

作者：繁依Fanyi0 | 2024-05-17 19:59:12

赞

踩

c语言贪吃蛇链表

贪吃蛇设计思路：

屏幕坐标：

 

拓展功能：

1.F1，F2控制加速减速  空格暂停游戏  Esc退出

2.加速每个食物得分更高

 

 

先打印出游戏界面，还有初始化蛇，蛇的节点用字符串★表示，游戏背景用■表示，因为这些字符串占两个字节的宽度，所以每次x,y坐标的对应关系是x=y*2。在相应位置打印出蛇，初始化蛇为五个节点

初始化蛇头的移动方向为右，根据按键来确定蛇的移动状态，要是吃到食物，就让食物为蛇头，然后随机生成食物，

 

 

重点模块：

 

蛇移动的实现：

      定义一个结构体，里面放节点坐标，和next指针。

蛇每次移动是通过用户按键方向来确定下一个蛇头节点的x,y坐标，新建一个节点赋给下一个坐标，在这个坐标打出蛇的图标，找到尾节点，将尾节点打印成背景图标，再将节点释放，这样蛇就动了一下，以此重复，蛇就可以了动态移动。

 

食物的实现：

     定义一个食物节点，也是一个类似于蛇的结构体指针，通过随机数生成坐标，注意不能在墙上和蛇身上。

用户按键的检测：可以使用wasd的字符来确定方向，但这里我们还需要使用空格，ESC键，上下左右键，所以直接一点，通过GetAsyncKeyState( )函数检测用户输入的按键，需要引用头文件conio.h，_getch()函数用来检测当前是否有按键输入，有的话返回非0的数。

蛇的变速:还是通过GetAsyncKeyState( )函数检测F1，F2,键来确定蛇移动一次Sleep()函数中的毫秒数，这样就实现了蛇的加速减速。而且蛇每移动一次，不必使用system（“cls")来清屏，通过在循环中snakemove()执行一次，Sleep()函数执行一次，就实现了动态移动。

 

 

 

实现效果：

 

完整代码：

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<stdio.h>			
  3. #include<time.h>			
  4. #include<windows.h>		
  5. #include<stdlib.h>			
  6. #include<conio.h>			//接收键盘输入输出
  7.  
  8.  
  9. #define U 1
  10. #define D 2
  11. #define L 3 
  12. #define R 4      //蛇的状态，U：上 ；D：下；L:左 R：右
  13.  
  14. /*******定  义  全  局  变  量 *******/
  15. typedef struct snake 		//蛇身的一个节点
  16. {
  17.     int x;
  18.     int y;
  19.     struct snake *next;
  20. }snake;
  21. int score=0,add=10;			//总得分与每次吃食物得分
  22. int status,sleeptime=200;	//蛇前进状态，每次运行的时间间隔
  23. snake *head, *food;			//蛇头指针，食物指针
  24. snake *q;					//遍历蛇的时候用到的指针
  25. int endgamestatus=0;		//游戏结束的情况，1：撞到墙；2：咬到自己；3：主动退出游戏。
  26. HANDLE hOut;				//控制台句柄
  27.  
  28.  
  29. /*******函  数  声  明 *******/
  30. void gotoxy(int x,int y);   //设置光标位置
  31. int color(int c);           //更改文字颜色
  32. void welcometogame();       //开始界面
  33. void createMap();           //绘制地图
  34. void scoreandtips();		//游戏界面右侧的得分和小提示
  35. void initsnake();           //初始化蛇身，画蛇身
  36. void createfood();          //创建并随机出现食物
  37. int biteself();             //判断是否咬到了自己
  38. void cantcrosswall();       //设置蛇撞墙的情况
  39. void speedup();				//加速
  40. void speeddown();			//减速
  41. void snakemove();           //控制蛇前进方向
  42. void keyboardControl();     //控制键盘按键
  43. void Lostdraw();            //游戏结束界面
  44. void endgame();             //游戏结束
  45. void choose();				//游戏失败之后的选择
  46. void explation();           //游戏说明
  47.  
  48. /**
  49.  * 设置光标位置
  50.  */
  51. void gotoxy(int x,int y)
  52. {
  53.     COORD c;
  54.     c.X=x;
  55.     c.Y=y;
  56.     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),c);
  57. }
  58.  
  59. /**
  60.  * 文字颜色函数     
  61.  */
  62. int color(int c)
  63. {
  64. 	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c);        //更改文字颜色
  65. 	return 0;
  66. }
  67.  
  68.  
  69.  
  70.   //开始界面
  71.  
  72. void welcometogame()
  73. {
  74. 	int n;
  75. 	gotoxy(43,10);
  76. 	color(11);
  77. 	printf("贪 吃 蛇 大 作 战");
  78. 	color(12);
  79. 	gotoxy(25, 22);
  80. 	printf("1.开始游戏");
  81. 	gotoxy(45, 22);
  82. 	printf("2.游戏说明");
  83. 	gotoxy(65, 22);
  84. 	printf("3.退出游戏");
  85. 	gotoxy(40,27);
  86. 	color(3);
  87. 	printf("请选择 1 2 3:");       
  88. 	color(14);
  89.     scanf("%d", &n);    		//输入选项
  90.     switch (n)
  91.     {
  92.     	case 1:
  93.     		system("cls");
  94. 			createMap();        //创建地图
  95.     		initsnake();        //初始化蛇身
  96.     		createfood();       //创建食物
  97.     		keyboardControl();	//按键控制
  98.         	break;
  99.     	case 2:
  100.         	explation();      	//游戏说明函数
  101.         	break;
  102.     	case 3:
  103.         	exit(0);     		//退出游戏
  104.         	break;
  105. 		default:				
  106. 			color(12);
  107. 			gotoxy(40,28);
  108. 			printf("请输入1—3之间的数!");
  109. 			_getch();			//输入任意键
  110. 			system("cls");		//清屏
  111. 			welcometogame();
  112.     }
  113. }
  114.  
  115.  
  116.  //创建地图
  117.  
  118. void createMap()
  119. {
  120.     int i,j;
  121.     for(i=0;i<58;i+=2)		//打印上下边框
  122.     {
  123.         gotoxy(i,0);
  124. 		color(5);			
  125.         printf("□");
  126.         gotoxy(i,26);
  127.         printf("□");
  128.     }
  129.     for(i=1;i<26;i++)		//打印左右边框
  130.     {
  131.         gotoxy(0,i);
  132.         printf("□");                        
  133.         gotoxy(56,i);
  134.         printf("□");        
  135.     }
  136. 	for(i = 2;i<56;i+=2)	//打印中间网格
  137. 	{
  138. 		for(j = 1;j<26;j++)
  139. 		{
  140. 			gotoxy(i,j);
  141. 			color(3);
  142. 			printf("■");
  143. 		}
  144. 	}
  145. }
  146.  
  147.  
  148.  //  游戏界面右侧的得分和小提示
  149.  
  150. void scoreandtips()
  151. {
  152. 	
  153. 	gotoxy(64,8);
  154. 	color(14);
  155. 	printf("得分：%d  ",score);
  156. 	
  157. 	gotoxy(64,14);
  158. 	printf("每个食物得分：%d分",add);
  159. 	gotoxy(64,16);
  160. 	printf("不能穿墙，不能咬到自己");
  161. 	gotoxy(64,18);
  162. 	printf("用↑ ↓ ← →分别控制蛇的移动");
  163. 	gotoxy(64,20);
  164. 	printf("F1 为加速，F2 为减速");
  165. 	gotoxy(64,22);
  166. 	printf("space：暂停游戏");
  167. 	gotoxy(64,24);
  168.     printf("ESC ：退出游戏");
  169. }
  170.  
  171.  
  172.   //初始化蛇身，画蛇身
  173.  
  174. void initsnake()
  175. {
  176.     snake *tail;
  177.     int i;
  178.     tail=(snake*)malloc(sizeof(snake));//从蛇尾开始，头插法，以x,y设定开始的位置
  179.     tail->x=24;         	//蛇的初始位置（24,5）
  180.     tail->y=5;
  181.     tail->next=NULL;
  182.     for(i=1;i<=4;i++)       //设置蛇身，长度为5
  183.     {
  184.         head=(snake*)malloc(sizeof(snake)); //初始化蛇头
  185.         head->next=tail;        //蛇头的下一位为蛇尾
  186.         head->x=24+2*i;         //设置蛇头位置
  187.         head->y=5;
  188.         tail=head;              //蛇头变成蛇尾，然后重复循环
  189.     }
  190.     while(tail!=NULL)		//从头到尾，输出蛇身
  191.     {
  192.         gotoxy(tail->x,tail->y);
  193. 		color(14);
  194.         printf("★");       //输出蛇身，蛇身使用★组成
  195.         tail=tail->next;    //蛇头输出完毕，输出蛇头的下一位，一直输出到蛇尾
  196.     }
  197. }
  198.  
  199.  /**
  200.  * 随机出现食物
  201.  */
  202. void createfood()
  203. {
  204.     snake *food_1;
  205.     srand((unsigned)time(NULL));        	//初始化随机数
  206.     food_1=(snake*)malloc(sizeof(snake));   //初始化food_1
  207.     while((food_1->x%2)!=0)    				//保证其为偶数，使得食物能与蛇头对其，然后食物会出现在网格线上
  208.     {
  209.         food_1->x=rand()%52+2;              //食物随机出现
  210.     }
  211.     food_1->y=rand()%24+1;
  212.     q=head;
  213.     while(q->next==NULL)
  214.     {
  215.         if(q->x==food_1->x && q->y==food_1->y) //判断蛇身是否与食物重合
  216.         {
  217.             free(food_1);               //如果蛇身和食物重合，那么释放食物指针
  218.             createfood();               //重新创建食物
  219.         }
  220.         q=q->next;
  221.     }
  222.     gotoxy(food_1->x,food_1->y);
  223.     food=food_1;
  224. 	color(12);
  225.     printf("●");           //输出食物
  226. }
  227.  
  228.  /**
  229.  * 判断是否咬到了自己
  230.  */
  231. int biteself()
  232. {
  233.     snake *self;            //定义self为蛇身上的一个节点
  234.     self=head->next;        //self是蛇头之外的蛇身上的节点
  235.     while(self!=NULL)
  236.     {
  237.         if(self->x==head->x && self->y==head->y)    //如果self和蛇身上的节点重合
  238.         {
  239.             return 1;       //返回1
  240.         }
  241.         self=self->next;
  242.     }
  243.     return 0;
  244. }
  245.  
  246.  /**
  247.  * 设置蛇撞墙的情况
  248.  */
  249. void cantcrosswall()
  250. {  
  251.     if(head->x==0 || head->x==56 ||head->y==0 || head->y==26) //如果蛇头碰到了墙壁
  252.     {
  253.         endgamestatus=1;        //返回第一种情况
  254.         endgame();              //出现游戏结束界面
  255.     }
  256. }
  257.  
  258.  
  259.  
  260. /**
  261.  *  加速，蛇吃到食物会自动提速，并且按F1会加速
  262.  */
  263. void speedup()
  264. {
  265. 	if(sleeptime>=50)
  266. 	{
  267. 		sleeptime=sleeptime-10;
  268. 		add=add+2;
  269.  
  270.     }
  271. }
  272.  
  273. /**
  274.  *  加速，按F2会减速
  275.  */
  276. void speeddown()
  277. {
  278. 	if(sleeptime<350)               //如果时间间隔小于350
  279.     {
  280.         sleeptime=sleeptime+30;     //时间间隔加上30
  281.         add=add-2;                  //每吃一次食物的得分减2
  282.  
  283.     }
  284. }
  285.  
  286. /**
  287.  *  控制方向    问题：为什么要设置status，而不使用前两章中接收键盘按键的方法
  288.  */
  289. void snakemove()	//蛇前进,上U,下D,左L,右R
  290. {
  291. 	snake * nexthead;
  292.     cantcrosswall();
  293.     nexthead=(snake*)malloc(sizeof(snake));		//为下一步开辟空间
  294.     if(status==U)
  295.     {
  296.         nexthead->x=head->x;        //向上前进时，x坐标不动，y坐标-1
  297.         nexthead->y=head->y-1;
  298.         nexthead->next=head;
  299.         head=nexthead;
  300.         q=head;                 //指针q指向蛇头
  301.         if(nexthead->x==food->x && nexthead->y==food->y)	//如果下一个有食物 下一个位置的坐标和食物的坐标相同
  302.         {
  303.             
  304.             while(q!=NULL)
  305.             {
  306.                 gotoxy(q->x,q->y);
  307. 				color(14);
  308.                 printf("★");       //原来食物的位置，从●换成★
  309.                 q=q->next;          //指针q指向的蛇身的下一位也执行循环里的操作
  310. 				
  311.             }
  312.             score=score+add;        //吃了一个食物，在总分上加上食物的分
  313. 			speedup();
  314.             createfood();           //创建食物
  315.         }
  316.         else                        
  317.         {
  318.             while(q->next->next!=NULL)	//如果没遇到食物
  319.             {
  320.                 gotoxy(q->x,q->y);
  321.                 color(14);
  322.                 printf("★");           //蛇正常往前走，输出当前位置的蛇身
  323.                 q=q->next;              //继续输出整个蛇身
  324.             }
  325.             gotoxy(q->next->x,q->next->y);  //经过上面的循环，q指向蛇尾，蛇尾的下一位，就是蛇走过去的位置
  326. 			color(3);
  327.             printf("■");
  328.             free(q->next);      //进行输出■之后，释放指向下一位的指针
  329.             q->next=NULL;       //指针下一位指向空
  330.         }
  331.     }
  332.     if(status==D)
  333.     {
  334.         nexthead->x=head->x;        //向下前进时，x坐标不动，y坐标+1
  335.         nexthead->y=head->y+1;
  336.         nexthead->next=head;
  337.         head=nexthead;
  338.         q=head;
  339.         if(nexthead->x==food->x && nexthead->y==food->y)  //有食物
  340.         {
  341.             
  342.             while(q!=NULL)
  343.             {
  344.                 gotoxy(q->x,q->y);
  345.                 color(14);
  346.                 printf("★");
  347.                 q=q->next;
  348.             }
  349.             score=score+add;
  350. 			speedup();
  351.             createfood();
  352.         }
  353.         else                               //没有食物
  354.         {
  355.             while(q->next->next!=NULL)
  356.             {
  357.                 gotoxy(q->x,q->y);
  358.                 color(14);
  359.                 printf("★");
  360.                 q=q->next;
  361.             }
  362.             gotoxy(q->next->x,q->next->y);
  363. 			color(3);
  364.             printf("■");
  365.             free(q->next);
  366.             q->next=NULL;
  367.         }
  368.     }
  369.     if(status==L)
  370.     {
  371.         nexthead->x=head->x-2;        //向左前进时，x坐标向左移动-2，y坐标不动
  372.         nexthead->y=head->y;
  373.         nexthead->next=head;
  374.         head=nexthead;
  375.         q=head;
  376.         if(nexthead->x==food->x && nexthead->y==food->y)//有食物
  377.         {
  378.             while(q!=NULL)
  379.             {
  380.                 gotoxy(q->x,q->y);
  381.                 color(14);
  382.                 printf("★");
  383.                 q=q->next;
  384.             }
  385.             score=score+add;
  386. 			speedup();
  387.             createfood();
  388.         }
  389.         else                                //没有食物
  390.         {
  391.             while(q->next->next!=NULL)
  392.             {
  393.                 gotoxy(q->x,q->y);
  394.                 color(14);
  395.                 printf("★");
  396.                 q=q->next;        
  397.             }
  398.             gotoxy(q->next->x,q->next->y);
  399. 			color(3);
  400.             printf("■");
  401.             free(q->next);
  402.             q->next=NULL;
  403.         }
  404.     }
  405.     if(status==R)
  406.     {
  407.         nexthead->x=head->x+2;        //向右前进时，x坐标向右移动+2，y坐标不动
  408.         nexthead->y=head->y;
  409.         nexthead->next=head;
  410.         head=nexthead;
  411.         q=head;
  412.         if(nexthead->x==food->x && nexthead->y==food->y)//有食物
  413.         {
  414.             while(q!=NULL)
  415.             {
  416.                 gotoxy(q->x,q->y);
  417.                 color(14);
  418.                 printf("★");
  419.                 q=q->next;
  420.             }
  421.             score=score+add;
  422. 			speedup();
  423.             createfood();
  424.         }
  425.         else                                         //没有食物
  426.         {
  427.             while(q->next->next!=NULL)
  428.             {
  429.                 gotoxy(q->x,q->y);
  430.                 color(14);
  431.                 printf("★");
  432.                 q=q->next;        
  433.             }
  434.             gotoxy(q->next->x,q->next->y);
  435. 			color(3);
  436.             printf("■");
  437.             free(q->next);
  438.             q->next=NULL;
  439.         }
  440.     }
  441.     if(biteself()==1)       //判断是否会咬到自己
  442.     {
  443.         endgamestatus=2;
  444.         endgame();
  445.     }
  446. }
  447.  
  448.  
  449. /**
  450.  * 控制键盘按键
  451.  */
  452. void keyboardControl()
  453. {
  454. 	status=R;       //初始蛇向右移动
  455.     while(1)
  456.     {
  457. 		scoreandtips();
  458.         if(GetAsyncKeyState(VK_UP) && status!=D)            //GetAsyncKeyState函数用来判断函数调用时指定虚拟键的状态
  459.         {
  460.             status=U;           //如果蛇不是向下前进的时候，按上键，执行向上前进操作
  461.         }
  462.         else if(GetAsyncKeyState(VK_DOWN) && status!=U)     //如果蛇不是向上前进的时候，按下键，执行向下前进操作
  463.         {
  464.             status=D;
  465.         }
  466.         else if(GetAsyncKeyState(VK_LEFT)&& status!=R)      //如果蛇不是向右前进的时候，按左键，执行向左前进
  467.         {
  468.             status=L;
  469.         }
  470.         else if(GetAsyncKeyState(VK_RIGHT)&& status!=L)     //如果蛇不是向左前进的时候，按右键，执行向右前进
  471.         {
  472.             status=R;
  473.         }
  474.         if(GetAsyncKeyState(VK_SPACE))		//按暂停键，执行pause暂停函数
  475.         {
  476.             while(1)
  477. 			{
  478. 				Sleep(300); //sleep()函数，头文件#include <unistd.h>  另进程暂停，知道达到里面设定的参数的时间。
  479. 				if(GetAsyncKeyState(VK_SPACE))      //按空格键暂停
  480. 				{
  481. 					break;
  482. 				}
  483. 				
  484. 			}       
  485.         }
  486.         else if(GetAsyncKeyState(VK_ESCAPE))
  487.         {
  488.             endgamestatus=3;    //按esc键，直接到结束界面
  489.             break;
  490.         }
  491.         else if(GetAsyncKeyState(VK_F1))    //按F1键，加速
  492.         {
  493.             speedup();
  494.         }
  495.         else if(GetAsyncKeyState(VK_F2))    //按F2键，减速
  496.         {
  497.         	speeddown();
  498.             
  499.         }
  500.         Sleep(sleeptime);
  501.         snakemove();
  502.     }
  503. }
  504.  
  505.  
  506.  
  507.  
  508.  
  509.  
  510.  
  511. /*
  512. *   游戏说明
  513. */
  514. void explation()
  515. {
  516. 	//int i,j = 1;
  517.     system("cls");
  518.  //   color(13);
  519.  //   gotoxy(44,3);
  520.  //   printf("游戏说明");
  521.  //   color(2);
  522.  //   for (i = 6; i <= 22; i++)   //输出上下边框===
  523. 	//{
  524. 	//	for (j = 20; j <= 75; j++)  //输出左右边框||
  525. 	//	{
  526. 	//		gotoxy(j, i);
  527. 	//		if (i == 6 || i == 22) printf("=");
  528. 	//		else if (j == 20 || j == 75) printf("||");
  529. 	//	}
  530. 	//}
  531.     color(3);
  532.     gotoxy(30,8);
  533.     printf("1. 不能穿墙，不能咬到自己");
  534.     color(10);
  535.     gotoxy(30,11);
  536.     printf("2. 用↑.↓.←.→分别控制蛇的移动");
  537.     color(14);
  538.     gotoxy(30,14);
  539.     printf("3. F1 为加速，F2 为减速");
  540.     color(11);
  541.     gotoxy(30,17);
  542.     printf("4. 按空格键暂停游戏，再按空格键继续");
  543.     color(4);
  544.     gotoxy(30,20);
  545.     printf("5. ESC ：退出游戏.space：暂停游戏");
  546.     _getch();                //按任意键返回主界面
  547.     system("cls");
  548.     welcometogame();
  549. }
  550.  
  551.  
  552.  
  553. /**
  554.  * 结束游戏
  555.  */
  556. void endgame()
  557. {
  558.     system("cls");
  559.     if(endgamestatus==1)
  560.     {
  561.         
  562. 		//Lostdraw();
  563. 		gotoxy(43,9);
  564.     	color(12);
  565. 		printf("GAME  OVER !");
  566.     }
  567.     else if(endgamestatus==2)
  568.     {
  569.         
  570.         //Lostdraw();
  571.         gotoxy(43,9);
  572.     	color(12);
  573.         printf("GAME  OVER !");
  574.     }
  575.     else if(endgamestatus==3)
  576.     {
  577. 		//Lostdraw();
  578. 		gotoxy(40,9);
  579.     	color(12);
  580.         printf("已结束游戏。");
  581.     }
  582.     gotoxy(43,12);
  583.     color(13);
  584.     printf("你的得分是 %d",score);
  585. 	choose();
  586. }
  587.  
  588. /**
  589.  * 边框下面的分支选项
  590.  */
  591. void choose()
  592. {
  593. 	int n;
  594. 	gotoxy(25,23);
  595. 	color(12);
  596. 	printf("Continue ------ 1");
  597. 	gotoxy(52,23);
  598. 	printf("Exit ------ 2");
  599. 	gotoxy(45,25);
  600. 	color(11);
  601. 	printf("选择： ");
  602. 	scanf("%d", &n);
  603.     switch (n)
  604.     {
  605. 	case 1:
  606. 		system("cls");          //清屏
  607. 		score=0;                //分数归零
  608. 		sleeptime=200;			//设定初始速度
  609. 		add = 10;				//使add设定为初值，吃一个食物得分10，然后累加
  610. 		welcometogame();
  611. 		break;
  612. 	case 2:
  613. 		exit(0);                //退出游戏
  614. 		break;
  615. 	default:
  616. 		gotoxy(35,27);
  617. 		color(12);
  618. 		printf(" 输入有误 重新输入 !");
  619. 		system("pause >nul");
  620. 		endgame();
  621. 		choose();
  622. 		break;
  623. 	}
  624.  
  625. }
  626. /**
  627.  * 失败界面
  628.  */
  629. void Lostdraw()
  630. {
  631. 	system("cls");
  632. 	int i;
  633. 	gotoxy(45,2);
  634. 	color(6);
  635. 	printf("\\\\\\|///");
  636. 	gotoxy(43,3);
  637. 	printf("\\\\");
  638. 	gotoxy(47,3);
  639. 	color(15);
  640. 	printf(".-.-");
  641. 	gotoxy(54,3);
  642. 	color(6);
  643. 	printf("//");
  644.  
  645. 	gotoxy(44,4);
  646. 	color(14);
  647. 	printf("(");
  648.  
  649. 	gotoxy(47,4);
  650. 	color(15);
  651. 	printf(".@.@");
  652.  
  653. 	gotoxy(54,4);
  654. 	color(14);
  655. 	printf(")");
  656.  
  657. 	gotoxy(17,5);
  658. 	color(11);
  659. 	printf("+------------------------");
  660.  
  661. 	gotoxy(35,5);
  662. 	color(14);
  663. 	printf("oOOo");
  664.  
  665. 	gotoxy(39,5);
  666. 	color(11);
  667. 	printf("----------");
  668.  
  669. 	gotoxy(48,5);
  670. 	color(14);
  671. 	printf("(_)");
  672.  
  673. 	gotoxy(51,5);
  674. 	color(11);
  675. 	printf("----------");
  676.  
  677. 	gotoxy(61,5);
  678. 	color(14);
  679. 	printf("oOOo");
  680.  
  681. 	gotoxy(65,5);
  682. 	color(11);
  683. 	printf("-----------------+");
  684. 	
  685. 	for(i = 6;i<=19;i++)        //竖边框
  686. 	{
  687. 		gotoxy(17,i);
  688. 		printf("|");
  689. 		gotoxy(82,i);
  690. 		printf("|");
  691. 	}
  692.  
  693. 	gotoxy(17,20);
  694. 	printf("+---------------------------------");
  695.  
  696. 	gotoxy(52,20);
  697. 	color(14);
  698. 	printf("☆☆☆〃");
  699.  
  700. 	gotoxy(60,20);
  701. 	color(11);
  702. 	printf("----------------------+");
  703.  
  704. }
  705.  
  706. /**
  707. * 主函数
  708. */
  709. int main()
  710. {	
  711. 	system("mode con cols=100 lines=30");   //设置控制台的宽高
  712. 	//printsnake();
  713.     welcometogame();
  714. 	
  715.     keyboardControl();
  716.     endgame();
  717. 	return 0;
  718. }

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/585024
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号