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

【C语言】2048小游戏【附源码】

作者：小小林熬夜学编程 | 2024-04-16 01:26:12

赞

踩

【C语言】2048小游戏【附源码】

欢迎来到英杰社区icon-default.png?t=N7T8https://bbs.csdn.net/topics/617804998

一、游戏描述：

        2048是一款数字益智类游戏，玩家需要使用键盘控制数字方块的移动，合并相同数字的方块，最终达到数字方块上出现“2048”的目标。

        每次移动操作，所有数字方块会朝着指定方向同时滑动，并在靠近边界或其他数字方块时停止。如果两个相邻的数字方块数字相同，则它们会合并成一个方块，数字值为原先相同方块的数字值相加。

二、效果展示

c661ac348297482ea142d8baa7a78410.png

三、代码讲解：

        实现了一个2048游戏的基本功能，包括初始化游戏界面、移动方块、放置新数字以及判定胜负等功能：

  1. DisplayBoard(int board[ROW][COL])：初始化并打印游戏界面。这个函数用于显示游戏的当前状态，包括棋盘上的数字和空格。

  2. init_num(int board[ROW][COL])：在游戏开始时随机生成两个数字2。这个函数用于初始化游戏棋盘，给棋盘上的两个随机位置赋值为2。

  3. put_num(int board[ROW][COL])：在每次移动后随机放置一个数字2或4。这个函数用于在每次玩家移动后，在空白的位置随机生成一个数字2或4。

  4. up(int board[ROW][COL])、down(int board[ROW][COL])、left(int board[ROW][COL])、right(int board[ROW][COL])：分别实现了向上、向下、向左、向右移动的功能。这些函数用于处理玩家的移动操作，更新棋盘上的数字位置。

  5. is_win(int board[ROW][COL])：判断是否获胜。这个函数用于检查游戏是否达到了2048，如果有一个位置的值为2048，则游戏获胜。

  6. is_fail(int board[ROW][COL])：判断是否失败。这个函数用于检查游戏是否失败，即所有位置都被填满且无法进行有效的移动操作。

  1. #pragma once
  2.  
  3.  
  4. #include <stdio.h>
  5. #include <time.h>
  6. #include <stdlib.h>
  7. #include <windows.h>
  8. #include<conio.h>
  9.  
  10. #define ROW 4
  11. #define COL 4
  12. const int copy[ROW][COL];
  13.  
  14. //初始化并打印游戏界面
  15. void DisplayBoard(int board[ROW][COL]);
  16. //开局随机生成两个2
  17. void init_num(int board[ROW][COL]);
  18. //在移动后随机放置数字2或4
  19. void put_num(int board[ROW][COL]);
  20. //移动
  21. void up(int board[ROW][COL]);
  22. void down(int board[ROW][COL]);
  23. void left(int board[ROW][COL]);
  24. void right(int board[ROW][COL]);
  25. //判定胜负
  26. int is_win(int board[ROW][COL]);
  27. int is_fail(int board[ROW][COL]);

显示2048游戏的棋盘界面

        

  1. 打印横向的分隔线，使用"+"和"-"来表示。
  2. 遍历每个格子，如果格子上有数字，则打印该数字并确保宽度为5个字符，右对齐；如果格子上没有数字，则打印5个空格。
  3. 在每行末尾打印"|"
  4. 再次打印横向的分隔线，使用"+"和"-"来表示。
  1. void DisplayBoard(int board[ROW][COL])
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	printf("tip：*方向键控制方块移动*ESC键返回菜单*\n");
  6. 	for (int j = 0; j < COL; j++)
  7. 		printf("+-----");
  8. 	printf("+\n");
  9. 	for (int i = 0; i < ROW; i++)
  10. 	{
  11. 		for (int j = 0; j < COL; j++)
  12. 		{
  13. 			printf("|");
  14. 			if (board[i][j] != 0)
  15. 				printf("%5d", board[i][j]);
  16.  
  17. 			else
  18. 				printf("     ");
  19. 		}
  20. 		printf("|\n");
  21. 		for (int j = 0; j < COL; j++)
  22. 		{
  23. 			printf("+-----");
  24. 		}
  25. 		printf("+\n");
  26. 	}
  27. }

初始化游戏棋盘：

        

  1. 生成一个随机的行索引 x 和列索引 y，确保它们在棋盘范围内。
  2. 在随机选择的位置 (x, y) 上放置一个数字2。
  3. 再次生成一个随机的行索引 x 和列索引 y，确保它们与第一个位置不重复。
  4. 在新的随机选择的位置 (x, y) 上放置另一个数字2。
  1. void init_num(int board[ROW][COL])
  2. {
  3. 	int x, y;
  4. 	x = rand() % ROW;
  5. 	y = rand() % COL;
  6. 	board[x][y] = 2;//随机在一个位置生成2
  7. 	x = rand() % ROW;
  8. 	y = rand() % COL;
  9. 	while (board[x][y] == 2)
  10. 	{
  11. 		x = rand() % ROW;
  12. 		y = rand() % COL;
  13. 	}
  14. 	board[x][y] = 2;
  15. 	return;
  16. }

空白位置随机放置一个数字：

  1. 生成一个随机的行索引 x 和列索引 y，确保它们在棋盘范围内。
  2. 如果在选择的位置 (x, y) 上已经有数字，则继续随机选择位置，直到找到一个空白位置。
  3. 生成一个随机数 z，范围为0到9之间的整数。
  4. 如果 z 小于9，则在当前空白位置 (x, y) 放置数字2；如果 z 等于9，则放置数字4。
  1. void put_num(int board[ROW][COL])
  2. {
  3. 	int x = 0;
  4. 	int y = 0;
  5. 	int z = 0;
  6. 	x = rand() % ROW;
  7. 	y = rand() % COL;
  8. 	while (board[x][y] != 0)
  9. 	{
  10. 		x = rand() % ROW;
  11. 		y = rand() % COL;
  12. 	}
  13. 	z = rand() % 10;
  14. 	if (z < 9)
  15. 		board[x][y] = 2;
  16. 	else
  17. 		board[x][y] = 4;
  18. 	return;
  19. }

简单的 2048 游戏的移动和合并操作

        上下左右四个方向的移动操作：up、down、left、right

每个函数都按照相应的方向进行移动并合并相同的数字。

在每个函数中，首先进行移动操作，然后进行合并操作，再次进行移动操作，并最后检查游戏是否可以继续进行（通过contrast(board)函数判断）。如果游戏可以继续，则调用put_num(board)函数来生成新的数字；否则直接返回。

  1. void up(int board[ROW][COL])
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	int x = 0;
  6. 	int y = 0;
  7. 	for (i = 0; i < ROW; i++)
  8. 	{
  9. 		//移动
  10. 		j = 0;
  11. 		y = 0;
  12. 		while (j < COL - 1 && y < COL - 1)
  13. 		{
  14. 			if (board[j][i] == 0)
  15. 			{
  16. 				for (x = j; x < ROW - 1; x++)
  17. 					board[x][i] = board[x + 1][i];
  18. 				board[ROW - 1][i] = 0;
  19. 				y++;
  20. 			}
  21. 			else
  22. 				j++;
  23. 		}
  24. 		//合并
  25. 		for (j = 0; j < COL - 1; j++)
  26. 			if (board[j][i] == board[j + 1][i] && board[j][i] != 0)
  27. 			{
  28. 				board[j][i] = board[j][i] * 2;
  29. 				board[j + 1][i] = 0;
  30. 			}
  31. 		//再次移动补空
  32. 		j = 0;
  33. 		y = 0;
  34. 		while (j < COL - 1 && y < COL - 1)
  35. 		{
  36. 			if (board[j][i] == 0)
  37. 			{
  38. 				for (x = j; x < ROW - 1; x++)
  39. 					board[x][i] = board[x + 1][i];
  40. 				board[ROW - 1][i] = 0;
  41. 				y++;
  42. 			}
  43. 			else
  44. 				j++;
  45. 		}
  46. 	}
  47. 	if (contrast(board) == 0)
  48. 		put_num(board);
  49. 	else
  50. 		return;
  51. }
  52.  
  53. void down(int board[ROW][COL])
  54. {
  55. 	int i = 0;
  56. 	int j = 0;
  57. 	int x = 0;
  58. 	int y = 0;
  59. 	for (i = 0; i < ROW; i++)
  60. 	{
  61. 		j = COL - 1;
  62. 		y = 0;
  63. 		while (j > 0 && y < COL - 1)
  64. 		{
  65. 			if (board[j][i] == 0)
  66. 			{
  67. 				for (x = j; x > 0; x--)
  68. 					board[x][i] = board[x - 1][i];
  69. 				board[0][i] = 0;
  70. 				y++;
  71. 			}
  72. 			else
  73. 				j--;
  74. 		}
  75. 		for (j = COL - 1; j > 0; j--)
  76. 			if (board[j][i] == board[j - 1][i] && board[j][i] != 0)
  77. 			{
  78. 				board[j][i] = board[j][i] * 2;
  79. 				board[j - 1][i] = 0;
  80. 			}
  81. 		j = COL - 1;
  82. 		y = 0;
  83. 		while (j > 0 && y < COL - 1)
  84. 		{
  85. 			if (board[j][i] == 0)
  86. 			{
  87. 				for (x = j; x > 0; x--)
  88. 					board[x][i] = board[x - 1][i];
  89. 				board[0][i] = 0;
  90. 				y++;
  91. 			}
  92. 			else
  93. 				j--;
  94. 		}
  95. 	}
  96. 	if (contrast(board) == 0)
  97. 		put_num(board);
  98. 	else
  99. 		return;
  100. }
  101.  
  102. void left(int board[ROW][COL])
  103. {
  104. 	int i = 0;
  105. 	int j = 0;
  106. 	int x = 0;
  107. 	int y = 0;
  108. 	for (i = 0; i < ROW; i++)
  109. 	{
  110. 		j = 0;
  111. 		y = 0;
  112. 		while (j < 3 && y < 3)
  113. 		{
  114. 			if (board[i][j] == 0)
  115. 			{
  116. 				for (x = j; x < ROW - 1; x++)
  117. 					board[i][x] = board[i][x + 1];
  118. 				board[i][COL - 1] = 0;
  119. 				y++;
  120. 			}
  121. 			else
  122. 				j++;
  123. 		}
  124. 		for (j = 0; j < 3; j++)
  125. 			if (board[i][j] == board[i][j + 1] && board[i][j] != 0)
  126. 			{
  127. 				board[i][j] = board[i][j] * 2;
  128. 				board[i][j + 1] = 0;
  129. 			}
  130. 		j = 0;
  131. 		y = 0;
  132. 		while (j < 3 && y < 3)
  133. 		{
  134. 			if (board[i][j] == 0)
  135. 			{
  136. 				for (x = j; x < ROW - 1; x++)
  137. 					board[i][x] = board[i][x + 1];
  138. 				board[i][COL - 1] = 0;
  139. 				y++;
  140. 			}
  141. 			else
  142. 				j++;
  143. 		}
  144. 	}
  145. 	if (contrast(board) == 0)
  146. 		put_num(board);
  147. 	else
  148. 		return;
  149. }
  150.  
  151. void right(int board[ROW][COL])
  152. {
  153. 	int i = 0;
  154. 	int j = 0;
  155. 	int x = 0;
  156. 	int y = 0;
  157. 	for (i = 0; i < 4; i++)
  158. 	{
  159. 		j = COL - 1;
  160. 		y = 0;
  161. 		while (j > 0 && y < COL - 1)
  162. 		{
  163. 			if (board[i][j] == 0)
  164. 			{
  165. 				for (x = j; x > 0; x--)
  166. 					board[i][x] = board[i][x - 1];
  167. 				board[i][0] = 0;
  168. 				y++;
  169. 			}
  170. 			else j--;
  171. 		}
  172. 		for (j = 3; j > 0; j--)
  173. 			if (board[i][j] == board[i][j - 1] && board[i][j] != 0)
  174. 			{
  175. 				board[i][j] = board[i][j] * 2;
  176. 				board[i][j - 1] = 0;
  177. 			}
  178. 		j = COL - 1;
  179. 		y = 0;
  180. 		while (j > 0 && y < COL - 1)
  181. 		{
  182. 			if (board[i][j] == 0)
  183. 			{
  184. 				for (x = j; x > 0; x--)
  185. 					board[i][x] = board[i][x - 1];
  186. 				board[i][0] = 0;
  187. 				y++;
  188. 			}
  189. 			else j--;
  190. 		}
  191. 	}
  192. 	if (contrast(board) == 0)
  193. 		put_num(board);
  194. 	else
  195. 		return;
  196. }

判断在 2048 游戏中是否无法继续移动

  1. 游戏板上还有空格（值为0），即游戏可以继续；
  2. 相邻的方块（上下或左右相邻）有相同的值，即游戏可以继续合并。

如果以上任意情况成立，函数将返回0，表示游戏可以继续；否则，如果所有方块都被填满且没有相邻方块的值相同，函数将返回1，表示游戏无法继续移动，游戏结束。

  1. int is_fail(int board[ROW][COL])
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	for (i = 0; i < ROW; i++)
  6. 	{
  7. 		for (j = 0; j < COL; j++)
  8. 		{
  9. 			if (board[i][j] == 0)
  10. 				return 0;
  11. 			if (i > 0)
  12. 			{
  13. 				if (board[i - 1][j] == board[i][j])
  14. 					return 0;
  15. 			}
  16. 			if (j > 0)
  17. 			{
  18. 				if (board[i][j - 1] == board[i][j])
  19. 					return 0;
  20. 			}
  21. 		}
  22. 	}
  23. 	return 1;
  24. }

检查在2048游戏中是否获胜

该函数遍历整个游戏板，找到其中的最大值。如果最大值达到或超过2048，函数将返回1，表示玩家已经获胜；否则返回0，表示游戏尚未获胜。

在2048游戏中，玩家的目标是通过合并方块使得其中一个方块的值达到2048。一旦某个方块的值达到2048，玩家就获胜了。

这个函数的作用是在每一步移动后检查游戏是否已经达到了获胜条件。如果返回1，通常会触发游戏获胜的逻辑，比如显示获胜信息或者终止游戏等。

  1. int is_win(int board[ROW][COL])
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	int num = 0;
  6. 	for (i = 0; i < ROW; i++)
  7. 		for (j = 0; j < COL; j++)
  8. 		{
  9. 			if (board[i][j] > num)
  10. 				num = board[i][j];
  11. 		}
  12. 	if (num >= 2048)
  13. 		return 1;
  14. 	else
  15. 		return 0;
  16. }

        copyboard 函数的作用是将一个二维数组 board 中的元素复制到另一个二维数组 copy 中。通常在编程中，这样的函数用于保存一个数组的副本，以便后续的比较或者其他操作而不影响原始数组。

  1. void copyboard(int board[ROW][COL], int copy[ROW][COL])
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	for (i = 0; i < ROW; i++)
  6. 		for (j = 0; j < COL; j++)
  7. 			copy[i][j] = board[i][j];
  8. }

菜单功能：

  1. void menu()
  2. {
  3. 	printf("**************************\n");
  4. 	printf("**************************\n");
  5. 	printf("**************************\n");
  6. 	printf("*****按 1 开 始 游 戏*****\n");
  7. 	printf("*****按 0 退 出 游 戏*****\n");
  8. 	printf("**************************\n");
  9. 	printf("**************************\n");
  10. 	printf("**************************\n");
  11. }

主函数：

  1. int main()
  2. {
  3. 	int input = 0;
  4. 	srand((unsigned int)time(NULL));
  5. 	do
  6. 	{
  7. 		menu();
  8. 		printf("请选择：");
  9. 		scanf("%d", &input);
  10. 		switch (input)
  11. 		{
  12. 		case 1:
  13. 			game2048();
  14.  
  15. 			break;
  16. 		case 0:
  17. 			printf("退出游戏)\n");
  18. 			break;
  19. 		default:
  20. 			printf("再次进入游戏\n");
  21. 			break;
  22. 		}
  23. 	} while (input);
  24. 	return 0;
  25. }

完整代码：

        Test.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "game2048.h"
  3.  
  4. void menu()
  5. {
  6. 	printf("**************************\n");
  7. 	printf("**************************\n");
  8. 	printf("**************************\n");
  9. 	printf("*****按 1 开 始 游 戏*****\n");
  10. 	printf("*****按 0 退 出 游 戏*****\n");
  11. 	printf("**************************\n");
  12. 	printf("**************************\n");
  13. 	printf("**************************\n");
  14. }
  15.  
  16. void game2048()
  17. {
  18. 	int board[ROW][COL] = { {0} };
  19. 	int control = 0;
  20. 	DisplayBoard(board);
  21. 	init_num(board);
  22. 	system("cls"); //清屏，美观界面
  23. 	DisplayBoard(board);
  24. 	while ((control = _getch()) != 0x1b)
  25. 	{
  26. 		switch (control)
  27. 		{
  28. 		case 0xe0:
  29. 			switch (control = getch())
  30. 			{
  31. 			case 72:
  32. 				copyboard(board, copy);
  33. 				up(board);
  34. 				break;
  35. 			case 80:
  36. 				copyboard(board, copy);
  37. 				down(board);
  38. 				break;
  39. 			case 75:
  40. 				copyboard(board, copy);
  41. 				left(board);
  42. 				break;
  43. 			case 77:
  44. 				copyboard(board, copy);
  45. 				right(board);
  46. 				break;
  47. 			default:
  48. 				break;
  49. 			}
  50.  
  51. 			system("cls");
  52. 			DisplayBoard(board);
  53. 			if (is_win(board) == 1)
  54. 			{
  55. 				printf("恭喜你赢了！\n");
  56. 			}
  57. 			if (is_fail(board) == 1)
  58. 			{
  59. 				printf("抱歉,您未能通关\n");
  60. 			}
  61. 		}
  62. 	}
  63. }
  64.  
  65. int main()
  66. {
  67. 	int input = 0;
  68. 	srand((unsigned int)time(NULL));
  69. 	do
  70. 	{
  71. 		menu();
  72. 		printf("请选择：");
  73. 		scanf("%d", &input);
  74. 		switch (input)
  75. 		{
  76. 		case 1:
  77. 			game2048();
  78.  
  79. 			break;
  80. 		case 0:
  81. 			printf("退出游戏)\n");
  82. 			break;
  83. 		default:
  84. 			printf("再次进入游戏\n");
  85. 			break;
  86. 		}
  87. 	} while (input);
  88. 	return 0;
  89. }

game.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #define _CRT_SECURE_NO_WARNINGS 1
  3. #include "game2048.h"
  4.  
  5. void DisplayBoard(int board[ROW][COL])
  6. {
  7. 	int i = 0;
  8. 	int j = 0;
  9. 	printf("tip：*方向键控制方块移动*ESC键返回菜单*\n");
  10. 	for (int j = 0; j < COL; j++)
  11. 		printf("+-----");
  12. 	printf("+\n");
  13. 	for (int i = 0; i < ROW; i++)
  14. 	{
  15. 		for (int j = 0; j < COL; j++)
  16. 		{
  17. 			printf("|");
  18. 			if (board[i][j] != 0)
  19. 				printf("%5d", board[i][j]);
  20.  
  21. 			else
  22. 				printf("     ");
  23. 		}
  24. 		printf("|\n");
  25. 		for (int j = 0; j < COL; j++)
  26. 		{
  27. 			printf("+-----");
  28. 		}
  29. 		printf("+\n");
  30. 	}
  31. }
  32.  
  33. void init_num(int board[ROW][COL])
  34. {
  35. 	int x, y;
  36. 	x = rand() % ROW;
  37. 	y = rand() % COL;
  38. 	board[x][y] = 2;//随机在一个位置生成2
  39. 	x = rand() % ROW;
  40. 	y = rand() % COL;
  41. 	while (board[x][y] == 2)
  42. 	{
  43. 		x = rand() % ROW;
  44. 		y = rand() % COL;
  45. 	}
  46. 	board[x][y] = 2;
  47. 	return;
  48. }
  49.  
  50. void put_num(int board[ROW][COL])
  51. {
  52. 	int x = 0;
  53. 	int y = 0;
  54. 	int z = 0;
  55. 	x = rand() % ROW;
  56. 	y = rand() % COL;
  57. 	while (board[x][y] != 0)
  58. 	{
  59. 		x = rand() % ROW;
  60. 		y = rand() % COL;
  61. 	}
  62. 	z = rand() % 10;
  63. 	if (z < 9)
  64. 		board[x][y] = 2;
  65. 	else
  66. 		board[x][y] = 4;
  67. 	return;
  68. }
  69.  
  70. void up(int board[ROW][COL])
  71. {
  72. 	int i = 0;
  73. 	int j = 0;
  74. 	int x = 0;
  75. 	int y = 0;
  76. 	for (i = 0; i < ROW; i++)
  77. 	{
  78. 		//移动
  79. 		j = 0;
  80. 		y = 0;
  81. 		while (j < COL - 1 && y < COL - 1)
  82. 		{
  83. 			if (board[j][i] == 0)
  84. 			{
  85. 				for (x = j; x < ROW - 1; x++)
  86. 					board[x][i] = board[x + 1][i];
  87. 				board[ROW - 1][i] = 0;
  88. 				y++;
  89. 			}
  90. 			else
  91. 				j++;
  92. 		}
  93. 		//合并
  94. 		for (j = 0; j < COL - 1; j++)
  95. 			if (board[j][i] == board[j + 1][i] && board[j][i] != 0)
  96. 			{
  97. 				board[j][i] = board[j][i] * 2;
  98. 				board[j + 1][i] = 0;
  99. 			}
  100. 		//再次移动补空
  101. 		j = 0;
  102. 		y = 0;
  103. 		while (j < COL - 1 && y < COL - 1)
  104. 		{
  105. 			if (board[j][i] == 0)
  106. 			{
  107. 				for (x = j; x < ROW - 1; x++)
  108. 					board[x][i] = board[x + 1][i];
  109. 				board[ROW - 1][i] = 0;
  110. 				y++;
  111. 			}
  112. 			else
  113. 				j++;
  114. 		}
  115. 	}
  116. 	if (contrast(board) == 0)
  117. 		put_num(board);
  118. 	else
  119. 		return;
  120. }
  121.  
  122. void down(int board[ROW][COL])
  123. {
  124. 	int i = 0;
  125. 	int j = 0;
  126. 	int x = 0;
  127. 	int y = 0;
  128. 	for (i = 0; i < ROW; i++)
  129. 	{
  130. 		j = COL - 1;
  131. 		y = 0;
  132. 		while (j > 0 && y < COL - 1)
  133. 		{
  134. 			if (board[j][i] == 0)
  135. 			{
  136. 				for (x = j; x > 0; x--)
  137. 					board[x][i] = board[x - 1][i];
  138. 				board[0][i] = 0;
  139. 				y++;
  140. 			}
  141. 			else
  142. 				j--;
  143. 		}
  144. 		for (j = COL - 1; j > 0; j--)
  145. 			if (board[j][i] == board[j - 1][i] && board[j][i] != 0)
  146. 			{
  147. 				board[j][i] = board[j][i] * 2;
  148. 				board[j - 1][i] = 0;
  149. 			}
  150. 		j = COL - 1;
  151. 		y = 0;
  152. 		while (j > 0 && y < COL - 1)
  153. 		{
  154. 			if (board[j][i] == 0)
  155. 			{
  156. 				for (x = j; x > 0; x--)
  157. 					board[x][i] = board[x - 1][i];
  158. 				board[0][i] = 0;
  159. 				y++;
  160. 			}
  161. 			else
  162. 				j--;
  163. 		}
  164. 	}
  165. 	if (contrast(board) == 0)
  166. 		put_num(board);
  167. 	else
  168. 		return;
  169. }
  170.  
  171. void left(int board[ROW][COL])
  172. {
  173. 	int i = 0;
  174. 	int j = 0;
  175. 	int x = 0;
  176. 	int y = 0;
  177. 	for (i = 0; i < ROW; i++)
  178. 	{
  179. 		j = 0;
  180. 		y = 0;
  181. 		while (j < 3 && y < 3)
  182. 		{
  183. 			if (board[i][j] == 0)
  184. 			{
  185. 				for (x = j; x < ROW - 1; x++)
  186. 					board[i][x] = board[i][x + 1];
  187. 				board[i][COL - 1] = 0;
  188. 				y++;
  189. 			}
  190. 			else
  191. 				j++;
  192. 		}
  193. 		for (j = 0; j < 3; j++)
  194. 			if (board[i][j] == board[i][j + 1] && board[i][j] != 0)
  195. 			{
  196. 				board[i][j] = board[i][j] * 2;
  197. 				board[i][j + 1] = 0;
  198. 			}
  199. 		j = 0;
  200. 		y = 0;
  201. 		while (j < 3 && y < 3)
  202. 		{
  203. 			if (board[i][j] == 0)
  204. 			{
  205. 				for (x = j; x < ROW - 1; x++)
  206. 					board[i][x] = board[i][x + 1];
  207. 				board[i][COL - 1] = 0;
  208. 				y++;
  209. 			}
  210. 			else
  211. 				j++;
  212. 		}
  213. 	}
  214. 	if (contrast(board) == 0)
  215. 		put_num(board);
  216. 	else
  217. 		return;
  218. }
  219.  
  220. void right(int board[ROW][COL])
  221. {
  222. 	int i = 0;
  223. 	int j = 0;
  224. 	int x = 0;
  225. 	int y = 0;
  226. 	for (i = 0; i < 4; i++)
  227. 	{
  228. 		j = COL - 1;
  229. 		y = 0;
  230. 		while (j > 0 && y < COL - 1)
  231. 		{
  232. 			if (board[i][j] == 0)
  233. 			{
  234. 				for (x = j; x > 0; x--)
  235. 					board[i][x] = board[i][x - 1];
  236. 				board[i][0] = 0;
  237. 				y++;
  238. 			}
  239. 			else j--;
  240. 		}
  241. 		for (j = 3; j > 0; j--)
  242. 			if (board[i][j] == board[i][j - 1] && board[i][j] != 0)
  243. 			{
  244. 				board[i][j] = board[i][j] * 2;
  245. 				board[i][j - 1] = 0;
  246. 			}
  247. 		j = COL - 1;
  248. 		y = 0;
  249. 		while (j > 0 && y < COL - 1)
  250. 		{
  251. 			if (board[i][j] == 0)
  252. 			{
  253. 				for (x = j; x > 0; x--)
  254. 					board[i][x] = board[i][x - 1];
  255. 				board[i][0] = 0;
  256. 				y++;
  257. 			}
  258. 			else j--;
  259. 		}
  260. 	}
  261. 	if (contrast(board) == 0)
  262. 		put_num(board);
  263. 	else
  264. 		return;
  265. }
  266.  
  267. int is_fail(int board[ROW][COL])
  268. {
  269. 	int i = 0;
  270. 	int j = 0;
  271. 	for (i = 0; i < ROW; i++)
  272. 	{
  273. 		for (j = 0; j < COL; j++)
  274. 		{
  275. 			if (board[i][j] == 0)
  276. 				return 0;
  277. 			if (i > 0)
  278. 			{
  279. 				if (board[i - 1][j] == board[i][j])
  280. 					return 0;
  281. 			}
  282. 			if (j > 0)
  283. 			{
  284. 				if (board[i][j - 1] == board[i][j])
  285. 					return 0;
  286. 			}
  287. 		}
  288. 	}
  289. 	return 1;
  290. }
  291.  
  292. int is_win(int board[ROW][COL])
  293. {
  294. 	int i = 0;
  295. 	int j = 0;
  296. 	int num = 0;
  297. 	for (i = 0; i < ROW; i++)
  298. 		for (j = 0; j < COL; j++)
  299. 		{
  300. 			if (board[i][j] > num)
  301. 				num = board[i][j];
  302. 		}
  303. 	if (num >= 2048)
  304. 		return 1;
  305. 	else
  306. 		return 0;
  307. }
  308.  
  309. void copyboard(int board[ROW][COL], int copy[ROW][COL])
  310. {
  311. 	int i = 0;
  312. 	int j = 0;
  313. 	for (i = 0; i < ROW; i++)
  314. 		for (j = 0; j < COL; j++)
  315. 			copy[i][j] = board[i][j];
  316. }
  317.  
  318. int contrast(int board[ROW][COL])
  319. {
  320. 	int i = 0;
  321. 	int j = 0;
  322. 	for (i = 0; i < 4; i++)
  323. 		for (j = 0; j < 4; j++)
  324. 			if (copy[i][j] != board[i][j])
  325. 				return 0;
  326. 	return 1;
  327. }

【文末送书】

京东链接：

https://item.jd.com/14022531.html

当当链接：

《DevOps: 企业级CI/CD实战》(李泽阳)【简介_书评_在线阅读】 - 当当图书

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

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

  

闽ICP备14008679号