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

对于小游戏2048代码具体讲解_2048小游戏代码的每步解析

作者：繁依Fanyi0 | 2024-03-05 15:21:46

赞

踩

2048小游戏代码的每步解析

1.如何做到打印外面的方框。

  1. void Game_printf()
  2. {
  3. 	int i,k,j;
  4. 	printf("SCORE = %d\n", score);
  5. 	for (i=0;i<high;i++)        //从第一行开始打印，由上往下。
  6. 	{
  7. 		for (k=0;k<4;k++)       //画出每一行的格子分割线。
  8. 		{
  9. 			printf(" ");
  10. 			for(j=0;j<4;j++)
  11. 			{
  12. 				printf("-");
  13. 			}
  14. 		}
  15. 		printf("\n");
  16. 		for (k=0;k<4;k++)
  17. 		{
  18. 			printf("|");
  19. 			if (array[i][k]!=0)   //如果这个不为0则将这个数打出来
  20. 			{
  21. 				printf("%4d", array[i][k]);
  22. 			}
  23. 			else                //如果这个数是0的话，则打印空格。
  24. 			{
  25. 				for (j=0; j<4;j++)
  26. 				{
  27. 					printf(" ");
  28. 				}
  29. 			}
  30.  
  31. 		}
  32. 		printf("|\n");
  33. 		if (i==high-1)      //当i位于最后一行的时候，不需要用分割线来进行分割。
  34. 		{
  35. 			for (k=0; k<4; k++)
  36. 			{
  37. 				printf(" ");
  38. 				for (j=0; j<4; j++)
  39. 				{
  40. 					printf("-");        //打出最下面的底线。
  41. 				}
  42. 			}
  43. 			printf("\n");
  44. 		}
  45. 	}
  46. 	printf("使用上下左右或者wasd来进行游戏操作\n");        //提示本游戏的键位设置，应该如何玩这个游戏。
  47. }

对于打印方框来说，用好其他的符号，便可以很好的打印这个边框。

每一个空格占四个格子，在进行输出的时候，如果是零，为了美观，我们将这个用四个空格来进行代替。如果是其他的数字，那么就用%4d来输出，那样，数字就会正好的在中间。

  1. void Game_ranf()     //生成一个随机数。
  2. {
  3.     int x,y,t;
  4.     do{
  5.         x=rand()%4;
  6.         y=rand()%4;
  7.     }while(array[x][y]);        //只有在等于0的空格上随机出现。
  8.     t=rand()%10;
  9.     if(t==4)                    //设置概率，当t随机出来为4的时候，赋值给array[x][y]
  10.         array[x][y]=4;
  11.     else                        //否则就是将2赋值给数组空白地方
  12.         array[x][y]=2;
  13. }

2.当知道如何打印格子之后，我们就要开始我们的第一步，根据2048的游戏规则，我么在最开始的时候，我们需要先生成两个随机数，那么我们应该如何来生成着两个随机数呢。

我们可以采用rand()，函数来进行我们的随机数输出，因为是随机生成2或者4，并且我们的2生成的概率要大于四。我们先定义一个xy，来进行位置的输出，如果x和y的数组不是零，那么重新进行随机数的赋值。当然我们还需要注意一个，我们的随机数很多，但是我们的随机数应该被四除取余数。

  1. int Game_win()
  2. {
  3.     int i,j;
  4.     for(i=0;i<4;i++)
  5.     {
  6.         for(j=0;j<4;j++)
  7.         {
  8.             if(array[i][j]==2048)
  9.                 return 1;
  10.             if(array[i][j]==0)
  11.                 return 0;
  12.         }
  13.     }
  14.     return -1;
  15. }

我们还需要写一个来判断输赢的函数，进行暴力搜索，如果有2048，那么就返回1，则代表游戏已经赢了，如果是0，那么返回为0，表示游戏继续，当搜索完成之后，任然没有找到2048或者0，那么我们的游戏就输了。返回-1；

  1. void move_left()
  2. {
  3.     int i,j,k;
  4. 	for(i=0;i<4;i++)			//从第一行开始，然后一个一个的来进行左移；
  5. 	{
  6. 		 k=0;							//用k来当最左边的那个列元素。
  7. 		for(j=1;j<4;j++)			//从这一行的第二个开始来进行判断。
  8. 		{
  9. 			if(array[i][j]!=0)			//判断这个地方的元素是不是等于零，如果等于零，直接下一个。
  10. 			{
  11. 				if(array[i][k]==0)		//如果第一个等于零，把第一个的元素往右边移动。
  12. 				{
  13. 					array[i][k]=array[i][j];
  14. 					array[i][j]=0;			//移动之后，原本的那个元素变成了零。
  15. 				}
  16. 				else					//如果不等于零，那么分为两种情况，一种是两个元素相等，一个是不相等。
  17. 					if(array[i][k]==array[i][j])			//如果两个元素相等，那么相加，然后到最左边，之后k++；
  18. 				{
  19. 					array[i][k]=2*array[i][k];
  20. 					score+=array[i][k];
  21. 					array[i][j]=0;					//原本的那个元素变为了零。
  22. 					k++;
  23. 				}
  24. 				else						//如果两个元素不相同，那么就是碰撞。
  25. 				{
  26. 					k++;					//首先先加跳到下一个
  27. 					array[i][k]=array[i][j];		//将下一个值赋给k。
  28. 					if (j!=k)					//如果j不等于k的值，那么就是直接将j的那个元素变为0；
  29. 					{
  30. 						array[i][j]=0;
  31. 					}
  32. 				}
  33. 			}
  34. 		}
  35. 	}
  36. }

现在到了我们整个程序最复杂的地方了，我们拿往左边移动来进行举例说明，既然是往左边移动，那么我们就从左边开始我们的循环，设置三个变量，首先用k来当最左边的那个数，在将j赋值1从第二个开始我们的计算查找，如果等于零，那么往后继续走，但是k的值不变，如果碰见不等于的值，那么将k与j的元素互换，相当于j转移到了最左边的地方。如果两个元素相同，将右边的那个置零，左边的元素乘2，那样子，我们等到了合成的式子，如果不是一样的，把右边的放在左边元素的下一位。

  1. 	void Game_jixu()
  2. 	{
  3. 		//为了判断在键盘上按下的哪个键
  4. 		int ch2 = 0;
  5. 		while (1)
  6. 		{
  7. 				ch2 = _getch();
  8. 				if (ch2 == 72||ch2=='w')
  9. 				{
  10. 					move_up();
  11. 					break;
  12. 				}
  13. 				if (ch2 == 80||ch2=='s')
  14. 				{
  15. 					move_down();
  16. 					break;
  17. 				}
  18. 				if (ch2 == 75||ch2=='a')
  19. 				{
  20. 					move_left();
  21. 					break;
  22. 				}
  23. 				if (ch2 == 77||ch2=='d')
  24. 				{
  25. 					move_right();
  26. 					break;
  27. 				}
  28. 			}
  29.  
  30. 	}

这一段代码游戏继续的代码，从键盘中获取按键，最好使用<conio.h>文件里面的getch()来进行判断，因为整个是获取后直接执行，更加适合我们这个游戏的设定。

  1. int Game()
  2. {
  3.     int t;
  4.     srand((unsigned int)time(NULL));
  5.     suijishu();
  6.     suijishu();
  7.     dayin();
  8.     Game_jixu();
  9.     while(1)
  10.     {
  11.         t=shuying();
  12.         if(t==1)
  13.         {
  14.             printf("恭喜你，赢得了比赛！\n");
  15.             return;
  16.         }
  17.         if(t==-1)
  18.         {
  19.             printf("很遗憾，你已经没有可移动的方块，你输了\n");
  20.             return;
  21.         }
  22.         else
  23.         {
  24.             Game_jixu();
  25.             system("cls");
  26.             suijishu();
  27.             dayin();
  28.         }
  29.     }
  30. }

剩下的就是游戏的本体了，没有很多需要讲解的，不过我们最好加一个<windows.h>文件下的system("cls")；来进行每一次执行之后的清屏，使得玩起来更加舒适。

最后把整个代码放在下面，供参考，如果有写的不好的地方，希望各位大佬指出来，共同学习。

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<time.h>
  4. #include<windows.h>
  5. #include<conio.h>
  6. #define high 4
  7. #define wide 4
  8. int score=0;
  9. int array[4][4]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  10. void suijishu()     //生成一个随机数。
  11. {
  12.     int x,y,t;
  13.     do{
  14.         x=rand()%4;
  15.         y=rand()%4;
  16.     }while(array[x][y]);        //只有在等于0的空格上随机出现。
  17.     t=rand()%10;
  18.     if(t==4)                    //设置概率，当t随机出来为4的时候，赋值给array[x][y]
  19.         array[x][y]=4;
  20.     else                        //否则就是将2赋值给数组空白地方
  21.         array[x][y]=2;
  22. }
  23. void dayin()
  24. {
  25. 	int i,k,j;
  26. 	printf("SCORE = %d\n", score);
  27. 	for (i=0;i<high;i++)        //从第一行开始打印，由上往下。
  28. 	{
  29. 		for (k=0;k<4;k++)       //画出每一行的格子分割线。
  30. 		{
  31. 			printf(" ");
  32. 			for(j=0;j<4;j++)
  33. 			{
  34. 				printf("-");
  35. 			}
  36. 		}
  37. 		printf("\n");
  38. 		for (k=0;k<4;k++)
  39. 		{
  40. 			printf("|");
  41. 			if (array[i][k]!=0)   //如果这个不为0则将这个数打出来
  42. 			{
  43. 				printf("%4d", array[i][k]);
  44. 			}
  45. 			else                //如果这个数是0的话，则打印空格。
  46. 			{
  47. 				for (j=0; j<4;j++)
  48. 				{
  49. 					printf(" ");
  50. 				}
  51. 			}
  52.  
  53. 		}
  54. 		printf("|\n");
  55. 		if (i==high-1)      //当i位于最后一行的时候，不需要用分割线来进行分割。
  56. 		{
  57. 			for (k=0; k<4; k++)
  58. 			{
  59. 				printf(" ");
  60. 				for (j=0; j<4; j++)
  61. 				{
  62. 					printf("-");        //打出最下面的底线。
  63. 				}
  64. 			}
  65. 			printf("\n");
  66. 		}
  67. 	}
  68. 	printf("使用上下左右或者wasd来进行游戏操作\n");        //提示本游戏的键位设置，应该如何玩这个游戏。
  69. }
  70. int shuying()
  71. {
  72.     int i,j;
  73.     for(i=0;i<4;i++)
  74.     {
  75.         for(j=0;j<4;j++)
  76.         {
  77.             if(array[i][j]==2048)
  78.                 return 1;
  79.             if(array[i][j]==0)
  80.                 return 0;
  81.         }
  82.     }
  83.     return -1;
  84. }
  85. void move_left()
  86. {
  87.     int i,j,k;
  88. 	for(i=0;i<4;i++)			//从第一行开始，然后一个一个的来进行左移；
  89. 	{
  90. 		 k=0;							//用k来当最左边的那个列元素。
  91. 		for(j=1;j<4;j++)			//从这一行的第二个开始来进行判断。
  92. 		{
  93. 			if(array[i][j]!=0)			//判断这个地方的元素是不是等于零，如果等于零，直接下一个。
  94. 			{
  95. 				if(array[i][k]==0)		//如果第一个等于零，把第一个的元素往右边移动。
  96. 				{
  97. 					array[i][k]=array[i][j];
  98. 					array[i][j]=0;			//移动之后，原本的那个元素变成了零。
  99. 				}
  100. 				else					//如果不等于零，那么分为两种情况，一种是两个元素相等，一个是不相等。
  101. 					if(array[i][k]==array[i][j])			//如果两个元素相等，那么相加，然后到最左边，之后k++；
  102. 				{
  103. 					array[i][k]=2*array[i][k];
  104. 					score+=array[i][k];
  105. 					array[i][j]=0;					//原本的那个元素变为了零。
  106. 					k++;
  107. 				}
  108. 				else						//如果两个元素不相同，那么就是碰撞。
  109. 				{
  110. 					k++;					//首先先加跳到下一个
  111. 					array[i][k]=array[i][j];		//将下一个值赋给k。
  112. 					if (j!=k)					//如果j不等于k的值，那么就是直接将j的那个元素变为0；
  113. 					{
  114. 						array[i][j]=0;
  115. 					}
  116. 				}
  117. 			}
  118. 		}
  119. 	}
  120. }
  121. void move_right()
  122. {
  123. 	int i,j,k;
  124. 	for (i=0;i<4;i++)
  125. 	{
  126. 		 k=3;
  127. 		for(j=2;j>=0;j--)
  128. 		{
  129. 			if(array[i][j]!=0)
  130. 			{
  131. 				if (array[i][k]==0)
  132. 				{
  133. 					array[i][k]=array[i][j];
  134. 					array[i][j]=0;
  135. 				}
  136. 				else
  137. 					if(array[i][k] == array[i][j])
  138. 				{
  139. 					array[i][k]*=2;
  140. 					score+=array[i][k];
  141. 					array[i][j]=0;
  142. 					k--;
  143. 				}
  144. 				else
  145. 				{
  146. 					k--;
  147. 					array[i][k] = array[i][j];
  148. 					if (j != k)
  149. 					{
  150. 						array[i][j] = 0;
  151. 					}
  152. 				}
  153. 			}
  154. 		}
  155. 	}
  156. }
  157. void move_up()
  158. {
  159.     	int i,j,k;
  160. 	for (j = 0; j < 4; j++)
  161. 	{
  162. 		k=0;
  163. 		for (i=1;i<4;i++)
  164. 		{
  165. 			if(array[i][j]>0)
  166. 			{
  167. 				if (array[k][j] == array[i][j])
  168. 				{
  169. 					array[k][j]*=2;
  170. 					score+=array[k][j];
  171. 					array[i][j]=0;
  172. 					k++;
  173. 				}
  174. 				else
  175.                     if(array[k][j]==0)
  176. 				{
  177. 					array[k][j]=array[i][j];
  178. 					array[i][j]=0;
  179. 				}
  180. 				else
  181. 				{
  182. 				    k++;
  183. 					array[k][j]=array[i][j];
  184. 					if(i!=k)
  185. 					{
  186. 						array[i][j]=0;
  187. 					}
  188. 				}
  189. 			}
  190. 		}
  191. 	}
  192. }
  193. void move_down()
  194. {
  195.     int i,j,k;
  196. 	for(j=0;j<4;j++)
  197. 	{
  198. 		k=3;
  199. 		for(i=2;i>=0;i--)
  200. 		{
  201. 			if(array[i][j]>0)
  202. 			{
  203. 				if(array[k][j]==array[i][j])
  204. 				{
  205. 					array[k][j]*=2;
  206. 					score+=array[k][j];
  207. 					array[i][j]=0;
  208. 					k--;
  209. 				}
  210. 				else
  211.                     if(array[k][j]==0)
  212. 				{
  213. 					array[k][j]=array[i][j];
  214. 					array[i][j]=0;
  215. 				}
  216. 				else
  217. 				{
  218. 					k--;
  219. 					array[k][j]=array[i][j];
  220. 					if (i!=k)
  221. 					{
  222. 						array[i][j]=0;
  223. 					}
  224. 				}
  225. 			}
  226. 		}
  227. 	}
  228. }
  229. 	void Game_jixu()
  230. 	{
  231. 		//为了判断在键盘上按下的哪个键
  232. 		int ch2 = 0;
  233. 		while (1)
  234. 		{
  235. 				ch2 = _getch();
  236. 				if (ch2 == 72||ch2=='w')
  237. 				{
  238. 					move_up();
  239. 					break;
  240. 				}
  241. 				if (ch2 == 80||ch2=='s')
  242. 				{
  243. 					move_down();
  244. 					break;
  245. 				}
  246. 				if (ch2 == 75||ch2=='a')
  247. 				{
  248. 					move_left();
  249. 					break;
  250. 				}
  251. 				if (ch2 == 77||ch2=='d')
  252. 				{
  253. 					move_right();
  254. 					break;
  255. 				}
  256. 			}
  257.  
  258. 	}
  259. int Game()
  260. {
  261.     int t;
  262.     srand((unsigned int)time(NULL));
  263.     suijishu();
  264.     suijishu();
  265.     dayin();
  266.     Game_jixu();
  267.     while(1)
  268.     {
  269.         t=shuying();
  270.         if(t==1)
  271.         {
  272.             printf("恭喜你，赢得了比赛！\n");
  273.             return;
  274.         }
  275.         if(t==-1)
  276.         {
  277.             printf("很遗憾，你已经没有可移动的方块，你输了\n");
  278.             return;
  279.         }
  280.         else
  281.         {
  282.             Game_jixu();
  283.             system("cls");
  284.             suijishu();
  285.             dayin();
  286.         }
  287.     }
  288. }
  289. int main()
  290. {
  291.     Game();
  292.     system("pause");
  293.     return 0;
  294. }
  295.  
  296.  
  297.

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

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

  

闽ICP备14008679号