C语言版2048小游戏

一、游戏特点

2048是一款数字益智类游戏，玩家需要使用键盘控制数字方块的移动，合并相同数字的方块，最终达到数字方块上出现“2048”的目标。
为用C语言实现2048的小游戏项目，我们需先观察2048小游戏的特点和我们需要实现的一些功能：
1.需要一个棋盘来储存数字，用什么来表示棋盘？
2.需要控制数字的移动，怎样控制数字的移动？
3.需要在数字移动的过程中产生新的随机数，怎么生成新的随机数？
4.需要控制数字是否需要合成，怎么判断数字是否需要合成和怎么合成？
5.需要判断判定游戏是否成功，怎么判断游戏是否结束？
6.需要丰富游戏的界面，怎样使游戏界面好看一点？
二、游戏运行示意图

三、工具准备

1.代码运行平台：Visual Studio 2022
官网地址：https://visualstudio.microsoft.com/zh-hans/
2.图形库：Easyx
官网地址：https://easyx.cn/
四、代码实现流程

一、核心逻辑

1、棋盘制作
用二维数组来存储数字，制作与显示棋盘

1. //用整型数组表示矩阵方格
2. int arr[4][4] = { 0 };
3. //打印矩阵方格的数据
4. void PrintArr()
5. {
6.         for (int row = 0; row < 4; row++)
7.         {
8.                 for (int column = 0; column < 4; column++)
9.                 {
10.                         printf("%d\t", arr[row][column]);
11.                 }
12.                 printf("\n");
13.         }
14. }

复制代码

2、控制数字的移动与合成

1. //向左边移动
2. void Left()
3. {
4.         //遍历行
5.         for (int row = 0; row < 4; row++)
6.         {
7.                 for (int column = 0; column < 4; column++)
8.                 {
9.             //如果当前格子为空，则向右移动
10.                         if (arr[row][column] == 0)
11.                         {
12.                                 //从后面找一个不为空的格子，如果找到，则交换位置
13.                                 for (int i = column + 1; i < 4; i++)
14.                                 {
15.                                         if (arr[row][i]!= 0)
16.                                         {
17.                                                 arr[row][column] = arr[row][i];
18.                                                 arr[row][i] = 0;
19.                                                 //处理一个非空位置后，条件不成立，不能往后走了
20.                                                 break;
21.                                         }
22.                                 }
23.                         }
24.                         //如果不为0，表示要合并
25.                         if (arr[row][column] != 0)
26.                         {
27.                                 //从后面找一个和当前数据相同的数据，遇到0就跳过，遇到不同的，退出
28.                                 for (int i = column + 1; i < 4; i++)
29.                                 {
30.                                         if (arr[row][i] == arr[row][column])
31.                                         {
32.                                                 //数据合并
33.                                                 arr[row][column] *= 2;
34.                                                 arr[row][i] = 0;
35.                                                 //合并完成就结束查找
36.                                                 break;
37.                                         }
38.                                         else if (arr[row][i] == 0)
39.                                                 continue;
41.                                         else
42.                                                 break;
43.                                 }
44.                         }
45.                 }
46.         }
47.         CreateRandData(1);
48. }
49. //向右边移动
50. void Right()
51. {
52.         for (int row = 0; row < 4; row++)
53.         {
54.                 for (int column = 3; column >= 0; column--)
55.                 {
56.                         //如果当前格子为空，则向左移动
57.                         if (arr[row][column] == 0)
58.                         {
59.                                 //从后面找一个不为空的格子，如果找到，则交换位置
60.                                 for (int i = column - 1; i >= 0; i--)
61.                                 {
62.                                         if (arr[row][i] != 0)
63.                                         {
64.                                                 arr[row][column] = arr[row][i];
65.                                                 arr[row][i] = 0;
66.                                                 //处理一个非空位置后，条件不成立，不能往后走了
67.                                                 break;
68.                                         }
69.                                 }
70.                         }
71.                         //如果不为0，表示要合并
72.                         if (arr[row][column] != 0)
73.                         {
74.                                 //从后面找一个和当前数据相同的数据，遇到0就跳过，遇到不同的，退出
75.                                 for (int i = column - 1; i >=0; i--)
76.                                 {
77.                                         if (arr[row][i] == arr[row][column])
78.                                         {
79.                                                 //数据合并
80.                                                 arr[row][column] *= 2;
81.                                                 arr[row][i] = 0;
82.                                                 //合并完成就结束查找
83.                                                 break;
84.                                         }
85.                                         else if (arr[row][i] == 0)
86.                                                 continue;
88.                                         else
89.                                                 break;
90.                                 }
91.                         }
92.                 }
93.         }
94.         CreateRandData(1);
95. }
96. //向上边移动
97. void Up()
98. {
99.         for (int column = 0; column < 4; column++)
100.         {
101.                 for (int row = 0; row < 4; row++)
102.                 {
103.                         //如果当前格子为空，则向下移动
104.                         if (arr[row][column] == 0)
105.                         {
106.                                 //从后面找一个不为空的格子，如果找到，则交换位置
107.                                 for (int i = row + 1; i < 4; i++)
108.                                 {
109.                                         if (arr[i][column] != 0)
110.                                         {
111.                                                 arr[row][column] = arr[i][column];
112.                                                 arr[i][column] = 0;
113.                                                 //处理一个非空位置后，条件不成立，不能往后走了
114.                                                 break;
115.                                         }
116.                                 }
117.                         }
118.                         //如果不为0，表示要合并
119.                         if (arr[row][column] != 0)
120.                         {
121.                                 //从后面找一个和当前数据相同的数据，遇到0就跳过，遇到不同的，退出
122.                                 for (int i = row + 1; i < 4; i++)
123.                                 {
124.                                         if (arr[i][column] == arr[row][column])
125.                                         {
126.                                                 //数据合并
127.                                                 arr[row][column] *= 2;
128.                                                 arr[i][column] = 0;
129.                                                 //合并完成就结束查找
130.                                                 break;
131.                                         }
132.                                         else if (arr[i][column] == 0)
133.                                                 continue;
135.                                         else
136.                                                 break;
137.                                 }
138.                         }
139.                 }
140.         }
141.         CreateRandData(1);
142. }
143. //向下边移动
144. void Down()
145. {
146.         for (int column = 0; column < 4; column++)
147.         {
148.                 for (int row = 3; row >= 0; row--)
149.                 {
150.                         //如果当前格子为空，则向上移动
151.                         if (arr[row][column] == 0)
152.                         {
153.                                 //从后面找一个不为空的格子，如果找到，则交换位置
154.                                 for (int i = row - 1; i >= 0; i--)
155.                                 {
156.                                         if (arr[i][column] != 0)
157.                                         {
158.                                                 arr[row][column] = arr[i][column];
159.                                                 arr[i][column] = 0;
160.                                                 //处理一个非空位置后，条件不成立，不能往后走了
161.                                                 break;
162.                                         }
163.                                 }
164.                         }
165.                         //如果不为0，表示要合并
166.                         if (arr[row][column] != 0)
167.                         {
168.                                 //从后面找一个和当前数据相同的数据，遇到0就跳过，遇到不同的，退出
169.                                 for (int i = row - 1; i >= 0; i--)
170.                                 {
171.                                         if (arr[i][column] == arr[row][column])
172.                                         {
173.                                                 //数据合并
174.                                                 arr[row][column] *= 2;
175.                                                 arr[i][column] = 0;
176.                                                 //合并完成就结束查找
177.                                                 break;
178.                                         }
179.                                         else if (arr[i][column] == 0)
180.                                                 continue;
182.                                         else
183.                                                 break;
184.                                 }
185.                         }
186.                 }
187.         }
188.         CreateRandData(1);
189. }

复制代码

3、判断是否可以合成
[code]//是否可以合成int CamMerge(){        for (int row = 0; row < 4; row++)        {                for (int column = 0; column < 4; column++)                {                        if (column+1