热门游戏2048C++源代码分享

这游戏前一段时间传的很火，前几天早上上课实在太无聊了，就决定把这游戏自己也写一个。

网站建设哪家好，找成都创新互联！专注于网页设计、网站建设、微信开发、微信小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了湖南免费建站欢迎大家使用！

前后写了一个多小时吧，大概300行左右，没什么复杂算法，不过实在懒得去优化了，但估计优化完能控制在200行以下，有兴趣的朋友可以自己优化一下。

说明：我一开始玩的是IOS APP版的TRHEES，后来才玩的2048，两者在滑动的规则上有些区别，本人这个版本是这两者的结合。

***，祝试玩愉快！

界面丑陋，求不笑。

以下是源代码：

 
 
    
  
  
  1. /*By Reason*/
    2. 
  
  
  2. #include 
    3. 
  
  
  3. #include  
    4. 
  
  
  4. #include 
    5. 
  
  
  5. #include 
    6. 
  
  
  6. #include 
    7. 
  
  
  7. #include  //为了读取方向键 
    8. 
  
  
  8. #include 
    9. 
  
  
  9. using namespace std;   
    10. 
  
  
  10. //srand( (unsigned)time( NULL ) ); //随机数种子 不能用在这里 
    11. 
  
  
  11. int pane[4][4]; //棋盘 
    12. 
  
  
  12. int N=1; //2的n次方 
    13. 
  
  
  13. void showpane() //显示棋盘 
    14. 
  
  
  14. { 
    15. 
  
  
  15.  cout<
  
  
  16.  cout<
  
  
  17.  for(int i=0;i<=3;i++)  
    18. 
  
  
  18.  { 
    19. 
  
  
  19.  cout<
  
  
  20.  for(int j=0;j<=3;j++) 
    21. 
  
  
  21.  { 
    22. 
  
  
  22.  //SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED);  
    23. 
  
  
  23.  cout<
  
  
  24.   
    25. 
  
  
  25.  if(j==3) 
    26. 
  
  
  26.  { 
    27. 
  
  
  27.  cout<
  
  
  28.  cout<
  
  
  29.  } 
    30. 
  
  
  30.  } 
    31. 
  
  
  31.  } 
    32. 
  
  
  32. } 
    33. 
  
  
  33. void newgame() //开始游戏 
    34. 
  
  
  34. { 
    35. 
  
  
  35.  N=1; 
    36. 
  
  
  36.  for(int i=0;i<=3;i++) //初始化棋盘 
    37. 
  
  
  37.  for(int j=0;j<=3;j++) 
    38. 
  
  
  38.  pane[i][j]=0; 
    39. 
  
  
  39.  srand( (unsigned)time( NULL ) ); 
    40. 
  
  
  40.  int m=rand()%4; 
    41. 
  
  
  41.  int n=rand()%4; 
    42. 
  
  
  42.  int p=rand()%4; 
    43. 
  
  
  43.  int q=rand()%4; 
    44. 
  
  
  44.  pane[m][n]=pane[p][q]=2; 
    45. 
  
  
  45.  showpane(); 
    46. 
  
  
  46. } 
    47. 
  
  
  47. int if2n(int x) //判断x是否是2的n次方 
    48. 
  
  
  48. { 
    49. 
  
  
  49.  int flag=0; 
    50. 
  
  
  50.  for(int n=1;n<=11;n++) 
    51. 
  
  
  51.  { 
    52. 
  
  
  52.  if(x==pow(2,n)) 
    53. 
  
  
  53.  { 
    54. 
  
  
  54.  flag=1; 
    55. 
  
  
  55.  if(n>N) 
    56. 
  
  
  56.  N=n; 
    57. 
  
  
  57.  return flag; 
    58. 
  
  
  58.  } 
    59. 
  
  
  59.  } 
    60. 
  
  
  60.  return flag; 
    61. 
  
  
  61. } 
    62. 
  
  
  62. int upmove() //上移 
    63. 
  
  
  63. { 
    64. 
  
  
  64.  int flag=0; 
    65. 
  
  
  65.  for(int j=0;j<=3;j++) 
    66. 
  
  
  66.  for(int i=0;i<3;i++) 
    67. 
  
  
  67.  { 
    68. 
  
  
  68.  if(if2n(pane[i][j]+pane[i+1][j])==1) 
    69. 
  
  
  69.  { 
    70. 
  
  
  70.  pane[i][j]=pane[i][j]+pane[i+1][j]; 
    71. 
  
  
  71.  pane[i+1][j]=0; 
    72. 
  
  
  72.  flag=1; 
    73. 
  
  
  73.  } 
    74. 
  
  
  74.  } 
    75. 
  
  
  75.  return flag; 
    76. 
  
  
  76. } 
    77. 
  
  
  77. int downmove() //下移 
    78. 
  
  
  78. { 
    79. 
  
  
  79.  int flag=0; 
    80. 
  
  
  80.  for(int j=0;j<=3;j++) 
    81. 
  
  
  81.  for(int i=3;i>0;i--) 
    82. 
  
  
  82.  { 
    83. 
  
  
  83.  if(if2n(pane[i][j]+pane[i-1][j])==1) 
    84. 
  
  
  84.  { 
    85. 
  
  
  85.  pane[i][j]=pane[i][j]+pane[i-1][j]; 
    86. 
  
  
  86.  pane[i-1][j]=0; 
    87. 
  
  
  87.  flag=1; 
    88. 
  
  
  88.  } 
    89. 
  
  
  89.  } 
    90. 
  
  
  90.  return flag; 
    91. 
  
  
  91. } 
    92. 
  
  
  92. int leftmove() //左移 
    93. 
  
  
  93. { 
    94. 
  
  
  94.  int flag=0; 
    95. 
  
  
  95.  for(int i=0;i<=3;i++) 
    96. 
  
  
  96.  for(int j=0;j<3;j++) 
    97. 
  
  
  97.  { 
    98. 
  
  
  98.  if(if2n(pane[i][j]+pane[i][j+1])==1) 
    99. 
  
  
  99.  { 
    100. 
  
  
  100.  pane[i][j]=pane[i][j]+pane[i][j+1]; 
    101. 
  
  
  101.  pane[i][j+1]=0; 
    102. 
  
  
  102.  flag=1; 
    103. 
  
  
  103.  } 
    104. 
  
  
  104.  } 
    105. 
  
  
  105.  return flag; 
    106. 
  
  
  106. } 
    107. 
  
  
  107. int rightmove() //右移 
    108. 
  
  
  108. { 
    109. 
  
  
  109.  int flag=0; 
    110. 
  
  
  110.  for(int i=0;i<=3;i++) 
    111. 
  
  
  111.  for(int j=3;j>0;j--) 
    112. 
  
  
  112.  { 
    113. 
  
  
  113.  if(if2n(pane[i][j]+pane[i][j-1])==1) 
    114. 
  
  
  114.  { 
    115. 
  
  
  115.  pane[i][j]=pane[i][j]+pane[i][j-1]; 
    116. 
  
  
  116.  pane[i][j-1]=0; 
    117. 
  
  
  117.  flag=1; 
    118. 
  
  
  118.  } 
    119. 
  
  
  119.  } 
    120. 
  
  
  120.  return flag; 
    121. 
  
  
  121. } 
    122. 
  
  
  122. int testup() //能否上移测试 
    123. 
  
  
  123. { 
    124. 
  
  
  124.  int flag=0; 
    125. 
  
  
  125.  for(int j=0;j<=3;j++) 
    126. 
  
  
  126.  for(int i=0;i<3;i++) 
    127. 
  
  
  127.  { 
    128. 
  
  
  128.  if(if2n(pane[i][j]+pane[i+1][j])==1) 
    129. 
  
  
  129.  { 
    130. 
  
  
  130.  flag=1; 
    131. 
  
  
  131.  } 
    132. 
  
  
  132.  } 
    133. 
  
  
  133.  return flag; 
    134. 
  
  
  134. } 
    135. 
  
  
  135. int testdown() //测试能否下移 
    136. 
  
  
  136. { 
    137. 
  
  
  137.  int flag=0; 
    138. 
  
  
  138.  for(int j=0;j<=3;j++) 
    139. 
  
  
  139.  for(int i=3;i>0;i--) 
    140. 
  
  
  140.  { 
    141. 
  
  
  141.  if(if2n(pane[i][j]+pane[i-1][j])==1) 
    142. 
  
  
  142.  { 
    143. 
  
  
  143.  flag=1; 
    144. 
  
  
  144.  } 
    145. 
  
  
  145.  } 
    146. 
  
  
  146.  return flag; 
    147. 
  
  
  147. } 
    148. 
  
  
  148. int testleft() //测试能否左移 
    149. 
  
  
  149. { 
    150. 
  
  
  150.  int flag=0; 
    151. 
  
  
  151.  for(int i=0;i<=3;i++) 
    152. 
  
  
  152.  for(int j=0;j<3;j++) 
    153. 
  
  
  153.  { 
    154. 
  
  
  154.  if(if2n(pane[i][j]+pane[i][j+1])==1) 
    155. 
  
  
  155.  { 
    156. 
  
  
  156.  flag=1; 
    157. 
  
  
  157.  } 
    158. 
  
  
  158.  } 
    159. 
  
  
  159.  return flag; 
    160. 
  
  
  160. } 
    161. 
  
  
  161. int testright() //测试能否右移 
    162. 
  
  
  162. { 
    163. 
  
  
  163.  int flag=0; 
    164. 
  
  
  164.  for(int i=0;i<=3;i++) 
    165. 
  
  
  165.  for(int j=3;j>0;j--) 
    166. 
  
  
  166.  { 
    167. 
  
  
  167.  if(if2n(pane[i][j]+pane[i][j-1])==1) 
    168. 
  
  
  168.  { 
    169. 
  
  
  169.  flag=1; 
    170. 
  
  
  170.  } 
    171. 
  
  
  171.  } 
    172. 
  
  
  172.  return flag; 
    173. 
  
  
  173. } 
    174. 
  
  
  174. int panemax() //棋盘***数 
    175. 
  
  
  175. { 
    176. 
  
  
  176.  int max=pane[0][0]; 
    177. 
  
  
  177.  for(int i=0;i<=3;i++) 
    178. 
  
  
  178.  for(int j=0;j<=3;j++) 
    179. 
  
  
  179.  if(pane[i][j]>max) 
    180. 
  
  
  180.  max=pane[i][j]; 
    181. 
  
  
  181.  return max; 
    182. 
  
  
  182. } 
    183. 
  
  
  183. int ifwin() //判断是否胜利 
    184. 
  
  
  184. { 
    185. 
  
  
  185.  int flag=0; 
    186. 
  
  
  186.  if(panemax()==2048) 
    187. 
  
  
  187.  { 
    188. 
  
  
  188.  cout<
  
  
  189.  flag=1; 
    190. 
  
  
  190.  } 
    191. 
  
  
  191.  return flag; 
    192. 
  
  
  192. } 
    193. 
  
  
  193. int ifGameOver() //判断是否游戏结束 
    194. 
  
  
  194. { 
    195. 
  
  
  195.  int flag=0; 
    196. 
  
  
  196.  if(testup()+ testdown() + testleft() + testright() ==0) 
    197. 
  
  
  197.  { 
    198. 
  
  
  198.  cout<
  
  
  199.  flag=1; 
    200. 
  
  
  200.  } 
    201. 
  
  
  201.  return flag; 
    202. 
  
  
  202. } 
    203. 
  
  
  203. void addnewnumberup() //上移后添加新数 
    204. 
  
  
  204. { 
    205. 
  
  
  205.  srand( (unsigned)time( NULL ) ); 
    206. 
  
  
  206.  int n; 
    207. 
  
  
  207.  if(N==1) 
    208. 
  
  
  208.  n=1; 
    209. 
  
  
  209.  else
    210. 
  
  
  210.  n=(rand()%(N)+1);  
    211. 
  
  
  211.  int newnumber=pow(2,n); 
    212. 
  
  
  212.  for(int i=3;i>=0;i--) 
    213. 
  
  
  213.  for(int j=0;j<=3;j++) 
    214. 
  
  
  214.  if(pane[i][j]==0) 
    215. 
  
  
  215.  { 
    216. 
  
  
  216.  pane[i][j]=newnumber; 
    217. 
  
  
  217.  return; 
    218. 
  
  
  218.  } 
    219. 
  
  
  219. } 
    220. 
  
  
  220. void addnewnumberdown() //下移后添加新数 
    221. 
  
  
  221. { 
    222. 
  
  
  222.  srand( (unsigned)time( NULL ) ); 
    223. 
  
  
  223.  int n; 
    224. 
  
  
  224.  if(N==1) 
    225. 
  
  
  225.  n=1; 
    226. 
  
  
  226.  else
    227. 
  
  
  227.  n=(rand()%(N)+1); int newnumber=pow(2,n); 
    228. 
  
  
  228.  for(int i=0;i<=3;i++) 
    229. 
  
  
  229.  for(int j=0;j<=3;j++) 
    230. 
  
  
  230.  if(pane[i][j]==0) 
    231. 
  
  
  231.  { 
    232. 
  
  
  232.  pane[i][j]=newnumber; 
    233. 
  
  
  233.  return; 
    234. 
  
  
  234.  } 
    235. 
  
  
  235. } 
    236. 
  
  
  236. void addnewnumberleft() //左移后添加新数 
    237. 
  
  
  237. { 
    238. 
  
  
  238.  srand( (unsigned)time( NULL ) ); 
    239. 
  
  
  239.  int n; 
    240. 
  
  
  240.  if(N==1) 
    241. 
  
  
  241.  n=1; 
    242. 
  
  
  242.  else
    243. 
  
  
  243.  n=(rand()%(N)+1);  
    244. 
  
  
  244.  int newnumber=pow(2,n); 
    245. 
  
  
  245.  for(int j=3;j>=0;j--) 
    246. 
  
  
  246.  for(int i=0;i<=3;i++) 
    247. 
  
  
  247.  if(pane[i][j]==0) 
    248. 
  
  
  248.  { 
    249. 
  
  
  249.  pane[i][j]=newnumber; 
    250. 
  
  
  250.  return; 
    251. 
  
  
  251.  } 
    252. 
  
  
  252. } 
    253. 
  
  
  253. void addnewnumberright() //右移后添加新数 
    254. 
  
  
  254. { 
    255. 
  
  
  255.  srand( (unsigned)time( NULL ) ); 
    256. 
  
  
  256.  int n; 
    257. 
  
  
  257.  if(N==1) 
    258. 
  
  
  258.  n=1; 
    259. 
  
  
  259.  else
    260. 
  
  
  260.  n=(rand()%(N)+1);  
    261. 
  
  
  261.  int newnumber=pow(2,n); 
    262. 
  
  
  262.  for(int j=0;j<=3;j++) 
    263. 
  
  
  263.  for(int i=0;i<=3;i++) 
    264. 
  
  
  264.  if(pane[i][j]==0) 
    265. 
  
  
  265.  { 
    266. 
  
  
  266.  pane[i][j]=newnumber; 
    267. 
  
  
  267.  return; 
    268. 
  
  
  268.  } 
    269. 
  
  
  269. } 
    270. 
  
  
  270. int GetDirection() //读取方向 
    271. 
  
  
  271. { 
    272. 
  
  
  272.     int ret = 0; 
    273. 
  
  
  273.   
    274. 
  
  
  274.     do  
    275. 
  
  
  275.     { 
    276. 
  
  
  276.         int ch = _getch(); 
    277. 
  
  
  277.         if(isascii(ch)) 
    278. 
  
  
  278.             continue; 
    279. 
  
  
  279.   
    280. 
  
  
  280.         ch = _getch(); 
    281. 
  
  
  281.         switch(ch) 
    282. 
  
  
  282.         { 
    283. 
  
  
  283.         case 72:    
    284. 
  
  
  284.             ret = 2; // top 
    285. 
  
  
  285.             break; 
    286. 
  
  
  286.         case 75:    
    287. 
  
  
  287.             ret = 1; // left  
    288. 
  
  
  288.             break; 
    289. 
  
  
  289.         case 77:    
    290. 
  
  
  290.             ret = 3; // right 
    291. 
  
  
  291.             break; 
    292. 
  
  
  292.         case 80:    
    293. 
  
  
  293.             ret = 4; // down 
    294. 
  
  
  294.             break; 
    295. 
  
  
  295.         default:    
    296. 
  
  
  296.             break; 
    297. 
  
  
  297.         } 
    298. 
  
  
  298.     } while (ret == 0); 
    299. 
  
  
  299.       
    300. 
  
  
  300.     return ret; 
    301. 
  
  
  301. } 
    302. 
  
  
  302. void main() //主函数 
    303. 
  
  
  303. { 
    304. 
  
  
  304.  system("color f9"); 
    305. 
  
  
  305.  int makesure=1; 
    306. 
  
  
  306.  while(makesure) 
    307. 
  
  
  307.  {  
    308. 
  
  
  308.  system("cls"); 
    309. 
  
  
  309.  newgame(); 
    310. 
  
  
  310.  while(ifwin()+ifGameOver()==0) 
    311. 
  
  
  311.  { 
    312. 
  
  
  312.  int c=GetDirection(); 
    313. 
  
  
  313.  switch(c) 
    314. 
  
  
  314.  { 
    315. 
  
  
  315.  case 2: 
    316. 
  
  
  316.  upmove(); 
    317. 
  
  
  317.  addnewnumberup(); 
    318. 
  
  
  318.  system("cls"); 
    319. 
  
  
  319.  showpane(); 
    320. 
  
  
  320.  break; 
    321. 
  
  
  321.  case 4: 
    322. 
  
  
  322.  downmove(); 
    323. 
  
  
  323.  addnewnumberdown(); 
    324. 
  
  
  324.  system("cls"); 
    325. 
  
  
  325.  showpane(); 
    326. 
  
  
  326.  break; 
    327. 
  
  
  327.  case 1: 
    328. 
  
  
  328.  leftmove(); 
    329. 
  
  
  329.  addnewnumberleft(); 
    330. 
  
  
  330.  system("cls"); 
    331. 
  
  
  331.  showpane(); 
    332. 
  
  
  332.  break; 
    333. 
  
  
  333.  case 3: 
    334. 
  
  
  334.  rightmove(); 
    335. 
  
  
  335.  addnewnumberright(); 
    336. 
  
  
  336.  system("cls"); 
    337. 
  
  
  337.  showpane(); 
    338. 
  
  
  338.  break; 
    339. 
  
  
  339.  default:    
    340. 
  
  
  340.  break; 
    341. 
  
  
  341.  } 
    342. 
  
  
  342.  } 
    343. 
  
  
  343.  cout<
  
  
  344.  cout<
  
  
  345.  cin>>makesure; 
    346. 
  
  
  346.  while(makesure!=1&&makesure!=0) 
    347. 
  
  
  347.  { 
    348. 
  
  
  348.  cout<<"输入不正确，请重新输入!"<
  
  
  349.  cin>>makesure; 
    350. 
  
  
  350.  } 
    351. 
  
  
  351.  } 
    352. 
  
  
  352.  cout<<"再见！"<
  
  
  353.  system("pause"); 
    354. 
  
  
  354.   
    355. 
  
  
  355. }
    356.

网站题目：热门游戏2048C++源代码分享
路径分享：http://www.shufengxianlan.com/qtweb/news26/268876.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

标签优化知识

同城分类信息

网站空间　　 　温江网站建设　　 　成都网络营销　　 　混凝土密封固化剂　　 　成都app软件开发　　 　网站seo优化　　 　成都棕树电信机房　　 　APP定制　　 　成都圣月制冷　　 　德阳服务器托管　　 　西部信息服务器托管　　 　达州做网站　　 　宇仓仓储　　 　广安园林景观设计　　 　手机网站制作　　 　成都画册设计公司　　 　微信小程序开发　　 　广汉锦华建材　　 　bgp多线机房托管　　 　成都商城网站建设公司