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

Linux下用C++实现2048小游戏详解_2048小游戏linux实验报告

作者：小小林熬夜学编程 | 2024-03-05 15:20:38

赞

踩

2048小游戏linux实验报告

目录

项目分析

库函数的基本运用

游戏界面盘子的绘制

绘制游戏界面盘子

操作界面进一步的完善

游戏的实现

数字在盘子中的位置

重新初始化游戏

实现向左移动合并数字

实现向其它方向的移动并合并数字

项目完整代码

对于2048这个小游戏大家应该都玩过，没玩过的话，可以点击下方的链接进去玩一下。

2048游戏网页链接

2048是一个风靡全球的益智类小游戏，通过上下左右控制来合并盘子里的数字，直到盘子里出现2048。

项目分析

我们今天在Linux下用C++实现2048编程小项目，自己动手实践一下。

首先前提是，小伙伴们必须要有Linux操作系统，没有的小伙伴可以自己去网上百度安装一个。

我们先简单了解一下2048的原理：

1. 通过上下左右来控制合并盘子里的数字。

2. 每次合并只能合并相邻的两个数字，例如 [2 2 2 2] ，向右合并以后是 [空 空 4 4] ，不是 [空 空 空 8]。

3. 每次合并的时候，合并那个方向的数字优先级高，例如 [空 2 2 2]，向右合并以后是 [空 空 2 4]，不是 [空 空 4 2]。

4. 判断游戏胜利的条件是盘子里出现数字2048。

5. 判断游戏失败的条件是盘子里的数字占满了，此时盘子中没有出现数字2048，且相邻的数字之间不满足合并要求，例如

此时盘子里相邻的数字之间都不能再合并了。

6. 盘子中每次重新开始会随机在两个空的位置产生数字2或者4。

7. 盘子中每次合并后出现新数字4的概率为10%。

8. 每次移动之后会在空的位置中随机产生一个数字2或者4。

库函数<curses.h>的基本运用

我们在Linux中依赖库函数<curses.h>来绘制图形界面和控制上下左右的移动操作，一般Linux中没有安装这个库，你可以输入这个操作命令安装这个<curses.h>库：$ apt-get install libncurses5-dev     安装完成之后，我们先简单了解一下这个库函数所包含的我们会使用到的函数。

initscr();ncurses初始化，初始化一下屏幕
cbreak();按键不需要输入回车直接交互，也就是我输入一个字符不需要回车 ，输入函数就可以得到这个字符了
noecho();

按键不显示，使你输入的字符不在屏幕上显示，就和Linux输密码一样，屏幕上看不到你输入了什么

curs_set(0);隐藏输入光标，平时输入时，输入位置会有一个光标在一闪一闪的，这个函数将光标隐藏起来了。
endwin();ncurses清理，清理屏幕。
move(5,5); 和addch(ch);将输入光标移到屏幕坐标（5,5）的位置上，然后使你要输入的字符显示在屏幕位置（5,5）上
mvprintw(8,8,"2048小游戏")；在指定位置打印字符串，在坐标（8,8）处打印字符串“Game 2048”

这几个就是我们要使用的库<curses.h>中的几个函数。库<curses.h>对中文不是很友好，比如函数mvprintw()中的字符串如果你用中文的话程序运行显示在屏幕上的就是一串乱码。

注意：函数move(row, column); 和函数mvprintw(row, column,"***"); 中的坐标row代表第几行，column代表第几空格。例如

  1. move(0,0);//将光标移到0*0的位置上 
  2. addch(ch);//使你要输入的字符显示在屏幕位置0*0上
  3. mvprintw(1,2,"Game 2048");//在1*2的位置上打印一个字符串

 这几个代码显示在屏幕上就是：

来仔细说明一下：

字符n的位置为（0,0），就是第0行第0个空格的位置；字符串“GAME 2048”中G的位置为（1,2），也就是第1行第2个空格的位置。所以说这两个函数是有坐标（0,0）的，也就是我们通常意义上的第一行第一个空格，但其实在函数中是第0行第0个空格的位置。

我们将这几个函数写成一个简易的程序来执行一下。代码如下所示：

  1. //step1.cpp
  2. #include<iostream>
  3. #include<curses.h>
  4. using namespace std;
  5.  
  6. void initialize()
  7. {
  8.     //ncurse初始化
  9.     initscr(); //初始化一下屏幕
  10.     //按键不需要输入回车直接交互
  11.     cbreak();//也就是我输入一个字符不需要回车  输入函数就可以得到这个字符了
  12.     //按键不显示
  13.     noecho();//使你输入的字符不在屏幕上显示，就和Linux输密码一样 屏幕上看不到你输入了什么
  14.     //隐藏光标
  15.     curs_set(0);//将输入为止的光标隐藏 
  16. }
  17. void shutdown()
  18. {
  19.     //ncurses清理
  20.     endwin();
  21. }
  22.  
  23. int main()
  24. {
  25.     initialize();
  26.  
  27.     char ch='n'; //将ch初始化为n
  28.     do
  29.     {
  30.         move(5,5);//将光标移到5*5的位置上 
  31.         addch(ch);//使你要输入的字符显示在屏幕位置5*5上
  32.         mvprintw(8,8,"Game 2048");//在2*2的位置上打印一个字符串  在指定位置打印字符串
  33.         ch=getch();//获取你输入的字符 赋值给ch  
  34.     }while(ch!='Q'&&ch !='q');//判断循环是否继续
  35.  
  36.     shutdown();
  37.     return 0;
  38. }
  39.

我们来看一下执行效果：

你随意按一个字符，屏幕上字符a就会变成你所按的字符，且字符a处没有光标闪烁。

游戏界面盘子的绘制

在了解了我们所要使用的几个函数之后，我们创建一个游戏类Game，用来实现2048游戏的主体。接下来我们来绘制一下简易的盘子。我们可以用符号+、-、|来绘制盘子。绘制的大概效果图如下所示：

绘制游戏界面盘子

我们可以将函数move();和函数addch();包装成一个函数drawch(int row, int col, char c)；调用这个函数时传入坐标和要显示的字符就可以了，代码如下所示：

  1. // 在指定的位置画一个字符
  2. void drawch(int row, int col, char c) 
  3. {
  4.     move(row, col);
  5.     addch(c);
  6. }

我们结合函数drawch();和for循环就能画出来，因为符号的位置是有规律的，我们可以用for循环将坐标传入给函数drawch();让符号在指定的位置显示即可。代码如下所示：

  1. //step2.cpp
  2. #include<iostream>
  3. #include<curses.h>
  4. using namespace std;
  5.  
  6. #define N 4 //格子数量
  7. #define W 5 //格子的宽度
  8.  
  9. class Game
  10. {
  11. public:
  12.     Game(){} //构造函数
  13.     //绘制游戏界面
  14.     void draw()
  15.     {        
  16.         //清理屏幕
  17.         clear();
  18.         //居中偏移
  19.         for(int i = 0; i<=N; ++i)
  20.         {     
  21.             for(int j = 0; j<=N ;++j)
  22.             {
  23.                 //绘制相交点
  24.                 drawch(i*2, j*W, '+');
  25.                 
  26.                 //绘制竖线
  27.                 if(i != N)
  28.                 {
  29.                     drawch(i*2+1, j*W, '|');
  30.                 }
  31.  
  32.                 //绘制横线
  33.                 for(int k=0; j != N && k<N; ++k)
  34.                 {
  35.                     drawch(i*2, 1 + j*W + k,'-');
  36.                 }  
  37.             }
  38.         }
  39.     }
  40. private:
  41.     // 在指定的位置画一个字符
  42.     void drawch(int row, int col, char c)
  43.     {
  44.         move(row, col);
  45.         addch(c);
  46.     }
  47. };
  48.  
  49. void initialize()
  50. {
  51.     //ncurse初始化
  52.     initscr();
  53.     //按键不需要输入回车直接交互
  54.     cbreak();
  55.     //按键不显示
  56.     noecho();
  57.     //隐藏光标
  58.     curs_set(0);
  59. }
  60. void shutdown()
  61. {
  62.     //ncurses清理
  63.     endwin();
  64. }
  65.  
  66. int main()
  67. {
  68.     initialize();//函数调用
  69.     Game game;
  70.     char ch='n';
  71.     do
  72.     {   
  73.         game.draw();//调用对象game的子函数绘制游戏界面   
  74.         ch = getch();
  75.     }while(ch != 'q' && ch != 'Q');//当输入的字符为q或Q时退出游戏界面
  76.  
  77.     shutdown();
  78.     return 0;
  79. }

运行结果为：

和step1.cpp相比较，step2.cpp创建了一个游戏类Game，将在屏幕指定位置上输出字符包装成了一个函数drawch()，并将其放在了游戏类Game中，这里我们还用到了预处理命令#define，其为宏定义命令，我们要画一个4*4的盘子，所以宏定义N代表格子数量4，我们设置各自中间的空格数为4个，也就是每次向后移动五个空格，在第五个空格输出字符‘|’，所以设置W代表格子的宽度5。然后利用for循环和函数drawch()编写一个函数draw()，来绘制游戏界面盘子。

操作界面进一步的完善

我们观察上图，绘制出来的游戏界面，发现贴着右边，不是很美观，我们宏定义M来控制盘子向右移动的距离，我们来看一下修改后的代码：

  1. //step2.cpp
  2. #include<iostream>
  3. #include<curses.h>
  4. using namespace std;
  5.  
  6. #define N 4 //格子数量
  7. #define W 5 //格子的宽度
  8. #define M 18 //盘子向右移动的距离
  9.  
  10. class Game
  11. {
  12. public:
  13.     Game(){} //构造函数
  14.     //绘制游戏界面
  15.     void draw()
  16.     {        
  17.         //清理屏幕
  18.         clear();
  19.         //居中偏移
  20.         for(int i = 0; i<=N; ++i)
  21.         {     
  22.             for(int j = 0; j<=N ;++j)
  23.             {
  24.                 //绘制相交点
  25.                 drawch(i*2, j*W + M, '+');
  26.                 
  27.                 //绘制竖线
  28.                 if(i != N)
  29.                 {
  30.                     drawch(i*2+1, j*W + M, '|');
  31.                 }
  32.  
  33.                 //绘制横线
  34.                 for(int k=0; j != N && k<N; ++k)
  35.                 {
  36.                     drawch(i*2, 1 + j*W + M + k,'-');
  37.                 }  
  38.             }
  39.         }
  40.     }
  41. private:
  42.     // 在指定的位置画一个字符
  43.     void drawch(int row, int col, char c)
  44.     {
  45.         move(row, col);
  46.         addch(c);
  47.     }
  48. };
  49.  
  50. void initialize()
  51. {
  52.     //ncurse初始化
  53.     initscr();
  54.     //按键不需要输入回车直接交互
  55.     cbreak();
  56.     //按键不显示
  57.     noecho();
  58.     //隐藏光标
  59.     curs_set(0);
  60. }
  61. void shutdown()
  62. {
  63.     //ncurses清理
  64.     endwin();
  65. }
  66.  
  67. int main()
  68. {
  69.     initialize();//函数调用
  70.     Game game;
  71.     char ch='n';
  72.     do
  73.     {   
  74.         game.draw();//调用对象game的子函数绘制游戏界面   
  75.         ch = getch();
  76.     }while(ch != 'q' && ch != 'Q');//当输入的字符为q或Q时退出游戏界面
  77.  
  78.     shutdown();
  79.     return 0;
  80. }

运行结果为：

这样看起来就舒服多了，接着我们要在屏幕合适位置显示一些提示信息，也就是，告诉玩家要怎么玩这个游戏，我们设置键盘上的W为向上合并数字，A为向左合并数字，S为向下合并数字，D为向右合并数字，Q为退出游戏，R为重新开始。这是我们就要用库函数<curses.h>中的函数mvpintw()，我们在游戏类Game的函数draw()中增加一行代码就可以了，增加的代码如下所示：

mvprintw(2 * (N + 1), 2 * N, "W(UP),S(DOWN),A(LEFT),D(RIGHT),R(RESTART),Q(QUIT)");

 我们看一下效果：

我们要对玩家按键要做出反应，所以我们要将主函数进行修改一下，我们先看看之前的主函数：

  1. int main()
  2. {
  3.     initialize();//函数调用
  4.     Game game;
  5.     char ch='n';
  6.     do
  7.     {   
  8.         game.draw();//调用对象game的子函数绘制游戏界面   
  9.         ch = getch();
  10.     }while(ch != 'q' && ch != 'Q');//当输入的字符为q或Q时退出游戏界面
  11.  
  12.     shutdown();
  13.     return 0;
  14. }

我们要对变量ch的处理写成类Game中的函数，对变量ch的处理的函数命名为processInput()，我们再增加一个Game类的成员变量status来控制游戏的状态，用函数getStatus()，返回status的值，我们宏定义S_FAIL表示失败、S_WIN表示胜利、S_NORMAL表示游戏正常进行、S_QUIT表示退出游戏。对其设置相应的值。 代码如下所示：

  1. #include<iostream>
  2. #include<curses.h>
  3. using namespace std;
  4.  
  5. #define N 4  //格子数量
  6. #define W 5  //格子的宽度
  7. #define M 18 //盘子向右移动的距离 居中偏移量
  8. //游戏状态
  9. #define S_WIN    0 //胜利
  10. #define S_FAIL   1 //失败
  11. #define S_NORMAL 2 //游戏正常进行
  12. #define S_QUIT   3 //退出
  13.  
  14. class Game
  15. {
  16. public:
  17.     Game():status(S_NORMAL) {}
  18.     //返回status的值
  19.     int getStatus()
  20.     {
  21.         return status;
  22.     }
  23.     
  24.     //处理按键
  25.     void processInput()
  26.     {
  27.         char ch = getch();
  28.         //将字母转化为大写
  29.         if(ch >= 'a' && ch <= 'z')
  30.         {
  31.             ch -= 32;
  32.         }
  33.         if(ch == 'Q')
  34.         {
  35.             status = S_QUIT;
  36.         }
  37.         else
  38.         {
  39.             //目前先不做处理,只在输赢提示语中转换
  40.             status = (status+1) % 2;
  41.         }
  42.     }
  43.     //绘制游戏界面
  44.     void draw()
  45.     {        
  46.         //清理屏幕
  47.         clear();
  48.         for(int i = 0; i<=N; ++i)
  49.         {     
  50.             for(int j = 0; j<=N ;++j)
  51.             {
  52.                 //绘制相交点
  53.                 drawch(i*2, j*W + M, '+');
  54.                 
  55.                 //绘制竖线
  56.                 if(i != N)
  57.                 {
  58.                     drawch(i*2+1, j*W + M, '|');
  59.                 }
  60.  
  61.                 //绘制横线
  62.                 for(int k=0; j != N && k<N; ++k)
  63.                 {
  64.                     drawch(i*2, 1 + j*W + M + k,'-');
  65.                 }  
  66.             }
  67.         }
  68.         mvprintw( 2*(N + 1), 2*N,"W(UP),S(DOWN),A(LEFT),D(RIGHT),R(RESTART),Q(QUIT)");
  69.         if(status == S_WIN)
  70.         {
  71.             mvprintw(2*(N + 2), 4*N,"YOU WIN, PRESS R TO CONTINUE");
  72.         }
  73.         else if(status == S_FAIL)
  74.         {
  75.             mvprintw(2*(N + 2), 4*N,"YOU LOSE, PRESS R TO CONTINUE");
  76.         }
  77.     }
  78. private:
  79.     void drawch(int row, int col, char c)
  80.     {
  81.         move(row, col);
  82.         addch(c);
  83.     }
  84.     //游戏中的数字是右对齐，row,col是数字最后一位所在的位置
  85.     void drawNum(int row, int col, int num)
  86.     {
  87.         while(num>0)
  88.         {
  89.             drawch(row, col, num%10+'0');
  90.             num /= 10;
  91.             --col;
  92.         }
  93.     }
  94. private:
  95.     int status;
  96. };
  97. void initialize()
  98. {
  99.     //ncurse初始化
  100.     initscr();
  101.     //按键不需要输入回车直接交互
  102.     cbreak();
  103.     //按键不显示
  104.     noecho();
  105.     //隐藏光标
  106.     curs_set(0);
  107. }
  108. void shutdown()
  109. {
  110.     //ncurses清理
  111.     endwin();
  112. }
  113.  
  114. int main()
  115. {
  116.     initialize();
  117.     Game game;
  118.     do
  119.     {   
  120.         game.draw();
  121.         game.processInput();
  122.     }while(game.getStatus() != S_QUIT);
  123.  
  124.     shutdown();
  125.     return 0;
  126. }
  127.

运行结果如下所示：

游戏的实现

数字在盘子中的位置

现在我们使数字在盘子中正确的位置出现，对于要显示的数字，我们利用函数drawch();和while循环将数字按位的显示出来，大部分的人以前应该写过这样的一道题，将输入的数字123，倒序输出来，321。这种题很简单，我们将数字123倒序每位数转化为字符型输出出来，我们来看一下实现代码：

  1. #include<stdio.h>
  2.  
  3. int main()
  4. {
  5. 	int num=123;
  6. 	char c; 
  7. 	while(num!=0)
  8. 	{
  9. 		c=num%10 + '0';
  10. 		num/=10;
  11. 		printf("%c",c);
  12. 	}
  13. 	return 0;
  14.  }

运行结果为：

这个代码我就不细细讲解了，稍微有点基础的人一下就能明白。

我们可以利用例题的解题思路，将数字显示在盘子中指定的位置，我们利用函数drawch();和for循环将数字化成字符显示在指定的位置，我们先创建一个函数setTestData()，这个函数是为了方便程序调制，随时设置数据。代码如下：

  1. //为了方便程序调制，随时设置数据
  2. //数组data定义在类中以声明
  3. void setTestData()
  4. {
  5.     for(int i = 0; i < N; ++i)
  6.     {
  7.         for(int j = 0; j < N; ++j)
  8.         {
  9.             //设置交点值
  10.             num[i][j] = 16<<i<<j;//左移一位相当于乘2,数组定义为类的私有成员函数
  11.         }
  12.     }
  13. }

数组设置好以后，我们将数组的元素显示在屏幕的盘子中，我们先看一下盘子：

数字显示，我们设置为右对齐，也就是如图中红色数字显示的那样，我们可以看出，数字是在符号 ‘ | ’ 的左边显示的，我们可以将从左往右数第二个符号 ‘ | ’ 的坐标的空格数减一，就可以得到数字个位数的坐标了，再减一就可以得到十位数的坐标了，以此类推就可以得到每位数字的坐标了，我们设置函数drawNum()对数字每一位求余并转化为字符，然后一位一位的画出来，我们来看一下实现代码：

  1. #include<iostream>
  2. #include<curses.h>
  3. using namespace std;
  4.  
  5. #define N 4  //格子数量
  6. #define W 5  //格子的宽度
  7. #define M 18 //盘子向右移动的距离
  8. //游戏状态
  9. #define S_WIN    0 //胜利
  10. #define S_FAIL   1 //失败
  11. #define S_NORMAL 2 //游戏正常进行
  12. #define S_QUIT   3 //退出
  13.  
  14. class Game
  15. {
  16. public:
  17.     Game():status(S_NORMAL) { setTestData(); }//数组初始化
  18.     //返回status的值
  19.     int getStatus()
  20.     {
  21.         return status;
  22.     }
  23.     
  24.     //处理按键
  25.     void processInput()
  26.     {
  27.         char ch = getch();
  28.         //将字母转化为大写
  29.         if(ch >= 'a' && ch <= 'z')
  30.         {
  31.             ch -= 32;
  32.         }
  33.         if(ch == 'Q')
  34.         {
  35.             status = S_QUIT;
  36.         }
  37.         else
  38.         {
  39.             //目前先不做处理,只在输赢提示语中转换
  40.             status = (status+1) % 2;
  41.         }
  42.     }
  43.     //绘制游戏界面
  44.     void draw()
  45.     {        
  46.         //清理屏幕
  47.         clear();
  48.         for(int i = 0; i<=N; ++i)
  49.         {     
  50.             for(int j = 0; j<=N ;++j)
  51.             {
  52.                 //绘制相交点
  53.                 drawch(i*2, j*W + M, '+');
  54.                 
  55.                 //绘制竖线
  56.                 if(i != N)
  57.                 {
  58.                     drawch(i*2+1, j*W + M, '|');
  59.                 }
  60. 				
  61.                 //每个格子中的数字
  62.                 if(i!=N && j!=N)
  63.                 {
  64.                     drawNum(i*2+1, (j+1)*W - 1 + M, num[i][j]);
  65.                 }
  66. 				
  67.                 //绘制横线
  68.                 for(int k=0; j != N && k<N; ++k)
  69.                 {
  70.                     drawch(i*2, 1 + j*W + M + k,'-');
  71.                 }  
  72.             }
  73.         }
  74.         mvprintw( 2*(N + 1), 2*N,"W(UP),S(DOWN),A(LEFT),D(RIGHT),R(RESTART),Q(QUIT)");
  75.         if(status == S_WIN)
  76.         {
  77.             mvprintw(2*(N + 2), 4*N,"YOU WIN, PRESS R TO CONTINUE");
  78.         }
  79.         else if(status == S_FAIL)
  80.         {
  81.             mvprintw(2*(N + 2), 4*N,"YOU LOSE, PRESS R TO CONTINUE");
  82.         }
  83.     }
  84. private:
  85.     //初始化数组
  86.     void setTestData()
  87.     {
  88.         for(int i = 0; i < N; ++i)
  89.         {
  90.             for(int j = 0; j<N; ++j)
  91.             {
  92.                 num[i][j] = 8<<i<<i<<j;//左移一位也就是将数字乘2，移动N位，乘以2的N次方
  93.             }
  94.         }
  95.     }
  96.     void drawch(int row, int col, char c)
  97.     {
  98.         move(row, col);
  99.         addch(c);
  100.     }
  101.     //游戏中的数字是右对齐，row,col是数字最后一位所在的位置
  102.     void drawNum(int row, int col, int num)
  103.     {
  104.         while(num>0)
  105.         {
  106.             drawch(row, col, num%10+'0');
  107.             num /= 10;
  108.             --col;
  109.         }
  110.     }
  111. private:
  112.     int status;
  113.     int num[N][N];
  114. };
  115. void initialize()
  116. {
  117.     //ncurse初始化
  118.     initscr();
  119.     //按键不需要输入回车直接交互
  120.     cbreak();
  121.     //按键不显示
  122.     noecho();
  123.     //隐藏光标
  124.     curs_set(0);
  125. }
  126. void shutdown()
  127. {
  128.     //ncurses清理
  129.     endwin();
  130. }
  131.  
  132. int main()
  133. {
  134.     initialize();
  135.     Game game;
  136.     do
  137.     {   
  138.         game.draw();
  139.         game.processInput();
  140.     }while(game.getStatus() != S_QUIT);
  141.  
  142.     shutdown();
  143.     return 0;
  144. }
  145.

运行结果如图所示：

重新初始化游戏

我们每次玩2048游戏时，开始的时候我们会发现，每次开始都是在盘子不同的位置出现两个数字2或者4，出现的位置是随机的，我们将每次重新开始调用的函数命名为restart()，我们来看一下实现的代码：

  1. // 重新开始
  2. void restart()
  3. {
  4. 	for (int i = 0; i < N; ++i)
  5. 	{
  6. 		for (int j = 0; j < N; ++j)
  7. 		{
  8. 			num[i][j] = 0;//将数组元素全部初始化为0
  9. 		}
  10. 	}
  11. 	randNew();
  12. 	randNew();//随机产生一个数字
  13. 	status = S_NORMAL;
  14. }

首先我们将数组元素全部初始化为0，然后我们调用函数randNew()，在随机空位置产生一个数字，调用这个函数两次就可以在不同的两个位置随机产生数字2或者4，函数randNew()的返回值类型为bool型，我们来看randNew()函数的代码：

  1. // 随机产生一个新的数字
  2. bool randNew()
  3. {
  4. 	vector<int> emptyPos;
  5. 	// 把空位置先存起来
  6. 	for (int i = 0; i < N; ++i)
  7. 	{
  8. 		for (int j = 0; j < N; ++j)
  9. 		{
  10. 			if (num[i][j] == 0)
  11. 			{
  12. 				emptyPos.push_back(i * N + j);//将数组中数值为0的元素的坐标保存到emptyPos中
  13. 			}
  14. 		}
  15. 	}
  16. 	if (emptyPos.size() == 0) 
  17.         {
  18. 		return false;
  19. 	}
  20. 	// 随机找个空位置
  21. 	int value = emptyPos[rand() % emptyPos.size()];
  22. 	// 10%的概率产生4
  23. 	num[value / N][value % N] = rand() % 10 == 1 ? 4 : 2;
  24. 	return true;
  25. }

这里创建一个vector对象emptyPos，用其保存数组中值为0的元素的坐标，然后判断一下emptyPos长度是否为空，如果是空的，说明数组中没有值为0的元素了，也就是，盘子中没有空位置了，返回false，代表游戏结束了，如果盘子中没有数字达到2048，说明你失败了，否则你胜利了，当然这是后面考虑的。如果盘子中还有空位置，这时我们就需要使用库函数<cstdlib>中，产生随机数的函数srand()和rand()，将这两个函数结合时间一起使用，不同的时间产生的随机数也是不一样的，我们将srand()函数放在我们自己创建的函数initialize()中，根据每次程序初始化的时间来随机产生数字。rand() % emptyPos.size() 的意思就是在vector对象emptyPos的所有元素中随机选取一个元素，在这里我们声明一个变量value来保存随机在vector对象emptyPos选择的元素，然后根据这个元素计算出这个元素在数组num中所代表的位置，由于value是int型变量，所以value/N得出来的是数组所在行，value%N得出来是数组所在列，具体是怎么实现的，我们看下图操作步骤：

我们得出盘子中的空位置之后，rand() % 10 == 1 ? 4 : 2;中的rand() % 10会随机产生整数0~9任意一个数，如果该数为1，则在盘子的空位置出生成数字4，否则是数字2，这样就达到了项目的要求在盘子空位置出现数字4的概率为10%，然后返回true。我们来看一下完整的代码：

  1. #include<iostream>
  2. #include<curses.h>
  3. #include<vector>
  4. #include<cstdlib>
  5. #include<ctime>
  6. using namespace std;
  7.  
  8. #define N 4  //格子数量
  9. #define W 5  //格子的宽度
  10. #define M 18 //盘子向右移动的距离
  11. //游戏状态
  12. #define S_WIN    0 //胜利
  13. #define S_FAIL   1 //失败
  14. #define S_NORMAL 2 //游戏正常进行
  15. #define S_QUIT   3 //退出
  16.  
  17. class Game
  18. {
  19. public:
  20.     Game():status(S_NORMAL) { setTestData(); }//数组初始化
  21.     //返回status的值
  22.     int getStatus()
  23.     {
  24.         return status;
  25.     }
  26.     //处理按键
  27.     void processInput()
  28.     {
  29.         char ch = getch();
  30.         //将字母转化为大写
  31.         if(ch >= 'a' && ch <= 'z')
  32.         {
  33.             ch -= 32;
  34.         }
  35.         if(ch == 'Q')//退出游戏
  36.         {
  37.             status = S_QUIT;
  38.         }
  39. 		else if (ch == 'R') //重新开始 
  40. 		{
  41.             restart();
  42.         }
  43.         else
  44.         {
  45.             //目前先不做处理,只在输赢提示语中转换
  46.             status = (status+1) % 2;
  47.         }
  48.     }
  49.     //绘制游戏界面
  50.     void draw()
  51.     {        
  52.         //清理屏幕
  53.         clear();
  54.         for(int i = 0; i<=N; ++i)
  55.         {     
  56.             for(int j = 0; j<=N ;++j)
  57.             {
  58.                 //绘制相交点
  59.                 drawch(i*2, j*W + M, '+');
  60.                 
  61.                 //绘制竖线
  62.                 if(i != N)
  63.                 {
  64.                     drawch(i*2+1, j*W + M, '|');
  65.                 }
  66. 				
  67.                 //每个格子中的数字
  68.                 if(i!=N && j!=N)
  69.                 {
  70.                     drawNum(i*2+1, (j+1)*W - 1 + M, num[i][j]);
  71.                 }
  72. 				
  73.                 //绘制横线
  74.                 for(int k=0; j != N && k<N; ++k)
  75.                 {
  76.                     drawch(i*2, 1 + j*W + M + k,'-');
  77.                 }  
  78.             }
  79.         }
  80.         mvprintw( 2*(N + 1), 2*N,"W(UP),S(DOWN),A(LEFT),D(RIGHT),R(RESTART),Q(QUIT)");
  81.         if(status == S_WIN)
  82.         {
  83.             mvprintw(2*(N + 2), 4*N,"YOU WIN, PRESS R TO CONTINUE");
  84.         }
  85.         else if(status == S_FAIL)
  86.         {
  87.             mvprintw(2*(N + 2), 4*N,"YOU LOSE, PRESS R TO CONTINUE");
  88.         }
  89.     }
  90. private:
  91.     // 重新开始
  92.     void restart() 
  93. 	{
  94.         for (int i = 0; i < N; ++i) 
  95. 		{
  96.             for (int j = 0; j < N; ++j) 
  97. 			{
  98.                 num[i][j] = 0;//将数组元素全部初始化为0
  99.             }
  100.         }
  101.         randNew();//随机产生一个数字
  102.         randNew();
  103.         status = S_NORMAL;
  104.     }
  105.     // 随机产生一个新的数字
  106.     bool randNew() 
  107. 	{
  108.         vector<int> emptyPos;
  109.         // 把空位置先存起来
  110.         for (int i = 0; i < N; ++i) 
  111. 		{
  112.             for (int j = 0; j < N; ++j) 
  113. 			{
  114.                 if (num[i][j] == 0) {
  115.                     emptyPos.push_back(i * N + j);//将数组中数值为0的元素的坐标保存到emptyPos中
  116.                 }
  117.             }
  118.         }
  119.         if (emptyPos.size() == 0) 
  120. 		{
  121.             return false;
  122.         }
  123.  
  124.         // 随机找个空位置
  125.         int value = emptyPos[rand() % emptyPos.size()];
  126.         // 10%的概率产生4
  127.         num[value / N][value % N] = rand() % 10 == 1 ? 4 : 2;
  128.         return true;
  129.     }
  130.     //初始化数组
  131.     void setTestData()
  132.     {
  133.         for(int i = 0; i < N; ++i)
  134.         {
  135.             for(int j = 0; j<N; ++j)
  136.             {
  137.                 num[i][j] = 8<<i<<i<<j;//左移一位也就是将数字乘2，移动N位，乘以2的N次方
  138.             }
  139.         }
  140.     }
  141.     void drawch(int row, int col, char c)
  142.     {
  143.         move(row, col);
  144.         addch(c);
  145.     }
  146.     //游戏中的数字是右对齐，row,col是数字最后一位所在的位置
  147.     void drawNum(int row, int col, int num)
  148.     {
  149.         while(num>0)
  150.         {
  151.             drawch(row, col, num%10+'0');
  152.             num /= 10;
  153.             --col;
  154.         }
  155.     }
  156. private:
  157.     int status;
  158.     int num[N][N];
  159. };
  160. void initialize()
  161. {
  162.     //ncurse初始化
  163.     initscr();
  164.     //按键不需要输入回车直接交互
  165.     cbreak();
  166.     //按键不显示
  167.     noecho();
  168.     //隐藏光标
  169.     curs_set(0);
  170.     // 随机数
  171.     srand(time(NULL));
  172. }
  173. void shutdown()
  174. {
  175.     //ncurses清理
  176.     endwin();
  177. }
  178.  
  179. int main()
  180. {
  181.     initialize();
  182.     Game game;
  183.     do
  184.     {   
  185.         game.draw();
  186.         game.processInput();
  187.     }while(game.getStatus() != S_QUIT);
  188.  
  189.     shutdown();
  190.     return 0;
  191. }
  192.

运行结果如下所示：（第一张为初始界面，第二张为按R键后的界面，盘子中随机两个位置产生数字）

实现向左移动合并数字

完成了这些功能之后，我们接下来完成向左移动合并数字，我们先回忆一下项目要求：

1. 通过上下左右来控制合并盘子里的数字。

2. 每次合并只能合并相邻的两个数字，例如 [2 2 2 2] ，向右合并以后是 [空 空 4 4] ，不是 [空 空 空 8]。

3. 每次合并的时候，合并那个方向的数字优先级高，例如 [空 2 2 2]，向右合并以后是 [空 空 2 4]，不是 [空 空 4 2]。

4. 每次移动之后会在空的位置中随机产生一个数字2或者4。

我们设置键盘上的W为向上合并数字，A为向左合并数字，S为向下合并数字，D为向右合并数字，Q为退出游戏，R为重新开始。当玩家按下A时，盘子中的数字会左移，并且合并相邻且相同的数字，当玩家按下D时，盘子中的数字会右移，并且合并相邻且相同的数字，当玩家按下W时，盘子中的数字会上移，并且合并相邻且相同的数字，当玩家按下S时，盘子中的数字会下移，并且合并相邻且相同的数字。

我们完善一下处理按键的函数processInput()：

  1. //处理按键 
  2. void processInput()
  3.     {
  4.         char ch = getch();
  5.         //将字母转化为大写
  6.         if(ch >= 'a' && ch <= 'z')
  7.         {
  8.             ch -= 32;
  9.         }
  10.         if(status == S_NORMAL)//如果游戏正常进行
  11.         {
  12.             bool updated = false;//用来判断盘子中的数是否移动了或者合并了
  13.             if(ch == 'A')
  14.             {
  15.                 //向左移动
  16.                 updated = moveLeft();//如果盘子中的数发生了变化，会返回true,否则返回false
  17.             }
  18.             else if(ch == 'D')
  19.             {
  20.                 //向右移动
  21.             }
  22.             else if(ch =='W')
  23.             {
  24.                 //向上移动
  25.             }
  26.             else if(ch == 'S')
  27.             {
  28.                 //向下移动
  29.             }
  30.             if(updated)//如果盘子中的数发生了变化，就在所有的空位置中，随机产生一个数字
  31.             {
  32.                 randNew();//在盘子中的空位置中的随机一个位置产生一个新数
  33.             }
  34.         }
  35.         if(ch == 'Q')//判断是否退出游戏
  36.         {
  37.             status = S_QUIT;
  38.         }
  39. 		else if (ch == 'R')//判断是否重新开始游戏
  40. 		{
  41.             restart();
  42.         }
  43.     }

向左移动的函数为moveLeft()，该函数返回值为bool类型，如果盘子中的数据发生了变化就返回true，否则就返回false，如果盘子中的数据没有发生变化，就不在盘子中随机产生新数，如果发生了变化就在盘子中的空位置中，随机一个空位置产生一个新数2或者4。我们来看一下代码：

  1. #include<iostream>
  2. #include<curses.h>
  3. #include<vector>
  4. #include<cstdlib>
  5. #include<ctime>
  6. using namespace std;
  7.  
  8. #define N 4  //格子数量
  9. #define W 5  //格子的宽度
  10. #define M 18 //盘子向右移动的距离
  11. //游戏状态
  12. #define S_WIN    0 //胜利
  13. #define S_FAIL   1 //失败
  14. #define S_NORMAL 2 //游戏正常进行
  15. #define S_QUIT   3 //退出
  16. //胜利条件
  17. #define TARGET 2048
  18. class Game
  19. {
  20. public:
  21.     Game():status(S_NORMAL) { setTestData(); }//数组初始化
  22.     //返回status的值
  23.     int getStatus()
  24.     {
  25.         return status;
  26.     }
  27.     //处理按键
  28.     void processInput()
  29.     {
  30.         char ch = getch();
  31.         //将字母转化为大写
  32.         if(ch >= 'a' && ch <= 'z')
  33.         {
  34.             ch -= 32;
  35.         }
  36.         if(status == S_NORMAL)//如果游戏正常进行
  37.         {
  38.             bool updated = false;//用来判断盘子中的数是否移动了或者合并了
  39.             if(ch == 'A')
  40.             {
  41.                 //向左移动
  42.                 updated = moveLeft();//如果盘子中的数发生了变化，会返回true,否则返回false
  43.             }
  44.             else if(ch == 'D')
  45.             {
  46.                 //向右移动
  47.             }
  48.             else if(ch =='W')
  49.             {
  50.                 //向上移动
  51.             }
  52.             else if(ch == 'S')
  53.             {
  54.                 //向下移动
  55.             }
  56.             if(updated)//如果盘子中的数发生了变化，就在所有的空位置中，随机产生一个数字
  57.             {
  58.                 randNew();//在盘子中的空位置中的随机一个位置产生一个新数
  59.             }
  60.         }
  61.         if(ch == 'Q')//判断是否退出游戏
  62.         {
  63.             status = S_QUIT;
  64.         }
  65. 		else if (ch == 'R')//判断是否重新开始游戏
  66. 		{
  67.             restart();
  68.         }
  69.     }
  70.     //绘制游戏界面
  71.     void draw()
  72.     {        
  73.         //清理屏幕
  74.         clear();
  75.         //居中偏移
  76.         //const int offs`et = 18;
  77.         for(int i = 0; i<=N; ++i)
  78.         {     
  79.             for(int j = 0; j<=N ;++j)
  80.             {
  81.                 //绘制相交点
  82.                 drawch(i*2, j*W + M, '+');
  83.                 
  84.                 //绘制竖线
  85.                 if(i != N)
  86.                 {
  87.                     drawch(i*2+1, j*W + M, '|');
  88.                 }
  89. 				
  90.                 //每个格子中的数字
  91.                 if(i!=N && j!=N)
  92.                 {
  93.                     drawNum(i*2+1, (j+1)*W - 1 + M, num[i][j]);
  94.                 }
  95. 				
  96.                 //绘制横线
  97.                 for(int k=0; j != N && k<N; ++k)
  98.                 {
  99.                     drawch(i*2, 1 + j*W + M + k,'-');
  100.                 }  
  101.             }
  102.         }
  103.         mvprintw( 2*(N + 1), 2*N,"W(UP),S(DOWN),A(LEFT),D(RIGHT),R(RESTART),Q(QUIT)");
  104.         if(status == S_WIN)
  105.         {
  106.             mvprintw(2*(N + 2), 4*N,"YOU WIN, PRESS R TO CONTINUE");
  107.         }
  108.         else if(status == S_FAIL)
  109.         {
  110.             mvprintw(2*(N + 2), 4*N,"YOU LOSE, PRESS R TO CONTINUE");
  111.         }
  112.     }
  113. private:
  114.     //向左移动
  115.     bool moveLeft()
  116.     {
  117.         int tmp[N][N];//保存移动之前的数组的值
  118.         for(int i=0; i< N; ++i)
  119.         {
  120.             //逐行处理数据 
  121.             int currentWritePos = 0;//记录合并数字的前一个数字的位置
  122.             int lastValue = 0;//记录合并数字的前一个数字的值
  123.             for(int j=0; j<N;++j)
  124.             {
  125.                 tmp[i][j] = num[i][j];
  126.                 if(num[i][j] == 0)
  127.                 {
  128.                     continue;//如果值为0，跳过此次循环，不执行下列操作，不为0，继续下列操作
  129.                 }
  130.                 if(lastValue == 0)
  131.                 {
  132.                     lastValue = num[i][j];//记录相同两个数合并时的前一个数字的值
  133.                 }
  134.                 else
  135.                 {
  136.                     if(lastValue == num[i][j])
  137.                         //如果lastValue的值与下一个不为0的值相同
  138.                     {
  139.                         num[i][currentWritePos] = lastValue*2;//这两个数的值相加
  140.                         lastValue = 0;//lastValue的值清空
  141.                         if(num[i][currentWritePos] == TARGET)//判断合并后的数字是否是2048，也就是判断是否胜利
  142.                         {
  143.                             status = S_WIN;
  144.                         }
  145.                     }
  146.                         //如果lastValue的值与下一个不为0的值相同
  147.                     else//如果lastValue的值与下一个不为0的值不相同
  148.                     {
  149.                         num[i][currentWritePos] = lastValue;//将lastValue对应的盘子中的数字向前移动
  150.                         lastValue = num[i][j];//lastValue的值更新为下一个不为0的值
  151.                     }
  152.                     ++currentWritePos;//执行到这一步说明num[i][currentWritePos]对应的盘子中的位置已有数值，所以currentWritePos的值加一，对应的盘子中的位置向右移动一位
  153.                 }
  154.                 num[i][j] = 0;//原本的值，要么向前移动了，要么和前面不为0的值合并了，所以要将此处的值赋值为0
  155.             }
  156.             if(lastValue != 0)//本行已经遍历到最后一个位置了，如果lastValue的值不为0，本行的后面没有值可以和lastValue合并了,所以将其赋值给currentWritePos对应的位置
  157.             {
  158.                 num[i][currentWritePos] = lastValue;
  159.             }
  160.         }
  161.         //判断数组的数据是否发生了变化，如果发生了变化，说明此次操作引起了数组的数据发生了移动或者合并，然后盘子中会产生新的数字，反之，说明盘子中的数没有移动，也没有合并，也就是此次操作没有引起变化，盘子中就不能随机生成新的数
  162.         for(int i = 0; i < N;++i)
  163.         {
  164.             for(int j = 0; j < N;++j)
  165.             {
  166.                 if(num[i][j] != tmp[i][j])
  167.                 {
  168.                     return true;
  169.                 }
  170.             }
  171.         }
  172.         return false;
  173.     }
  174.     // 重新开始
  175.     void restart() 
  176.     {
  177.         for (int i = 0; i < N; ++i) 
  178.         {
  179.             for (int j = 0; j < N; ++j) 
  180.             {
  181.                 num[i][j] = 0;//将数组元素初始化为0
  182.             }
  183.         }
  184.         randNew();//随机产生一个数字
  185.         randNew();
  186.         status = S_NORMAL;
  187.     }
  188.     // 随机产生一个新的数字
  189.     bool randNew() 
  190.     {
  191.         vector<int> emptyPos;
  192.         // 把空位置先存起来
  193.         for (int i = 0; i < N; ++i) 
  194.         {
  195.             for (int j = 0; j < N; ++j) 
  196.             {
  197.                 if (num[i][j] == 0) 
  198.                 {
  199.                     emptyPos.push_back(i * N + j);
  200.                 }
  201.             }
  202.         }
  203.         if (emptyPos.size() == 0) 
  204.         {
  205.             return false;
  206.         }
  207.         // 随机找个空位置
  208.         int value = emptyPos[rand() % emptyPos.size()];
  209.         // 10%的概率产生4
  210.         num[value / N][value % N] = rand() % 10 == 1 ? 4 : 2;
  211.         return true;
  212.     }
  213.     //初始化数组
  214.     void setTestData()
  215.     {
  216.         for(int i = 0; i < N; ++i)
  217.         {
  218.             for(int j = 0; j<N; ++j)
  219.             {
  220.                 num[i][j] = 8<<i<<i<<j;//左移一位也就是将数字乘2，移动N位，乘以2的N次方
  221.             }
  222.         }
  223.     }
  224.     void drawch(int row, int col, char c)
  225.     {
  226.         move(row, col);
  227.         addch(c);
  228.     }
  229.     //游戏中的数字是右对齐，row,col是数字最后一位所在的位置
  230.     void drawNum(int row, int col, int num)
  231.     {
  232.         while(num>0)
  233.         {
  234.             drawch(row, col, num%10+'0');
  235.             num /= 10;
  236.             --col;
  237.         }
  238.     }
  239. private:
  240.     int status;
  241.     int num[N][N];
  242. };
  243. void initialize()
  244. {
  245.     //ncurse初始化
  246.     initscr();
  247.     //按键不需要输入回车直接交互
  248.     cbreak();
  249.     //按键不显示
  250.     noecho();
  251.     //隐藏光标
  252.     curs_set(0);
  253.     // 随机数
  254.     srand(time(NULL));
  255. }
  256. void shutdown()
  257. {
  258.     //ncurses清理
  259.     endwin();
  260. }
  261.  
  262. int main()
  263. {
  264.     initialize();
  265.     Game game;
  266.     do
  267.     {   
  268.         game.draw();
  269.         game.processInput();
  270.     }while(game.getStatus() != S_QUIT);
  271.  
  272.     shutdown();
  273.     return 0;
  274. }
  275.

实现向其它方向的移动并合并数字

假如我们有下图所示的第一个盘子的数据，我们现在要将其向上移动合并数字，利用数学思维，我们将其逆时针旋转90°之后，向左移，再逆时针旋转270°，这样我们就实现了向上移动合并数字；向右移动，我们就我们将其逆时针旋转180°之后，向左移，再逆时针旋转180°，这样就是实现了向右移；向下移动，我们就我们将其逆时针旋转270°之后，向左移，再逆时针旋转90°，这样就实现了向下移动。这样处理代码是实现起来就很简洁了，而且很巧妙。

我们来看一下实现逆时针旋转90°的代码：

  1.     //数组逆时针旋转90度
  2.     void rotate()
  3.     {
  4.         int tmp[N][N] = {0};
  5.         for(int i = 0;i<N;++i)
  6.         {
  7.             for(int j = 0; j<N;++j)
  8.             {
  9.                 tmp[i][j] = num[N-1-i];
  10.             }
  11.         }
  12.         for(int i = 0;i<N;++i)
  13.         {
  14.             for(int j = 0; j<N;++j)
  15.             {
  16.                 num[i][j] = tmp[i][j];
  17.             }
  18.         }
  19.     }

我们还要增加一个函数isOver()判断盘子中如果还有空位，相邻元素之间还能合并，则返回true，否则返回false。代码如下所示：

  1.     //判断游戏是否结束
  2.     bool isOver()
  3.     {
  4.         for(int i = 0;i<N;++i)
  5.         {
  6.             for(int j = 0; j<N;++j)
  7.             {
  8.                 //有空位或相邻相同 两个有一个成立
  9.                 if((j+1<N)&&(num[i][j]*num[i][j+1] == 0 || num[i][j]==num[i][j+1])) 
  10.                 {
  11.                     return false;
  12.                 }
  13.                 if((i+1<N)&&(num[i][j]*num[i+1][j] == 0 || num[i][j] == num[i+1][j])) 
  14.                 {
  15.                     return false;
  16.                 }
  17.             }
  18.         }
  19.         return true;
  20.     }

我们看一下完善之后的处理按键的函数processInput()：

  1.     //处理按键
  2.     void processInput()
  3.     {
  4.         char ch = getch();
  5.         //将字母转化为大写
  6.         if(ch >= 'a' && ch <= 'z')
  7.         {
  8.             ch -= 32;
  9.         }
  10.         if(status == S_NORMAL)//如果游戏正常进行
  11.         {
  12.             bool updated = false;//用来判断盘子中的数是否移动了或者合并了
  13.             if(ch == 'A')
  14.             {
  15.                 //向左移动
  16.                 updated = moveLeft();//如果盘子中的数发生了变化，会返回true,否则返回false
  17.             }
  18.             else if(ch == 'D')
  19.             {
  20.                 //向右移动
  21.                 rotate();
  22.                 rotate();
  23.                 updated = moveLeft();
  24.                 rotate();
  25.                 rotate();
  26.             }
  27.             else if(ch =='W')
  28.             {
  29.                 //向上移动
  30.                 rotate();
  31.                 updated = moveLeft();
  32.                 rotate();
  33.                 rotate();
  34.                 rotate();
  35.             }
  36.             else if(ch == 'S')
  37.             {
  38.                 //向下移动
  39. 		rotate();
  40.                 rotate();
  41.                 rotate();
  42.                 updated = moveLeft();
  43.                 rotate();
  44.             }
  45.             if(updated)//如果盘子中的数发生了变化，就在所有的空位置中，随机产生一个数字
  46.             {
  47.                 randNew();//在盘子中的空位置中的随机一个位置产生一个新数
  48. 		if(isOver())//判断盘子中是否还有空位置，相邻元素之间是否还能合并
  49.                 {
  50.                     status = S_FAIL;
  51.                 }
  52.             }
  53.         }
  54.         if(ch == 'Q')//判断是否退出游戏
  55.         {
  56.             status = S_QUIT;
  57.         }
  58. 	else if (ch == 'R')//判断是否重新开始游戏
  59. 	{
  60.             restart();
  61.         }
  62.     }

 我们将新增的几个函数，加进去之后，我们的项目2048小游戏就圆满完成了。当然还能变得更加完美，结合数据库，保留每次的成绩，还有最高和最低成绩，等等，如果之后有时间在完善该功能。

项目完整代码

  1. #include<iostream>
  2. #include<curses.h>
  3. #include<vector>
  4. #include<cstdlib>
  5. #include<ctime>
  6. using namespace std;
  7.  
  8. #define N 4  //格子数量
  9. #define W 5  //格子的宽度
  10. #define M 18 //盘子向右移动的距离
  11. //游戏状态
  12. #define S_WIN    0 //胜利
  13. #define S_FAIL   1 //失败
  14. #define S_NORMAL 2 //游戏正常进行
  15. #define S_QUIT   3 //退出
  16. //胜利条件
  17. #define TARGET 2048
  18. class Game
  19. {
  20. public:
  21.     Game():status(S_NORMAL) { setTestData(); }//数组初始化
  22.     //返回status的值
  23.     int getStatus()
  24.     {
  25.         return status;
  26.     }
  27.     //处理按键
  28.     void processInput()
  29.     {
  30.         char ch = getch();
  31.         //将字母转化为大写
  32.         if(ch >= 'a' && ch <= 'z')
  33.         {
  34.             ch -= 32;
  35.         }
  36.         if(status == S_NORMAL)//如果游戏正常进行
  37.         {
  38.             bool updated = false;//用来判断盘子中的数是否移动了或者合并了
  39.             if(ch == 'A')
  40.             {
  41.                 //向左移动
  42.                 updated = moveLeft();//如果盘子中的数发生了变化，会返回true,否则返回false
  43.             }
  44.             else if(ch == 'D')
  45.             {
  46.                 //向右移动
  47.                 rotate();
  48.                 rotate();
  49.                 updated = moveLeft();
  50.                 rotate();
  51.                 rotate();
  52.             }
  53.             else if(ch =='W')
  54.             {
  55.                 //向上移动
  56.                 rotate();
  57.                 updated = moveLeft();
  58.                 rotate();
  59.                 rotate();
  60.                 rotate();
  61.             }
  62.             else if(ch == 'S')
  63.             {
  64.                 //向下移动
  65. 		rotate();
  66.                 rotate();
  67.                 rotate();
  68.                 updated = moveLeft();
  69.                 rotate();
  70.             }
  71.             if(updated)//如果盘子中的数发生了变化，就在所有的空位置中，随机产生一个数字
  72.             {
  73.                 randNew();//在盘子中的空位置中的随机一个位置产生一个新数
  74. 		if(isOver())//判断盘子中是否还有空位置，相邻元素之间是否还能合并
  75.                 {
  76.                     status = S_FAIL;
  77.                 }
  78.             }
  79.         }
  80.         if(ch == 'Q')//判断是否退出游戏
  81.         {
  82.             status = S_QUIT;
  83.         }
  84. 	else if (ch == 'R')//判断是否重新开始游戏
  85. 	{
  86.             restart();
  87.         }
  88.     }
  89.     //绘制游戏界面
  90.     void draw()
  91.     {        
  92.         //清理屏幕
  93.         clear();
  94.         //居中偏移
  95.         //const int offs`et = 18;
  96.         for(int i = 0; i<=N; ++i)
  97.         {     
  98.             for(int j = 0; j<=N ;++j)
  99.             {
  100.                 //绘制相交点
  101.                 drawch(i*2, j*W + M, '+');
  102.                 
  103.                 //绘制竖线
  104.                 if(i != N)
  105.                 {
  106.                     drawch(i*2+1, j*W + M, '|');
  107.                 }
  108. 				
  109.                 //每个格子中的数字
  110.                 if(i!=N && j!=N)
  111.                 {
  112.                     drawNum(i*2+1, (j+1)*W - 1 + M, num[i][j]);
  113.                 }
  114. 				
  115.                 //绘制横线
  116.                 for(int k=0; j != N && k<N; ++k)
  117.                 {
  118.                     drawch(i*2, 1 + j*W + M + k,'-');
  119.                 }  
  120.             }
  121.         }
  122.         mvprintw( 2*(N + 1), 2*N,"W(UP),S(DOWN),A(LEFT),D(RIGHT),R(RESTART),Q(QUIT)");
  123.         if(status == S_WIN)
  124.         {
  125.             mvprintw(2*(N + 2), 4*N,"YOU WIN, PRESS R TO CONTINUE");
  126.         }
  127.         else if(status == S_FAIL)
  128.         {
  129.             mvprintw(2*(N + 2), 4*N,"YOU LOSE, PRESS R TO CONTINUE");
  130.         }
  131.     }
  132. private:
  133.     //判断游戏是否结束
  134.     bool isOver()
  135.     {
  136.         for(int i = 0;i<N;++i)
  137.         {
  138.             for(int j = 0; j<N;++j)
  139.             {
  140.                 //有空位或相邻相同 两个有一个成立
  141.                 if((j+1<N)&&(num[i][j]*num[i][j+1] == 0 || num[i][j]==num[i][j+1])) 
  142.                 {
  143.                     return false;
  144.                 }
  145.                 if((i+1<N)&&(num[i][j]*num[i+1][j] == 0 || num[i][j] == num[i+1][j])) 
  146.                 {
  147.                     return false;
  148.                 }
  149.             }
  150.         }
  151.         return true;
  152.     }
  153.     //数组逆时针旋转90度
  154.     void rotate()
  155.     {
  156.         int tmp[N][N] = {0};
  157.         for(int i = 0;i<N;++i)
  158.         {
  159.             for(int j = 0; j<N;++j)
  160.             {
  161.                 tmp[i][j] = num[j][N-1-i];
  162.             }
  163.         }
  164.         for(int i = 0;i<N;++i)
  165.         {
  166.             for(int j = 0; j<N;++j)
  167.             {
  168.                 num[i][j] = tmp[i][j];
  169.             }
  170.         }
  171.     }
  172.     //向左移动
  173.     bool moveLeft()
  174.     {
  175.         int tmp[N][N];//保存移动之前的数组的值
  176.         for(int i=0; i< N; ++i)
  177.         {
  178.             //逐行处理数据 
  179.             int currentWritePos = 0;//记录合并数字的前一个数字的位置
  180.             int lastValue = 0;//记录合并数字的前一个数字的值
  181.             for(int j=0; j<N;++j)
  182.             {
  183.                 tmp[i][j] = num[i][j];
  184.                 if(num[i][j] == 0)
  185.                 {
  186.                     continue;//如果值为0，跳过此次循环，不执行下列操作，不为0，继续下列操作
  187.                 }
  188.                 if(lastValue == 0)
  189.                 {
  190.                     lastValue = num[i][j];//记录相同两个数合并时的前一个数字的值
  191.                 }
  192.                 else
  193.                 {
  194.                     if(lastValue == num[i][j])
  195.                         //如果lastValue的值与下一个不为0的值相同
  196.                     {
  197.                         num[i][currentWritePos] = lastValue*2;//这两个数的值相加
  198.                         lastValue = 0;//lastValue的值清空
  199.                         if(num[i][currentWritePos] == TARGET)//判断合并后的数字是否是2048，也就是判断是否胜利
  200.                         {
  201.                             status = S_WIN;
  202.                         }
  203.                     }
  204.                         //如果lastValue的值与下一个不为0的值相同
  205.                     else//如果lastValue的值与下一个不为0的值不相同
  206.                     {
  207.                         num[i][currentWritePos] = lastValue;//将lastValue对应的盘子中的数字向前移动
  208.                         lastValue = num[i][j];//lastValue的值更新为下一个不为0的值
  209.                     }
  210.                     ++currentWritePos;//执行到这一步说明num[i][currentWritePos]对应的盘子中的位置已有数值，所以currentWritePos的值加一，对应的盘子中的位置向右移动一位
  211.                 }
  212.                 num[i][j] = 0;//原本的值，要么向前移动了，要么和前面不为0的值合并了，所以要将此处的值赋值为0
  213.             }
  214.             if(lastValue != 0)//本行已经遍历到最后一个位置了，如果lastValue的值不为0，本行的后面没有值可以和lastValue合并了,所以将其赋值给currentWritePos对应的位置
  215.             {
  216.                 num[i][currentWritePos] = lastValue;
  217.             }
  218.         }
  219.         //判断数组的数据是否发生了变化，如果发生了变化，说明此次操作引起了数组的数据发生了移动或者合并，然后盘子中会产生新的数字，反之，说明盘子中的数没有移动，也没有合并，也就是此次操作没有引起变化，盘子中就不能随机生成新的数
  220.         for(int i = 0; i < N;++i)
  221.         {
  222.             for(int j = 0; j < N;++j)
  223.             {
  224.                 if(num[i][j] != tmp[i][j])
  225.                 {
  226.                     return true;
  227.                 }
  228.             }
  229.         }
  230.         return false;
  231.     }
  232.     // 重新开始
  233.     void restart() 
  234.     {
  235.         for (int i = 0; i < N; ++i) 
  236.         {
  237.             for (int j = 0; j < N; ++j) 
  238.             {
  239.                 num[i][j] = 0;//将数组元素初始化为0
  240.             }
  241.         }
  242.         randNew();//随机产生一个数字
  243.         randNew();
  244.         status = S_NORMAL;
  245.     }
  246.     // 随机产生一个新的数字
  247.     bool randNew() 
  248.     {
  249.         vector<int> emptyPos;
  250.         // 把空位置先存起来
  251.         for (int i = 0; i < N; ++i) 
  252.         {
  253.             for (int j = 0; j < N; ++j) 
  254.             {
  255.                 if (num[i][j] == 0) 
  256.                 {
  257.                     emptyPos.push_back(i * N + j);
  258.                 }
  259.             }
  260.         }
  261.         if (emptyPos.size() == 0) 
  262.         {
  263.             return false;
  264.         }
  265.         // 随机找个空位置
  266.         int value = emptyPos[rand() % emptyPos.size()];
  267.         // 10%的概率产生4
  268.         num[value / N][value % N] = rand() % 10 == 1 ? 4 : 2;
  269.         return true;
  270.     }
  271.     //初始化数组
  272.     void setTestData()
  273.     {
  274.         for(int i = 0; i < N; ++i)
  275.         {
  276.             for(int j = 0; j<N; ++j)
  277.             {
  278.                 num[i][j] = 8<<i<<i<<j;//左移一位也就是将数字乘2，移动N位，乘以2的N次方
  279.             }
  280.         }
  281.     }
  282.     void drawch(int row, int col, char c)
  283.     {
  284.         move(row, col);
  285.         addch(c);
  286.     }
  287.     //游戏中的数字是右对齐，row,col是数字最后一位所在的位置
  288.     void drawNum(int row, int col, int num)
  289.     {
  290.         while(num>0)
  291.         {
  292.             drawch(row, col, num%10+'0');
  293.             num /= 10;
  294.             --col;
  295.         }
  296.     }
  297. private:
  298.     int status;
  299.     int num[N][N];
  300. };
  301. void initialize()
  302. {
  303.     //ncurse初始化
  304.     initscr();
  305.     //按键不需要输入回车直接交互
  306.     cbreak();
  307.     //按键不显示
  308.     noecho();
  309.     //隐藏光标
  310.     curs_set(0);
  311.     // 随机数
  312.     srand(time(NULL));
  313. }
  314. void shutdown()
  315. {
  316.     //ncurses清理
  317.     endwin();
  318. }
  319.  
  320. int main()
  321. {
  322.     initialize();
  323.     Game game;
  324.     do
  325.     {   
  326.         game.draw();
  327.         game.processInput();
  328.     }while(game.getStatus() != S_QUIT);
  329.  
  330.     shutdown();
  331.     return 0;
  332. }
  333.

运行结果，以及部分操作图：

好吧，我玩不到2048。。。

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

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

  

闽ICP备14008679号