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

c++语言实现贪吃蛇_c++贪吃蛇

作者：小蓝xlanll | 2024-04-10 04:00:05

赞

踩

c++贪吃蛇
  1. 1.完美的贪吃蛇 
  2. #include<windows.h>
  3. #include<time.h>
  4. #include<stdlib.h>
  5. #include<conio.h>
  6. #define N 21
  7. #include<iostream>
  8. using namespace std; 
  9. void gotoxy(int x,int y)//位置函数
  10. {
  11. COORD pos;
  12. pos.X=2*x;
  13. pos.Y=y;
  14. SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
  15. }
  16. void color(int a)//颜色函数
  17. {
  18. SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),a);
  19. }
  20. void init(int apple[2])//初始化函数（初始化围墙、显示信息、苹果）
  21. {
  22. int i,j;//初始化围墙
  23. int wall[N+2][N+2]={{0}};
  24. for(i=1;i<=N;i++)
  25. {
  26. for(j=1;j<=N;j++)
  27. wall[i][j]=1;
  28. }
  29. color(11);
  30. for(i=0;i<N+2;i++)
  31. {
  32. for(j=0;j<N+2;j++)
  33. {
  34. if(wall[i][j])
  35. cout<<"■";
  36. else cout<<"□" ;
  37. }
  38. cout<<endl;
  39. }
  40. gotoxy(N+3,1);//显示信息
  41. color(20);
  42. cout<<"按 W S A D 移动方向"<<endl;
  43. gotoxy(N+3,2);
  44. color(20);
  45. cout<<"按任意键暂停"<<endl;
  46. gotoxy(N+3,3);
  47. color(20);
  48. cout<<"得分："<<endl;
  49. apple[0]=rand()%N+1;//苹果
  50. apple[1]=rand()%N+1;
  51. gotoxy(apple[0],apple[1]);
  52. color(12);
  53. cout<<"●"<<endl;
  54. }
  55. int main()
  56. {
  57. int i,j;
  58. int** snake=NULL;
  59. int apple[2];
  60. int score=0;
  61. int tail[2];
  62. int len=3;
  63. char ch='p';
  64. srand((unsigned)time(NULL));
  65. init(apple);
  66. snake=(int**)realloc(snake,sizeof(int*)*len);
  67. for(i=0;i<len;i++)
  68. snake[i]=(int*)malloc(sizeof(int)*2);
  69. for(i=0;i<len;i++)
  70. {
  71. snake[i][0]=N/2;
  72. snake[i][1]=N/2+i;
  73. gotoxy(snake[i][0],snake[i][1]);
  74. color(14);
  75. cout<<"★"<<endl;
  76. }
  77. while(1)//进入消息循环
  78. {
  79. tail[0]=snake[len-1][0];
  80. tail[1]=snake[len-1][1];
  81. gotoxy(tail[0],tail[1]);
  82. color(11);
  83. cout<<"■"<<endl;
  84. for(i=len-1;i>0;i--)
  85. {
  86. snake[i][0]=snake[i-1][0];
  87. snake[i][1]=snake[i-1][1];
  88. gotoxy(snake[i][0],snake[i][1]);
  89. color(14);
  90. cout<<"★"<<endl;
  91. }
  92. if(kbhit())
  93. {
  94. gotoxy(0,N+2);
  95. ch=getche();
  96. }
  97. switch(ch)
  98. {
  99. case 'w':snake[0][1]--;break;
  100. case 's':snake[0][1]++;break;
  101. case 'a':snake[0][0]--;break;
  102. case 'd':snake[0][0]++;break;
  103. default: break;
  104. }
  105. gotoxy(snake[0][0],snake[0][1]);
  106. color(14);
  107. cout<<"★"<<endl;
  108. Sleep(abs(200-0.5*score));
  109. if(snake[0][0]==apple[0]&&snake[0][1]==apple[1])//吃掉苹果后蛇分数加1，蛇长加1
  110. {
  111. score++;
  112. len++;
  113. snake=(int**)realloc(snake,sizeof(int*)*len);
  114. snake[len-1]=(int*)malloc(sizeof(int)*2);
  115. apple[0]=rand()%N+1;
  116. apple[1]=rand()%N+1;
  117. gotoxy(apple[0],apple[1]);
  118. color(12);
  119. cout<<"●"<<endl;
  120. gotoxy(N+5,3);
  121. color(20);
  122. cout<<score<<endl;
  123. }
  124. if(snake[0][1]==0||snake[0][1]==N||snake[0][0]==0||snake[0][0]==N)//撞到围墙后失败
  125. {
  126. gotoxy(N/2,N/2);
  127. color(30);
  128. cout<<"失败！！！"<<endl;
  129. for(i=0;i<len;i++)
  130. free(snake[i]);
  131. Sleep(INFINITE);
  132. exit(0);
  133. }
  134. }
  135. return 0;
  136. }

  1. 2.有缺陷的贪吃蛇 
  2. #include <stdio.h>
  3. #include <windows.h>
  4. #include <conio.h>
  5. #include <time.h>
  6. //游戏窗口
  7. #define FrameX 4   //游戏窗口左上角的X轴坐标
  8. #define FrameY 4   //游戏窗口左上角的Y轴坐标
  9. #define Frame_height  20 //游戏窗口的高度
  10. #define Frame_width   20 //游戏窗口的宽度
  11. //定义全局变量
  12. int i,j;
  13. int a[2];     //用于记住蛇尾坐标，其中a[0]、a[1]分别表示横、竖坐标
  14. //声明蛇的结构体
  15. struct Snake
  16. {
  17.  int x[100];    //蛇的横坐标，其中x[0]表示蛇尾的横坐标，x[N-1]表示蛇头的横坐标
  18.  int y[100];    //蛇的竖坐标，其中y[0]表示蛇尾的竖坐标，y[N-1]表示蛇头的竖坐标
  19.  int count;    //蛇吃食物的个数
  20.  int length;    //蛇的长度
  21.  int speed;    //蛇的速度
  22. };
  23. //声明食物的结构体
  24. struct Food
  25. {
  26.  int x;     //食物的横坐标
  27.  int y;     //食物的竖坐标
  28. };
  29. /******光标移到指定位置**************************************************************/
  30. void gotoxy(HANDLE hOut, int x, int y)
  31. {
  32.  COORD pos;
  33.  pos.X = x;  //横坐标
  34.  pos.Y = y;  //纵坐标
  35.  SetConsoleCursorPosition(hOut, pos);
  36. }
  37. /******设置文本为绿色*****************************************************************/
  38. void Set_TextColor_Green (void)
  39. { 
  40.  HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE);
  41.  
  42.  SetConsoleTextAttribute(Handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN);
  43. }
  44. /******制作游戏窗口******************************************************************/
  45. void make_frame()
  46. {
  47.  HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);  //定义显示器句柄变量
  48.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+13);  //打印选择菜单
  49.  printf("Esc 退出游戏");
  50.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+15);
  51.  printf("长按方向键：加速");
  52.  gotoxy(hOut,FrameX,FrameY);       //打印框角
  53.  printf("╔");
  54.  gotoxy(hOut,FrameX+2*Frame_width-2,FrameY);
  55.  printf("╗");
  56.  gotoxy(hOut,FrameX,FrameY+Frame_height);
  57.  printf("╚");
  58.  gotoxy(hOut,FrameX+2*Frame_width-2,FrameY+Frame_height);
  59.  printf("╝");
  60.  for(i=2;i<2*Frame_width-2;i+=2)
  61.  {
  62.   gotoxy(hOut,FrameX+i,FrameY);
  63.   printf("═");         //打印上横框
  64.  }
  65.  for(i=2;i<2*Frame_width-2;i+=2)
  66.  {
  67.   gotoxy(hOut,FrameX+i,FrameY+Frame_height);
  68.   printf("═");         //打印下横框
  69.  }
  70.  for(i=1;i<Frame_height;i++)
  71.  {
  72.   gotoxy(hOut,FrameX,FrameY+i); 
  73.   printf("║");         //打印左竖框
  74.  }
  75.  for(i=1;i<Frame_height;i++)
  76.  {
  77.   gotoxy(hOut,FrameX+2*Frame_width-2,FrameY+i); 
  78.   printf("║");         //打印右竖框
  79.  }
  80.  gotoxy(hOut,FrameX+Frame_width-5,FrameY-2);   //打印游戏名称 
  81.  Set_TextColor_Green ();        //设置蛇为绿色
  82.  printf("贪吃蛇游戏");
  83. }
  84. /******结束菜单*******************************************************************/
  85. void over_game()
  86. {
  87.  system("cls");
  88.  printf("\n\n\n\n\n\n\n\n\t\t\t\t游戏结束\n\n\n");
  89.  Sleep(2000);
  90.  getch();
  91. }
  92. /******菜单信息***************************************************************/
  93. print_information(HANDLE hOut,struct Snake *snake,struct Food *food)
  94. {
  95.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+1);
  96.  printf("level : %d",snake->count/5+1);    //打印游戏等级
  97.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+3);
  98.  printf("score : %d",10*snake->count);    //打印游戏得分
  99.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+5);
  100.  printf("eat food : %d",snake->count);    //打印产生食物个数 
  101.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+7);
  102.  printf("speed : %dms",snake->speed);    //打印游戏速度
  103.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+9);
  104.  printf("foodX : %d",food->x);      //打印食物的横坐标
  105.  gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+11);
  106.  printf("foodY : %d",food->y);      //打印食物的竖坐标
  107. }
  108. /******初始化蛇**********************************************************************/
  109. void init_snake(struct Snake *snake)
  110. {
  111.  snake->x[0]=FrameX+2;     //初始化蛇的横坐标 
  112.  snake->y[0]=FrameY+Frame_height/2;  //初始化蛇的竖坐标 
  113.  snake->speed=300;      //初始化蛇的速度为300ms
  114.  snake->length=3;      //初始化蛇的长度为3节
  115.  snake->count=0;       //初始化蛇吃的个数为0
  116.  for(i=1;i<snake->length;i++)
  117.  {/* 依次得到蛇身、蛇头的坐标 */
  118.   snake->x[i]=snake->x[i-1]+2;
  119.   snake->y[i]=snake->y[i-1];
  120.  } 
  121. }
  122. /******移动蛇*************************************************************************/
  123. void move_snake(HANDLE hOut,struct Snake *snake)
  124. {
  125.  gotoxy(hOut,snake->x[0],snake->y[0]);
  126.  printf("  ");       /* 清除蛇尾*/
  127.  for(i=1;i<snake->length;i++)
  128.  {/* 后一节的坐标依次取代前一节的坐标 */
  129.   snake->x[i-1]=snake->x[i];
  130.   snake->y[i-1]=snake->y[i];
  131.  }
  132. }
  133. /******打印蛇*************************************************************************/
  134. void print_snake(HANDLE hOut,struct Snake *snake)
  135. {
  136.  for(i=0;i<snake->length;i++)
  137.  {
  138.   gotoxy(hOut,snake->x[i],snake->y[i]);
  139.   if(i==0)
  140.   {
  141.    printf("○");       //打印蛇尾
  142.   }
  143.   else if(i==snake->length-1)
  144.   {
  145.    printf("¤");       //打印蛇头
  146.   }
  147.   else
  148.   {
  149.    printf("⊙");       //打印蛇身
  150.   }
  151.  }
  152. }
  153. /******随机产生食物*******************************************************************/
  154. void get_food(HANDLE hOut,struct Snake *snake,struct Food *food)
  155. {
  156.  srand((unsigned)time(NULL));       //初始化随机数
  157.  while(1)
  158.  {/* 产生食物的条件：1.在游戏窗口内 2.不在蛇的身上 */ 
  159.   food->x = rand() % (Frame_width-1);
  160.   food->y = rand() % Frame_height;
  161.   if( food->x==0 || food->y==0 )
  162.   {
  163.    continue;
  164.   }
  165.   food->x = 2*food->x + FrameX;      //得到食物的横坐标
  166.   food->y+=FrameY;         //得到食物的竖坐标
  167.   for(i=0;i<snake->length;i++)
  168.   {/* 判断食物是否在蛇的身上，如果在蛇身上，则重新产生；否则，打印蛇身 */
  169.    if( food->x==snake->x[i] && food->y==snake->y[i] )
  170.    {
  171.     break;
  172.    }
  173.   }
  174.   if(i==snake->length)
  175.   {
  176.    gotoxy(hOut,food->x,food->y);
  177.    printf("⊙");
  178.    break;
  179.   } 
  180.  }
  181. }
  182. /******吃食物***************************************************************************/
  183. void eat_food(HANDLE hOut,struct Snake *snake,struct Food *food)
  184. {
  185.  if( snake->x[snake->length-1]==food->x && snake->y[snake->length-1]==food->y )
  186.  {/* 如果蛇头位置与食物位置相同，吃食物 */
  187.   snake->length++;      //吃一个食物，蛇身增长一节
  188.   for(i=snake->length-1;i>=1;i--)
  189.   {/* 蛇后节坐标依次赋值给蛇前一节的坐标，依次得到蛇身及蛇头的坐标 */
  190.    snake->x[i]=snake->x[i-1];
  191.    snake->y[i]=snake->y[i-1];
  192.   } 
  193.   snake->x[0]=a[0];      //得到蛇尾移动前的横坐标
  194.   snake->y[0]=a[1];      //得到蛇尾移动前的竖坐标  
  195.   get_food(hOut,snake,food);    //重新产生食物
  196.   snake->count++;       //食物的个数增1
  197.   if( snake->count%5==0 )
  198.   {/* 当蛇吃Up_level个食物时，速度加快Up_speed毫秒并且升一级 */
  199.    snake->speed-=50;
  200.   }
  201.  }
  202. }
  203. /******穿墙**********************************************************************************/
  204. void through_wall(HANDLE hOut,struct Snake *snake,char ch)
  205. {
  206.  if( ch==72 && snake->y[snake->length-1]==FrameY)
  207.  {
  208.   snake->y[snake->length-1] = FrameY+Frame_height-1; //如果蛇在上框且向上移动，穿墙
  209.  }
  210.  if( ch==80 && snake->y[snake->length-1]==FrameY+Frame_height )
  211.  {
  212.   snake->y[snake->length-1] = FrameY+1;    //如果蛇在下框且向下移动，穿墙
  213.  }
  214.  if( ch==75 && snake->x[snake->length-1]==FrameX )
  215.  {
  216.   snake->x[snake->length-1] = FrameX+2*Frame_width-4; //如果蛇在左框且向左移动，穿墙
  217.  }
  218.  if( ch==77 && snake->x[snake->length-1]==FrameX+2*Frame_width-2 )
  219.  {
  220.   snake->x[snake->length-1] = FrameX+2;    //如果蛇在右框且向右移动，穿墙
  221.  }
  222. }
  223. /******判断蛇是否死**************************************************************************/
  224. int if_die(struct Snake *snake)
  225. {/* 当蛇头碰到自身时，蛇死 ，返回值为0 */
  226.  for(i=0;i<snake->length-1;i++)
  227.  {
  228.   if( snake->x[snake->length-1]==snake->x[i] && snake->y[snake->length-1]==snake->y[i] )
  229.   {
  230.    return 0;
  231.   }
  232.  }
  233.  return 1;
  234. }
  235. /******开始游戏*******************************************************************************/
  236. void start_game()
  237. {
  238.  unsigned char ch=77;        //定义用于接收键盘输入的字符变量
  239.  HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); //定义显示器句柄变量
  240.  struct Snake s,*snake=&s;      //定义蛇的结构体指针并指向蛇的结构体
  241.  struct Food f,*food=&f;       //定义食物的结构体指针并指向食物的结构体
  242.  
  243.  make_frame();         //制作游戏窗口 
  244.  init_snake(snake);        //初始化蛇
  245.  get_food(hOut,snake,food);      //随机产生食物
  246.  while(1)
  247.  {
  248.   print_information(hOut,snake,food);   //打印菜单信息
  249.   a[0]=snake->x[0];       //记住蛇尾的横坐标
  250.   a[1]=snake->y[0];       //记住蛇尾的竖坐标
  251.   j=0;
  252.   if(kbhit())
  253.   {/* 判断是否按下键盘，如果按下，ch接收键盘输入 */
  254.    ch=getch();
  255.    if(kbhit())
  256.    {/* 如果长按键盘，则加速 */
  257.     Sleep(20);
  258.     j=1;
  259.    }
  260.   }
  261.   switch(ch)
  262.   {
  263.    case 72:
  264.     {/* 向上移动 */
  265.      move_snake(hOut,snake);   //移动蛇
  266.      snake->y[snake->length-1]-=1; //蛇头的竖坐标向上移，即减1 
  267.      break;
  268.     }
  269.    case 80:
  270.     {/* 向下移动 */
  271.      move_snake(hOut,snake);   //移动蛇
  272.      snake->y[snake->length-1]+=1; //蛇头的竖坐标向下移，即加1
  273.      break;
  274.     }
  275.    case 75:
  276.     {/* 向左移动 */
  277.      move_snake(hOut,snake);   //移动蛇
  278.      snake->x[snake->length-1]-=2; //蛇头的横坐标向左移，即减2
  279.      break;
  280.     }    
  281.    case 77:
  282.     {/* 向右移动 */
  283.      move_snake(hOut,snake);   //移动蛇
  284.      snake->x[snake->length-1]+=2; //蛇头的横坐标向右移，即加2
  285.      break;
  286.     }
  287.   }
  288.   through_wall(hOut,snake,ch);    //穿墙   
  289.   eat_food(hOut,snake,food);     //吃食物
  290.   print_snake(hOut,snake);     //打印蛇
  291.   if( if_die(snake)==0 || ch==27 || snake->speed==50 )
  292.   {/* 游戏结束条件：1.蛇碰到自身 2.按Esc键 3.速度为50ms */
  293.    gotoxy(hOut,FrameX+Frame_width-2,FrameY+Frame_height/2-1);
  294.    printf("Game Over");
  295.    Sleep(2000);
  296.    break;
  297.   }
  298.   if(j==0)
  299.   {
  300.    Sleep(snake->speed);      //延迟时间
  301.   }
  302.   else
  303.   {
  304.    Sleep(1000);
  305.   } 
  306.  }
  307. }
  308. int main()
  309. {
  310.  system("color 0D");  //设置文本为粉红色
  311.  start_game();   //开始游戏
  312.  over_game(); 
  313.  return 0;  //结束游戏
  314. }

  1. 3.贪吃蛇的简单移动 
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <windows.h>
  5.  
  6. #define BEG_X	2
  7. #define BEG_Y	1
  8. #define WID		20
  9. #define HEI		20
  10.  
  11. HANDLE hout;
  12. typedef enum {UP, DOWN, LEFT, RIGHT} DIR;
  13. typedef struct Snake_body
  14. {
  15. 	COORD pos;//蛇身的位置
  16. 	struct Snake_body *next;//下一个蛇身
  17. 	struct Snake_body *prev;//前一个蛇身
  18. }SNAKE, *PSNAKE;
  19. PSNAKE head = NULL;//蛇头
  20. PSNAKE tail = NULL;//蛇尾
  21.  
  22. //画游戏边框的函数
  23. void DrawBorder()
  24. {
  25. 	int i, j;
  26. 	COORD pos = {BEG_X, BEG_Y};
  27. 	for(i = 0; i < HEI; ++i)
  28. 	{
  29. 		SetConsoleCursorPosition(hout, pos);
  30. 		for(j = 0; j < WID; ++j)
  31. 		{
  32. 			if(i == 0)//第一行
  33. 			{
  34. 				if(j == 0)
  35. 					printf("┏");
  36. 				else if(j == WID - 1)
  37. 					printf("┓");
  38. 				else
  39. 					printf("━");
  40. 			}
  41. 			else if(i == HEI - 1)//最后一行
  42. 			{
  43. 				if(j == 0)
  44. 					printf("┗");
  45. 				else if(j == WID - 1)
  46. 					printf("┛");
  47. 				else
  48. 					printf("━");
  49. 			}
  50. 			else if(j == 0 || j == WID - 1)//第一列或最后一列
  51. 				printf("┃");
  52. 			else
  53. 				printf("  ");
  54. 		}
  55. 		++pos.Y;
  56. 	}	
  57. }
  58.  
  59. //添加蛇身的函数
  60. void AddBody(COORD pos)
  61. {
  62. 	PSNAKE pnew = (PSNAKE)calloc(1, sizeof(SNAKE));
  63. 	pnew->pos = pos;
  64. 	if(!head)
  65. 	{
  66. 		head = tail = pnew;
  67. 	}
  68. 	else
  69. 	{
  70. 		pnew->next = head;//新创建蛇身的next指向原先的蛇头
  71. 		head->prev = pnew;//原先的蛇头的prev指向新创建的蛇身
  72. 		head = pnew;//把新创建的蛇身作为新的蛇头
  73. 	}
  74. 	SetConsoleCursorPosition(hout, head->pos);
  75. 	printf("◎");
  76. }
  77.  
  78. //蛇身移动的函数
  79. void MoveBody(DIR dir)
  80. {
  81. 	PSNAKE ptmp;
  82. 	COORD pos = head->pos;
  83. 	switch(dir)
  84. 	{
  85. 		case UP:
  86. 			if(head->pos.Y > BEG_Y + 1)
  87. 				--pos.Y;
  88. 			else
  89. 				return;
  90. 		break;		
  91. 		case DOWN:
  92. 			if(head->pos.Y < BEG_Y + HEI - 2)
  93. 				++pos.Y;
  94. 			else
  95. 				return;
  96. 		break;
  97. 		case LEFT:
  98. 			if(head->pos.X > BEG_X + 2)
  99. 				pos.X -= 2;
  100. 			else
  101. 				return;
  102. 		break;
  103. 		case RIGHT:
  104. 			if(head->pos.X < BEG_X + (WID - 2) * 2)
  105. 				pos.X += 2;
  106. 			else 
  107. 				return;
  108. 		break;
  109. 	}
  110. 	AddBody(pos);//添加了一个新的蛇头
  111. 	ptmp = tail;//保存当前的蛇尾
  112. 	tail = tail->prev;
  113. 	if(tail)
  114. 		tail->next = NULL;
  115. 	SetConsoleCursorPosition(hout, ptmp->pos);
  116. 	printf("  ");
  117. 	free(ptmp);
  118. }
  119.  
  120.  
  121. int main()
  122. {
  123. 	int ctrl;
  124. 	DIR dir = RIGHT;//初始蛇的方向是向右的
  125. 	COORD pos = {BEG_X + 2, BEG_Y + HEI / 2};
  126. 	system("color 0E");
  127. 	system("mode con cols=90 lines=30");
  128. 	hout = GetStdHandle(STD_OUTPUT_HANDLE);
  129. 	printf("    ------------贪吃蛇的移动------------");
  130. 	DrawBorder();
  131. 	//自定义几个蛇的身体
  132. 	AddBody(pos);
  133. 	pos.X += 2;
  134. 	AddBody(pos);
  135. 	pos.X += 2;
  136. 	AddBody(pos);
  137. 	pos.X += 2;
  138. 	AddBody(pos);
  139. 	pos.X += 2;
  140. 	AddBody(pos);
  141. 	pos.X += 2;
  142. 	AddBody(pos);
  143. 	pos.X += 2;
  144. 	AddBody(pos);
  145. 	//控制蛇的移动
  146. 	while(ctrl = getch())
  147. 	{
  148. 		switch(ctrl)
  149. 		{
  150. 			case 'w':
  151. 				if(dir == DOWN)
  152. 					continue;
  153. 				dir = UP;
  154. 				break;
  155. 			case 's':
  156. 				if(dir == UP)
  157. 					continue;
  158. 				dir = DOWN;
  159. 				break;
  160. 			case 'a':
  161. 				if(dir == RIGHT)
  162. 					continue;
  163. 				dir = LEFT;
  164. 				break;
  165. 			case 'd':
  166. 				if(dir == LEFT)
  167. 					continue;
  168. 				dir = RIGHT;
  169. 				break;
  170. 			case 'q':
  171. 				return 0;
  172. 		}
  173. 		MoveBody(dir);
  174. 	}
  175. 	
  176. 	return 0;
  177. }
  1. #include<stdio.h>  
  2. #include<time.h>  
  3. #include<windows.h>  
  4. #include<stdlib.h>  
  5.   
  6. #define U 1  
  7. #define D 2  
  8. #define L 3  
  9. #define R 4       //蛇的状态，U：上 ；D：下；L:左 R：右  
  10.   
  11. typedef struct SNAKE { //蛇身的一个节点  
  12.     int x;  
  13.     int y;  
  14.     struct SNAKE *next;  
  15. } snake;  
  16.   
  17. //全局变量//  
  18. int score=0,add=10;//总得分与每次吃食物得分。  
  19. int status,sleeptime=200;//每次运行的时间间隔  
  20. snake *head, *food;//蛇头指针，食物指针  
  21. snake *q;//遍历蛇的时候用到的指针  
  22. int endgamestatus=0; //游戏结束的情况，1：撞到墙；2：咬到自己；3：主动退出游戏。  
  23.   
  24. //声明全部函数//  
  25. void Pos();  
  26. void creatMap();  
  27. void initsnake();  
  28. int biteself();  
  29. void createfood();  
  30. void cantcrosswall();  
  31. void snakemove();  
  32. void pause();  
  33. void gamecircle();  
  34. void welcometogame();  
  35. void endgame();  
  36. void gamestart();  
  37.   
  38. void Pos(int x,int y) { //设置光标位置  
  39.     COORD pos;  
  40.     HANDLE hOutput;  
  41.     pos.X=x;  
  42.     pos.Y=y;  
  43.     hOutput=GetStdHandle(STD_OUTPUT_HANDLE);  
  44.     SetConsoleCursorPosition(hOutput,pos);  
  45. }  
  46.   
  47. void creatMap() { //创建地图  
  48.     int i;  
  49.     for(i=0; i<58; i+=2) { //打印上下边框  
  50.         Pos(i,0);  
  51.         printf("■");  
  52.         Pos(i,26);  
  53.         printf("■");  
  54.     }  
  55.     for(i=1; i<26; i++) { //打印左右边框  
  56.         Pos(0,i);  
  57.         printf("■");  
  58.         Pos(56,i);  
  59.         printf("■");  
  60.     }  
  61. }  
  62.   
  63. void initsnake() { //初始化蛇身  
  64.     snake *tail;  
  65.     int i;  
  66.     tail=(snake*)malloc(sizeof(snake));//从蛇尾开始，头插法，以x,y设定开始的位置//  
  67.     tail->x=24;  
  68.     tail->y=5;  
  69.     tail->next=NULL;  
  70.     for(i=1; i<=4; i++) {  
  71.         head=(snake*)malloc(sizeof(snake));  
  72.         head->next=tail;  
  73.         head->x=24+2*i;  
  74.         head->y=5;  
  75.         tail=head;  
  76.     }  
  77.     while(tail!=NULL) { //从头到为，输出蛇身  
  78.         Pos(tail->x,tail->y);  
  79.         printf("■");  
  80.         tail=tail->next;  
  81.     }  
  82. }  
  83.   
  84. int biteself() { //判断是否咬到了自己  
  85.     snake *self;  
  86.     self=head->next;  
  87.     while(self!=NULL) {  
  88.         if(self->x==head->x && self->y==head->y) {  
  89.             return 1;  
  90.         }  
  91.         self=self->next;  
  92.     }  
  93.     return 0;  
  94. }  
  95.   
  96. void createfood() { //随机出现食物  
  97.     snake *food_1;  
  98.     srand((unsigned)time(NULL));  
  99.     food_1=(snake*)malloc(sizeof(snake));  
  100.     while((food_1->x%2)!=0) {  //保证其为偶数，使得食物能与蛇头对其  
  101.         food_1->x=rand()%52+2;  
  102.     }  
  103.     food_1->y=rand()%24+1;  
  104.     q=head;  
  105.     while(q->next==NULL) {  
  106.         if(q->x==food_1->x && q->y==food_1->y) { //判断蛇身是否与食物重合  
  107.             free(food_1);  
  108.             createfood();  
  109.         }  
  110.         q=q->next;  
  111.     }  
  112.     Pos(food_1->x,food_1->y);  
  113.     food=food_1;  
  114.     printf("■");  
  115. }  
  116.   
  117. void cantcrosswall() { //不能穿墙  
  118.     if(head->x==0 || head->x==56 ||head->y==0 || head->y==26) {  
  119.         endgamestatus=1;  
  120.         endgame();  
  121.     }  
  122. }  
  123.   
  124. void snakemove() { //蛇前进,上U,下D,左L,右R  
  125.     snake * nexthead;  
  126.     cantcrosswall();  
  127.   
  128.     nexthead=(snake*)malloc(sizeof(snake));  
  129.     if(status==U) {  
  130.         nexthead->x=head->x;  
  131.         nexthead->y=head->y-1;  
  132.         if(nexthead->x==food->x && nexthead->y==food->y) { //如果下一个有食物//  
  133.             nexthead->next=head;  
  134.             head=nexthead;  
  135.             q=head;  
  136.             while(q!=NULL) {  
  137.                 Pos(q->x,q->y);  
  138.                 printf("■");  
  139.                 q=q->next;  
  140.             }  
  141.             score=score+add;  
  142.             createfood();  
  143.         } else {                                           //如果没有食物//  
  144.             nexthead->next=head;  
  145.             head=nexthead;  
  146.             q=head;  
  147.             while(q->next->next!=NULL) {  
  148.                 Pos(q->x,q->y);  
  149.                 printf("■");  
  150.                 q=q->next;  
  151.             }  
  152.             Pos(q->next->x,q->next->y);  
  153.             printf("  ");  
  154.             free(q->next);  
  155.             q->next=NULL;  
  156.         }  
  157.     }  
  158.     if(status==D) {  
  159.         nexthead->x=head->x;  
  160.         nexthead->y=head->y+1;  
  161.         if(nexthead->x==food->x && nexthead->y==food->y) { //有食物  
  162.             nexthead->next=head;  
  163.             head=nexthead;  
  164.             q=head;  
  165.             while(q!=NULL) {  
  166.                 Pos(q->x,q->y);  
  167.                 printf("■");  
  168.                 q=q->next;  
  169.             }  
  170.             score=score+add;  
  171.             createfood();  
  172.         } else {                           //没有食物  
  173.             nexthead->next=head;  
  174.             head=nexthead;  
  175.             q=head;  
  176.             while(q->next->next!=NULL) {  
  177.                 Pos(q->x,q->y);  
  178.                 printf("■");  
  179.                 q=q->next;  
  180.             }  
  181.             Pos(q->next->x,q->next->y);  
  182.             printf("  ");  
  183.             free(q->next);  
  184.             q->next=NULL;  
  185.         }  
  186.     }  
  187.     if(status==L) {  
  188.         nexthead->x=head->x-2;  
  189.         nexthead->y=head->y;  
  190.         if(nexthead->x==food->x && nexthead->y==food->y) { //有食物  
  191.             nexthead->next=head;  
  192.             head=nexthead;  
  193.             q=head;  
  194.             while(q!=NULL) {  
  195.                 Pos(q->x,q->y);  
  196.                 printf("■");  
  197.                 q=q->next;  
  198.             }  
  199.             score=score+add;  
  200.             createfood();  
  201.         } else {                            //没有食物  
  202.             nexthead->next=head;  
  203.             head=nexthead;  
  204.             q=head;  
  205.             while(q->next->next!=NULL) {  
  206.                 Pos(q->x,q->y);  
  207.                 printf("■");  
  208.                 q=q->next;  
  209.             }  
  210.             Pos(q->next->x,q->next->y);  
  211.             printf("  ");  
  212.             free(q->next);  
  213.             q->next=NULL;  
  214.         }  
  215.     }  
  216.     if(status==R) {  
  217.         nexthead->x=head->x+2;  
  218.         nexthead->y=head->y;  
  219.         if(nexthead->x==food->x && nexthead->y==food->y) { //有食物  
  220.             nexthead->next=head;  
  221.             head=nexthead;  
  222.             q=head;  
  223.             while(q!=NULL) {  
  224.                 Pos(q->x,q->y);  
  225.                 printf("■");  
  226.                 q=q->next;  
  227.             }  
  228.             score=score+add;  
  229.             createfood();  
  230.         } else {                                     //没有食物  
  231.             nexthead->next=head;  
  232.             head=nexthead;  
  233.             q=head;  
  234.             while(q->next->next!=NULL) {  
  235.                 Pos(q->x,q->y);  
  236.                 printf("■");  
  237.                 q=q->next;  
  238.             }  
  239.             Pos(q->next->x,q->next->y);  
  240.             printf("  ");  
  241.             free(q->next);  
  242.             q->next=NULL;  
  243.         }  
  244.     }  
  245.     if(biteself()==1) {     //判断是否会咬到自己  
  246.         endgamestatus=2;  
  247.         endgame();  
  248.     }  
  249. }  
  250.   
  251. void pause() { //暂停  
  252.     while(1) {  
  253.         Sleep(300);  
  254.         if(GetAsyncKeyState(VK_SPACE)) {  
  255.             break;  
  256.         }  
  257.   
  258.     }  
  259. }  
  260.   
  261. void gamecircle() { //控制游戏  
  262.   
  263.     Pos(64,15);  
  264.     printf("不能穿墙，不能咬到自己\n");  
  265.     Pos(64,16);  
  266.     printf("用↑.↓.←.→分别控制蛇的移动.");  
  267.     Pos(64,17);  
  268.     printf("F1 为加速，F2 为减速\n");  
  269.     Pos(64,18);  
  270.     printf("ESC ：退出游戏.space：暂停游戏.");  
  271.     Pos(64,20);  
  272.     printf("C语言研究中心 www.clang.cc");  
  273.     status=R;  
  274.     while(1) {  
  275.         Pos(64,10);  
  276.         printf("得分：%d  ",score);  
  277.         Pos(64,11);  
  278.         printf("每个食物得分：%d分",add);  
  279.         if(GetAsyncKeyState(VK_UP) && status!=D) {  
  280.             status=U;  
  281.         } else if(GetAsyncKeyState(VK_DOWN) && status!=U) {  
  282.             status=D;  
  283.         } else if(GetAsyncKeyState(VK_LEFT)&& status!=R) {  
  284.             status=L;  
  285.         } else if(GetAsyncKeyState(VK_RIGHT)&& status!=L) {  
  286.             status=R;  
  287.         } else if(GetAsyncKeyState(VK_SPACE)) {  
  288.             pause();  
  289.         } else if(GetAsyncKeyState(VK_ESCAPE)) {  
  290.             endgamestatus=3;  
  291.             break;  
  292.         } else if(GetAsyncKeyState(VK_F1)) {  
  293.             if(sleeptime>=50) {  
  294.                 sleeptime=sleeptime-30;  
  295.                 add=add+2;  
  296.                 if(sleeptime==320) {  
  297.                     add=2;//防止减到1之后再加回来有错  
  298.                 }  
  299.             }  
  300.         } else if(GetAsyncKeyState(VK_F2)) {  
  301.             if(sleeptime<350) {  
  302.                 sleeptime=sleeptime+30;  
  303.                 add=add-2;  
  304.                 if(sleeptime==350) {  
  305.                     add=1;  //保证最低分为1  
  306.                 }  
  307.             }  
  308.         }  
  309.         Sleep(sleeptime);  
  310.         snakemove();  
  311.     }  
  312. }  
  313.   
  314. void welcometogame() { //开始界面  
  315.     Pos(40,12);  
  316.   
  317.     system("title C语言研究中心   www.clang.cc");  
  318.     printf("欢迎来到贪食蛇游戏！");  
  319.     Pos(40,25);  
  320.     printf("              C语言研究中心  www.clang.cc.\n");  
  321.     system("pause");  
  322.     system("cls");  
  323.     Pos(25,12);  
  324.     printf("用↑.↓.←.→分别控制蛇的移动， F1 为加速，2 为减速\n");  
  325.     Pos(25,13);  
  326.     printf("加速将能得到更高的分数。\n");  
  327.     system("pause");  
  328.     system("cls");  
  329. }  
  330.   
  331. void endgame() { //结束游戏  
  332.   
  333.     system("cls");  
  334.     Pos(24,12);  
  335.     if(endgamestatus==1) {  
  336.         printf("对不起，您撞到墙了。游戏结束.");  
  337.     } else if(endgamestatus==2) {  
  338.         printf("对不起，您咬到自己了。游戏结束.");  
  339.     } else if(endgamestatus==3) {  
  340.         printf("您的已经结束了游戏。");  
  341.     }  
  342.     Pos(24,13);  
  343.     printf("您的得分是%d\n",score);  
  344.     exit(0);  
  345. }  
  346.   
  347. void gamestart() { //游戏初始化  
  348.     system("mode con cols=100 lines=30");  
  349.     welcometogame();  
  350.     creatMap();  
  351.     initsnake();  
  352.     createfood();  
  353. }  
  354.   
  355. int main() {  
  356.     gamestart();  
  357.     gamecircle();  
  358.     endgame();  
  359.     return 0;  
  360. }


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

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

  

闽ICP备14008679号