一. 前言
在我们的DIY套件上，终于集成了第三个小游戏----2048。怎么感觉做成了个游戏机呢(#.#)。
这款游戏也是非常流行的，玩起来也是非常的轻松，要想过关的话，还是需要一点的技巧。

二. 游戏规则简介
1.游戏地图为 4 * 4。
2.每次移动所以方块都会向指定的方向移动，同时会在地图上随机生成值为2或者4的方块。
3.在移动的过程中，如果相邻的两个方块的值一样，那么它们就会融合成一个值为它们之合的方块，每一次移动，只能进行一次融合。
4.如果方块中的值为2048，则游戏胜利。如果整个地图都被方块添满了，则游戏失败。
三. 核心代码介绍
方块的随机生成，和胜利的判断的实现都较为容易。整个游戏的核心部分为第三点，方块的移动和融合，这个部分如果弄懂了的话，整个游戏实现起来会非常容易。
先在Visual Studio实现这一过程的准确性，然后在搬运到keil中去，这一方便debug发现问题。

这里先合并，后移动

1.通过定义一个长度为4的数组，来模拟一行数据。

1. int Map[4] = { 0,8,0,8 };

复制代码

2.通过循环来找到可以合并的两个数，将其合并

1. for (j = i + 1; j < 4; j++)
   
2. {
   
3.         //如果不为0，且当前选择的值也不为0，且和这个数不相等，则跳过
   
4.         if (Map[j] != Map&& Map[j] != 0)
   
5.                 break;
   
6. 
   
7.         //如果有相等的两个方块，且中没有其余方块，进行融合
   
8.         if (Map[j] == Map)
   
9.         {
   
10.                 Map[j] = 0; //先将这方块消除掉
    
11.                 unsigned char k;
    
12.                 for (k = i + 1; k < 3; k++)
    
13.                 {
    
14.                         Map[k] = Map[k + 1]; //移动一次方块
    
15.                 }
    
16.                 Map += Map;//更新融合后的方块的值
    
17.                 Map[3] = 0;
    
18.                 flag = 1;
    
19.                 break;
    
20.         }
    
21. }
    

复制代码

3.移动所有方块，直到所有方块都靠在一起

1. while (1)
   
2. {
   
3.         int j, flag = 0;
   
4.         for (i = 0; i < 3; i++)
   
5.         {
   
6.                 if (Map == 0) //有空的方块，说明可以移动
   
7.                 {
   
8.                         Map = Map[i + 1];
   
9.                         Map[i + 1] = 0;
   
10.                 }
    
11.         }
    
12.         for (j = 0; j < 3; j++)
    
13.         {
    
14.                 if (Map[j] == 0)
    
15.                 {
    
16.                         int k;
    
17.                         for (k = j + 1; k < 4; k++)
    
18.                         {
    
19.                                 if (Map[k] != 0) //判断是否继续移动
    
20.                                 {
    
21.                                         flag = 1;  
    
22.                                         break;
    
23.                                 }
    
24.                         }
    
25.                 }
    
26.         }
    
27.         if (flag == 0)
    
28.                 break;
    
29. }

复制代码

4.测试结果展示








完整测试代码

1. 
   
2. int main(void)
   
3. {
   
4.         int Map[4] = { 0,2,4,8};
   
5.         int i,flag = 0;
   
6.         int flags = 0;
   
7.         for (i = 0; i < 4; i++)
   
8.                 printf("%d\t", Map);
   
9.         printf("\n");
   
10. 
    
11.         for (i = 0; i < 3; i++)
    
12.         {
    
13.                 unsigned char j;
    
14.                 for (j = i + 1; j < 4; j++)
    
15.                 {
    
16.                         //如果不为0，且当前选择的值也不为0，且和这个数不相等，则跳过
    
17.                         if (Map[j] != Map && Map[j] != 0)
    
18.                                 break;
    
19. 
    
20.                         //如果有相等的两个方块，且中没有其余方块
    
21.                         if (Map[j] == Map)
    
22.                         {
    
23.                                 Map[j] = 0;
    
24.                                 unsigned char k;
    
25.                                 for (k = i + 1; k < 3; k++)
    
26.                                 {
    
27.                                         Map[k] = Map[k + 1];
    
28.                                 }
    
29.                                 Map += Map;
    
30.                                 Map[3] = 0;
    
31.                                 flags = 1;
    
32.                                 break;
    
33.                         }
    
34.                 }
    
35.                
    
36.                         while (1)
    
37.                         {
    
38.                                 int j, flag = 0;
    
39.                                 for (i = 0; i < 3; i++)
    
40.                                 {
    
41.                                         if (Map == 0)
    
42.                                         {
    
43.                                                 Map = Map[i + 1];
    
44.                                                 Map[i + 1] = 0;
    
45.                                         }
    
46.                                 }
    
47.                                 for (j = 0; j < 3; j++)
    
48.                                 {
    
49.                                         if (Map[j] == 0)
    
50.                                         {
    
51.                                                 int k;
    
52.                                                 for (k = j + 1; k < 4; k++)
    
53.                                                 {
    
54.                                                         if (Map[k] != 0)
    
55.                                                         {
    
56.                                                                 flag = 1;
    
57.                                                                 break;
    
58.                                                         }
    
59.                                                 }
    
60.                                         }
    
61.                                 }
    
62.                                 if (flag == 0)
    
63.                                         break;
    
64.                         }
    
65.                         for (i = 0; i < 4; i++)
    
66.                                 printf("%d\t", Map);
    
67.                         printf("\n");
    
68.                
    
69.         }
    
70.         return flags;
    
71. }

复制代码