大大维的游戏机计划3--2048v1

Posted 大大维

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了大大维的游戏机计划3--2048v1相关的知识,希望对你有一定的参考价值。

本文为大大维原创,最早于博客园发表,转载请注明出处!!!

 

前几天由于忙着过年串门,游戏机的计划搁置了几天。这两天终于空出了一块时间,抽空写了2048。

由于笔者前面自制了一个类似2048的游戏,所以写起来也算是轻车熟路,花了两个晚上也就差不多了。

废话少说,先将代码copy一份过来!

后续这几天,笔者想先写一个拼图小游戏,然后想办法将这几个游戏中共同存在的全屏刷新闪屏的问题给解决了。

另外,整个程序代码均为笔者原创,引用或转载请注明出处!

  1 /**--------------------------------------------------------------**/
  2 /**名称:大大维的2048v1                            日期:2017/2/1**/
  3 /**描述:简单地实现了2048的基本功能                            **/
  4 /**存在的问题:由于使用了全局刷新,游戏运行中会出现闪屏现象;
  5 不能够存储玩家的游戏记录;由于不是图形化界面,用户界面较丑;
  6 不能改变游戏的地图大小                                          **/
  7 /**笔者会在后续版本逐步完善这些问题!!!                         **/
  8 /**-------------------------------------------------------------**/
  9 /**申明: 1.本程序由大大维独自编写,转载、引用请注明出处
 10          2.本程序注释掉的部分,笔者认为理论上可以替代后续的代码,
 11          但存在错误。笔者未发现错误原因,如有高手发现,请联系笔者
 12          3.程序中若存在BUG请联系笔者
 13          4.笔者联系方式   1329423134@qq.com                     **/
 14 /**-------------------------------------------------------------**/
 15 #include<iostream>
 16 #include<string>
 17 #include<vector>
 18 #include<ctime>
 19 #include<cstdlib>
 20 #include<conio.h>
 21 using namespace std;
 22 constexpr unsigned HIGH=4;
 23 constexpr unsigned LENG=4;
 24 ///当前地图状态:READY,即(),可以进行moveAndAddData()操作;WAIT,即[],可以进行chooseMapSpace()操作
 25 enum state {READY,WAIT};
 26 ///当前操作块的移动方向:UP,上;DOWN,下;LEFT,左;RIGHT,右;DEFAULT,其他
 27 enum dir {UP,DOWN,LEFT,RIGHT,DEFAULT};
 28 class Map2048
 29 {
 30 public:
 31     Map2048();///构造函数,初始化数据
 32     void moveAndAddData();///移动和相加选中块的数据
 33     ///地图压缩
 34     void mapSortToUp();
 35     void mapSortToDown();
 36     void mapSortToLeft();
 37     void mapSortToRight();
 38     void dataCreate(unsigned persentOf2);///生成新data
 39     bool isLive();///是否存活判断
 40     void printMap();///地图打印
 41     dir setDir();///输入操作块的移动方向
 42     string dataToPrintData(int n);///data到printData的转换函数
 43     unsigned getScore();
 44 private:
 45     unsigned data[HIGH][LENG];///设要显示数据为x,data=log2(x),空白时,data=0
 46     string printData[HIGH][LENG];///存储规范化的输出数据
 47     unsigned score;
 48 };
 49 
 50 Map2048::Map2048()
 51 {
 52     for(int i=0; i<HIGH; i++)
 53         for(int j=0; j<LENG; j++)
 54         {
 55             data[i][j]=0;
 56         }
 57     for(int i=0; i<HIGH; i++)
 58         for(int j=0; j<LENG; j++)
 59             printData[i][j]=dataToPrintData(data[i][j]);
 60     bool initFlag=true;
 61     while(initFlag)
 62     {
 63         srand((unsigned)time(NULL));
 64         int x1=rand()%HIGH,y1=rand()%LENG,x2=rand()%HIGH,y2=rand()%LENG;
 65         if(x1!=x2&&y1!=y2)
 66         {
 67             initFlag=false;
 68             data[x1][y1]=data[x2][y2]=2;
 69             printData[x1][y1]=dataToPrintData(data[x1][y1]);
 70             printData[x2][y2]=dataToPrintData(data[x2][y2]);
 71         }
 72     }
 73     score=0;
 74 }
 75 
 76 void Map2048::moveAndAddData()
 77 {
 78     dir DIR=setDir();
 79     switch(DIR)
 80     {
 81     case UP:
 82     {
 83         mapSortToUp();
 84         for(int n=0; n<LENG; n++)
 85             for(int m=1; m<HIGH; m++)
 86                 if(data[m][n]==data[m-1][n])
 87                 {
 88                     data[m-1][n]*=2;
 89                     data[m][n]=0;
 90                     printData[m-1][n]=dataToPrintData(data[m-1][n]);
 91                     printData[m][n]=dataToPrintData(data[m][n]);
 92                     score+=data[m-1][n];
 93                 }
 94         mapSortToUp();
 95         break;
 96     }
 97     case DOWN:
 98     {
 99         mapSortToDown();
100         for(int n=0; n<LENG; n++)
101             for(int m=HIGH-2; m>=0; m--)
102                 if(data[m][n]==data[m+1][n])
103                 {
104                     data[m+1][n]*=2;
105                     data[m][n]=0;
106                     printData[m+1][n]=dataToPrintData(data[m+1][n]);
107                     printData[m][n]=dataToPrintData(data[m][n]);
108                     score+=data[m+1][n];
109                 }
110         mapSortToDown();
111         break;
112     }
113     case LEFT:
114     {
115         mapSortToLeft();
116         for(int m=0; m<HIGH; m++)
117             for(int n=1; n<LENG; n++)
118                 if(data[m][n]==data[m][n-1])
119                 {
120                     data[m][n-1]*=2;
121                     data[m][n]=0;
122                     printData[m][n-1]=dataToPrintData(data[m][n-1]);
123                     printData[m][n]=dataToPrintData(data[m][n]);
124                     score+=data[m][n-1];
125                 }
126         mapSortToLeft();
127         break;
128     }
129     case RIGHT:
130     {
131         mapSortToRight();
132         for(int m=0; m<HIGH; m++)
133             for(int n=LENG-2; n>=0; n--)
134                 if(data[m][n]==data[m][n+1])
135                 {
136                     data[m][n+1]*=2;
137                     data[m][n]=0;
138                     printData[m][n+1]=dataToPrintData(data[m][n+1]);
139                     printData[m][n]=dataToPrintData(data[m][n]);
140                     score+=data[m][n+1];
141                 }
142         mapSortToRight();
143         break;
144     }
145     case DEFAULT:
146         break;
147     }
148 }
149 
150 void Map2048::mapSortToUp()///地图向上压缩
151 {
152     for(int n=0; n<LENG; n++)
153         for(int m=0; m<HIGH; m++)
154             if(data[m][n]==0)
155                 for(int k=m; k<HIGH; k++)
156                     if(data[k][n]!=0)
157                     {
158                         data[m][n]=data[k][n];
159                         data[k][n]=0;
160                         printData[m][n]=dataToPrintData(data[m][n]);
161                         printData[k][n]=dataToPrintData(data[k][n]);
162                         break;
163                     }
164 }
165 
166 void Map2048::mapSortToDown()///地图向下压缩
167 {
168     for(int n=LENG-1; n>=0; n--)
169         for(int m=HIGH-1; m>=0; m--)
170             if(data[m][n]==0)
171                 for(int k=m; k>=0; k--)
172                     if(data[k][n]!=0)
173                     {
174                         data[m][n]=data[k][n];
175                         data[k][n]=0;
176                         printData[m][n]=dataToPrintData(data[m][n]);
177                         printData[k][n]=dataToPrintData(data[k][n]);
178                         break;
179                     }
180 }
181 
182 void Map2048::mapSortToLeft()///地图向左压缩
183 {
184     for(int m=0; m<HIGH; m++)
185         for(int n=0; n<LENG; n++)
186             if(data[m][n]==0)
187                 for(int k=n; k<LENG; k++)
188                     if(data[m][k]!=0)
189                     {
190                         data[m][n]=data[m][k];
191                         data[m][k]=0;
192                         printData[m][n]=dataToPrintData(data[m][n]);
193                         printData[m][k]=dataToPrintData(data[m][k]);
194                         break;
195                     }
196 }
197 
198 void Map2048::mapSortToRight()///地图向右压缩
199 {
200     for(int m=HIGH-1; m>=0; m--)
201         for(int n=LENG-1; n>=0; n--)
202             if(data[m][n]==0)
203                 for(int k=n; k>=0; k--)
204                     if(data[m][k]!=0)
205                     {
206                         data[m][n]=data[m][k];
207                         data[m][k]=0;
208                         printData[m][n]=dataToPrintData(data[m][n]);
209                         printData[m][k]=dataToPrintData(data[m][k]);
210                         break;
211                     }
212 }
213 
214 void Map2048::dataCreate(unsigned persentOf2)
215 {
216     vector<int> dataVecX;///加入一个矢量,记录空位置的x坐标
217     vector<int> dataVecY;///加入一个矢量,记录空位置的y坐标
218     for(int i=0; i<HIGH; i++)
219         for(int j=0; j<LENG; j++)
220         {
221             if(data[i][j]==0)
222             {
223                 dataVecX.push_back(i);
224                 dataVecY.push_back(j);
225             }
226         }
227     if(!dataVecX.empty())
228     {
229         srand((unsigned)time(NULL));
230         auto k=rand()%dataVecX.size();///在空位中随机选择一个位置
231         if(rand()%100<persentOf2)///根据2,4生成的比例随机生成新数据
232             data[dataVecX[k]][dataVecY[k]]=2;
233         else
234             data[dataVecX[k]][dataVecY[k]]=4;
235         printData[dataVecX[k]][dataVecY[k]]=dataToPrintData(data[dataVecX[k]][dataVecY[k]]);
236     }
237 }
238 
239 bool Map2048::isLive()
240 {
241     bool liveFlag=false;
242     for(int m=0; m<HIGH; m++) ///确保没有空位置
243         for(int n=0; n<LENG; n++)
244             if(data[m][n]==0)
245             {
246                 liveFlag=true;
247                 return liveFlag;
248             }
249 //    ///以下代码基于如下数学关系:反复使用向右,向下查询
250 //    ///(最右行只向下,最底行只向右),可以遍历检查一遍元素自身是否与邻居相等
251 //    for(int i=0; i<HIGH; i++)
252 //    {
253 //        for(int j=0; j<LENG; j++)
254 //        {
255 //            if(i!=HIGH-1&&j!=LENG-1)///非最右且非最下节点
256 //            {
257 //                if(data[i][j]==data[i][j+1]||data[i][j]==data[i+1][j])///向右,向下比较
258 //                {
259 //                    liveFlag=true;
260 //                    return liveFlag;
261 //                }
262 //            }
263 //            else if(i==HIGH-1&&j!=LENG-1)///非最右但是最下节点
264 //            {
265 //                if(data[i][j]=data[i][j+1])///向右比较
266 //                {
267 //                    liveFlag=true;
268 //                    return liveFlag;
269 //                }
270 //            }
271 //            else if(i!=HIGH-1&&j==LENG-1)///非最下但是最右节点
272 //            {
273 //                if(data[i][j]=data[i+1][j])///向下比较
274 //                {
275 //                    liveFlag=true;
276 //                    return liveFlag;
277 //                }
278 //            }
279 //            else///末尾节点,即最下且最右节点,无须比较,直接返回标志
280 //                return liveFlag;
281 //        }
282 //    }
283     for(int m=0; m<HIGH; m++) ///确保没有空位置
284         for(int n=0; n<LENG; n++)
285         {
286             if((m==0)&&(n==0))
287             {
288                 if(data[m][n]==data[m+1][n]||data[m][n]==data[m][n+1])
289                 {
290                     liveFlag=true;
291                     return liveFlag;
292                 }
293             }
294             else if((m==HIGH-1)&&(n==LENG-1))
295             {
296                 if(data[m][n]==data[m-1][n]||data[m][n]==data[m][n-1])
297                 {
298                     liveFlag=true;
299                     return liveFlag;
300                 }
301             }
302             else if((m==0)&&(n==LENG-1))
303             {
304                 if(data[m][n]==data[m+1][n]||data[m][n]==data[m][n-1])
305                 {
306                     liveFlag=true;
307                     return liveFlag;
308                 }
309             }
310             else if((m==HIGH-1)&&(n==0))
311             {
312                 if(data[m][n]==data[m-1][n]||data[m][n]==data[m][n+1])
313                 {
314                     liveFlag=true;
315                     return liveFlag;
316                 }
317             }
318             else if((m==0)&&(n!=0)&&(n!=LENG-1))
319             {
320                 if(data[m][n]==data[m+1][n]||data[m][n]==data[m][n-1]||data[m][n]==data[m][n+1])
321                 {
322                     liveFlag=true;
323                     return liveFlag;
324                 }
325             }
326             else if((m=HIGH-1)&&(n!=0)&&(n!=LENG-1))
327             {
328                 if(data[m][n]==data[m-1][n]||data[m][n]==data[m][n-1]||data[m][n]==data[m][n+1])
329                 {
330                     liveFlag=true;
331                     return liveFlag;
332                 }
333             }
334             else if((n==0)&&(m!=0)&&(m!=HIGH-1))
335             {
336                 if(data[m][n]==data[m+1][n]||data[m][n]==data[m-1][n]||data[m][n]==data[m][n+1])
337                 {
338                     liveFlag=true;
339                     return liveFlag;
340                 }
341             }
342             else if((n==LENG-1)&&(m!=0)&&(m!=HIGH-1))
343             {
344                 if(data[m][n]==data[m+1][n]||data[m][n]==data[m-1][n]||data[m][n]==data[m][n-1])
345                 {
346                     liveFlag=true;
347                     return liveFlag;
348                 }
349             }
350             else
351             {
352                 以上是关于大大维的游戏机计划3--2048v1的主要内容,如果未能解决你的问题,请参考以下文章

Python编程快速上手让繁琐工作自动化-第十一章实践项目11.11.3 2048

cocos2dx3.0 2048多功能版

从片段调用 Google Play 游戏服务

第二个五年计划

将多个输出中的hls属性设置为单独的片段代码

游戏运维的最佳实践:搜狐畅游自动化运维之旅!