〇、前言
       本文最初是在2014年发表的，当时只是Windows版本的，前段时间有位读者给我发邮件咨询Linux下版本移植问题，于是便花时间支持了Linux下的版本，并修改完善了代码，加入记录最高分的功能，供读者参考学习。
  一、游戏介绍
       所谓《2048》是最近比较流行的一款数字游戏。原版2048首先在github上发布，原作者是Gabriele Cirulli。它是基于《1024》和《小3传奇》（Threes!）的玩法开发而成的新型数字游戏。
  二、游戏规则
       游戏的规则很简单，你需要控制所有方块向同一个方向运动，两个相同数字的方块撞在一起之后合并成为他们的和，每次操作之后会在空白的方格处随机生成一个2或者4（生成2的概率要大一些），最终得到一个“2048”的方块就算胜利了。
  三、核心算法
  1、方块的移动和合并
       主要思想：把游戏数字面板抽象成4行4列的二维数组a[4][4]，值为0的位置表示空方块，其他表示对应数字方块。把每一行同等对待，只研究一行的移动和合并算法，然后可以通过遍历行来实现所有行的移动合并算法。在一行中，用b[4]表示一行的一维数组，使用两个下标变量来遍历列项，这里使用j和k，其中j总在k的后面，用来寻找k项后面第一个不为0的数字，而k项用于表示当前待比较的项，总是和j项之间隔着若干个数字0，或者干脆紧挨着。不失一般性，考虑往左滑动时，初始情况下j等于1，而k等于0，接着判断j项数字是否大于0，若是，则判断j项和k项数字的关系，分成3种情况处理，分别是（合并）P1: b[k]==b[j]，（移动）P2: b[k]==0和（碰撞）P3: b[k]!=0且b[k]!=b[j]；若否，则j自加1，然后继续寻找k项后面第一个不为0的数字。
       其中P1，P2和P3分别对应如下：
       （合并）P1：b[k]==b[j]，则b[k] = 2 * b[k]（说明两数合并了），且b[j] = 0（合并之后要将残留的j项值清零），接着k自加1，然后进行下一次循环。
       （移动）P2：b[k]==0，则表示b[j]之前全是空格子，此时直接移动b[j]到k的位置，也就是b[k] = b[j]，然后b[j] = 0（移动后将残留的j项值清零），接着k值不变，然后进行下一次循环。
       （碰撞）P3：b[k]!=0且b[k]!=b[j]，则表示两数不相等且都不为0，此时将两数靠在一起，也就是b[k+1] = b[j]。接着分两种小情况，若j!=k+1，则b[j] = 0（移动后将残留的j项值清零）；若否，则表示两数原先就靠在一起，则不进行特殊处理（相当于未移动）。接着k自加1，然后进行下一次循环。
       举一个P1的例子，流程表示如下：
      011753497132914.png
       一行内移动合并算法描述如下（此例为左移情况，其他方向与之类似，区别仅仅是遍历二维数组的行项和列项的方式）：
  2. int j, k;
  3. for (j = 1, k = 0; j < 4; j++) {
  4.     if (b[j] > 0) { /* 找出k后面第一个不为空的项，下标为j，之后分三种情况 */
  5.         if (b[k] == b[j]) { /* P1情况，合并 */
  6.             b[k] = 2 * b[k];
  7.             b[j] = 0;
  8.             k = k + 1;
  9.         } else if (b[k] == 0) { /* P2情况，移动 */
  10.             b[k] = b[j];
  11.             b[j] = 0;
  12.         } else { /* P3情况，碰撞 */
  13.             b[k + 1] = b[j];
  14.             if (j != k + 1) { /* 原先两数不挨着 */
  15.                 b[j] = 0;
  16.             }
  17.             k = k + 1;
  18.         }
  19.     }
  20. }
2、判断游戏是否结束
       核心思想：遍历二维数组，看是否存在横向和纵向两个相邻的元素相等，若存在，则游戏不结束，若不存在，则游戏结束。
       算法代码描述如下（board表示真正的游戏源码中使用的二维数组）：
  1. /* 检查游戏是否结束 函数定义 */
  2. void check_game_over() {
  3.     int i;
  4.     for (i = 0; i < 4; ++i) {
  5.         int j;
  6.         for (j = 0; j < 3; ++j) {
  7.             /* 横向和纵向比较挨着的两个元素是否相等，若有相等则游戏不结束 */
  8.             if (board[i][j] == board[i][j + 1] || board[j][i] == board[j + 1][i]) {
  9.                 if_game_over = 0;
  10.                 return;
  11.             }
  12.         }
  13.     }
  14.     if_game_over = 1;
  15. }
3、生成随机数
       核心思想：根据生成的随机数，对一定的值进行取模，达到生成一定概率的数。在本游戏中，设定4出现的概率为1/10，于是可以利用系统提供的随机数函数生成一个数，然后对10取余，得到的数若大于0则在游戏面板空格处生成一个2，若余数等于0，则生成4。在选择将在哪一个空格出生成数的时候，也是根据系统提供的随机函数生成一个数，然后对空格数取余，然后在第余数个空格出生成数字。
       算法代码描述如下（board表示真正的游戏源码中使用的二维数组）：
  1. /* 生成随机数 函数定义 */
  2. void add_rand_num() {
  3.     srand((unsigned int) time(0));
  4.     int n = rand() % get_null_count(); /* 确定在何处空位置生成随机数 */
  5.     int i;
  6.     for (i = 0; i < 4; ++i) {
  7.         int j;
  8.         for (j = 0; j < 4; ++j) {
  9.             /* 定位待生成的位置 */
  10.             if (board[i][j] == 0 && n-- == 0) {
  11.                 board[i][j] = (rand() % 10 ? 2 : 4); /* 生成数字2或4，生成概率为9:1 */
  12.                 return;
  13.             }
  14.         }
  15.     }
  16. }
4、绘制界面
       核心思想：利用系统提供的控制台界面清屏功能，达到刷新界面的效果，利用控制制表符位置，达到绘制游戏数字面板的效果。
       由于绘制界面不算是本游戏的本质，且代码段相对较长，所以算法描述在这里省略，读者可以参考完整源代码。
  5、计算得分
       核心思想：两块带数字的方格合并后的数字为合并的得分，一次上下左右移动后游戏面板上所有合并的得分总和为一次移动的得分，多次移动的得分进行累加作为当前总得分。
       如果当前总得分（SCORE）超过最高分（BEST），则最高分被改写为当前总得分，并存储下来，下次启动游戏时会自动载入本机存储的最高分。
  四、完整源代码如下，敬请读者批评指正：
  1. /*
  2. * Copyright (C) 2014-2018 Judge Young
  3. * E-mail: yjjtc@126.com
  4. * Version: 2.0
  5. * DateTime: 2018-08-01 23:18
  6. */
  8. #include <time.h>   /* 包含设定随机数种子所需要的time()函数 */
  9. #include <stdio.h>  /* 包含C的IO读写功能 */
  10. #include <stdlib.h> /* 包含C标准库的功能 */
  12. #ifdef _WIN32
  14. /* 包含Windows平台相关函数，包括控制台界面清屏及光标设定等功能 */
  15. #include <conio.h>
  16. #include <windows.h>
  17. #include <io.h>
  18. #include <direct.h>
  19. #include <Shlobj.h>
  21. #else
  23. /* 包含Linux平台相关函数，包括控制台界面清屏及光标设定等功能 */
  24. #include <termio.h>
  25. #include <unistd.h>
  26. #include <bits/signum.h>
  27. #include <signal.h>
  29. #define KEY_CODE_UP    0x41
  30. #define KEY_CODE_DOWN  0x42
  31. #define KEY_CODE_LEFT  0x44
  32. #define KEY_CODE_RIGHT 0x43
  33. #define KEY_CODE_QUIT  0x71
  35. struct termios old_config; /* linux下终端属性配置备份 */
  37. #endif
  39. static char config_path[4096] = {0}; /* 配置文件路径 */
  41. static void init_game();    /* 初始化游戏 */
  42. static void loop_game();    /* 游戏循环 */
  43. static void reset_game();   /* 重置游戏 */
  44. static void release_game(int signal); /* 释放游戏 */
  46. static int read_keyboard();
  48. static void move_left();  /* 左移 */
  49. static void move_right(); /* 右移 */
  50. static void move_up();    /* 上移 */
  51. static void move_down();  /* 下移 */
  53. static void add_rand_num();    /* 生成随机数，本程序中仅生成2或4，概率之比设为9:1 */
  54. static void check_game_over(); /* 检测是否输掉游戏，设定游戏结束标志 */
  55. static int get_null_count();   /* 获取游戏面板上空位置数量 */
  56. static void clear_screen();    /* 清屏 */
  57. static void refresh_show();    /* 刷新界面显示 */
  59. static int board[4][4];     /* 游戏数字面板，抽象为二维数组 */
  60. static int score;           /* 游戏得分 */
  61. static int best;            /* 游戏最高分 */
  62. static int if_need_add_num; /* 是否需要生成随机数标志，1表示需要，0表示不需要 */
  63. static int if_game_over;    /* 是否游戏结束标志，1表示游戏结束，0表示正常 */
  64. static int if_prepare_exit; /* 是否准备退出游戏，1表示是，0表示否 */
  66. /* main函数 函数定义 */
  67. int main(int argc, char *argv[]) {
  68.     init_game();
  69.     loop_game();
  70.     release_game(0);
  71.     return 0;
  72. }
  74. /* 读取键盘 函数定义 */
  75. int read_keyboard() {
  76. #ifdef _WIN32
  77.     return _getch();
  78. #else
  79.     int key_code;
  80.     if (read(0, &key_code, 1) < 0) {
  81.         return -1;
  82.     }
  83.     return key_code;
  84. #endif
  85. }
  87. /* 开始游戏 函数定义 */
  88. void loop_game() {
  89.     while (1) {
  90.         int cmd = read_keyboard(); /* 接收标准输入流字符命令 */
  92.         /* 判断是否准备退出游戏 */
  93.         if (if_prepare_exit) {
  94.             if (cmd == 'y' || cmd == 'Y') {
  95.                 /* 退出游戏，清屏后退出 */
  96.                 clear_screen();
  97.                 return;
  98.             } else if (cmd == 'n' || cmd == 'N') {
  99.                 /* 取消退出 */
  100.                 if_prepare_exit = 0;
  101.                 refresh_show();
  102.                 continue;
  103.             } else {
  104.                 continue;
  105.             }
  106.         }
  108.         /* 判断是否已经输掉游戏 */
  109.         if (if_game_over) {
  110.             if (cmd == 'y' || cmd == 'Y') {
  111.                 /* 重玩游戏 */
  112.                 reset_game();
  113.                 continue;
  114.             } else if (cmd == 'n' || cmd == 'N') {
  115.                 /* 退出游戏，清屏后退出  */
  116.                 clear_screen();
  117.                 return;
  118.             } else {
  119.                 continue;
  120.             }
  121.         }
  123.         if_need_add_num = 0; /* 先设定不默认需要生成随机数，需要时再设定为1 */
  125. #ifdef _WIN32
  126.         /* 命令解析，w，s，a，d字符代表上下左右命令，q代表退出 */
  127.         switch (cmd) {
  128.           case 'a':
  129.           case 75:move_left();
  130.             break;
  131.           case 's':
  132.           case 80:move_down();
  133.             break;
  134.           case 'w':
  135.           case 72:move_up();
  136.             break;
  137.           case 'd':
  138.           case 77:move_right();
  139.             break;
  140.           case 'q':
  141.           case 27:if_prepare_exit = 1;
  142.             break;
  143.           default:continue;
  144.         }
  145. #else
  146.         /* 命令解析，上下左右箭头代表上下左右命令，q代表退出 */
  147.         switch (cmd) {
  148.             case 'a':
  149.             case KEY_CODE_LEFT:move_left();
  150.                 break;
  151.             case 's':
  152.             case KEY_CODE_DOWN:move_down();
  153.                 break;
  154.             case 'w':
  155.             case KEY_CODE_UP:move_up();
  156.                 break;
  157.             case 'd':
  158.             case KEY_CODE_RIGHT:move_right();
  159.                 break;
  160.             case KEY_CODE_QUIT:if_prepare_exit = 1;
  161.                 break;
  162.             default:continue;
  163.         }
  164. #endif
  165.         /* 打破得分纪录 */
  166.         if (score > best) {
  167.             best = score;
  168.             FILE *fp = fopen(config_path, "w");
  169.             if (fp) {
  170.                 fwrite(&best, sizeof(best), 1, fp);
  171.                 fclose(fp);
  172.             }
  173.         }
  175.         /* 默认为需要生成随机数时也同时需要刷新显示，反之亦然 */
  176.         if (if_need_add_num) {
  177.             add_rand_num();
  178.             refresh_show();
  179.         } else if (if_prepare_exit) {
  180.             refresh_show();
  181.         }
  182.     }
  183. }
  185. /* 重置游戏 函数定义 */
  186. void reset_game() {
  187.     score = 0;
  188.     if_need_add_num = 1;
  189.     if_game_over = 0;
  190.     if_prepare_exit = 0;
  192.     /* 了解到游戏初始化时出现的两个数一定会有个2，所以先随机生成一个2，其他均为0 */
  193.     int n = rand() % 16;
  194.     int i;
  195.     for (i = 0; i < 4; ++i) {
  196.         int j;
  197.         for (j = 0; j < 4; ++j) {
  198.             board[i][j] = (n-- == 0 ? 2 : 0);
  199.         }
  200.     }
  202.     /* 前面已经生成了一个2，这里再生成一个随机的2或者4，概率之比9:1 */
  203.     add_rand_num();
  205.     /* 在这里刷新界面并显示的时候，界面上已经默认出现了两个数字，其他的都为空（值为0） */
  206.     refresh_show();
  207. }
  209. /* 生成随机数 函数定义 */
  210. void add_rand_num() {
  211.     srand((unsigned int) time(0));
  212.     int n = rand() % get_null_count(); /* 确定在何处空位置生成随机数 */
  213.     int i;
  214.     for (i = 0; i < 4; ++i) {
  215.         int j;
  216.         for (j = 0; j < 4; ++j) {
  217.             /* 定位待生成的位置 */
  218.             if (board[i][j] == 0 && n-- == 0) {
  219.                 board[i][j] = (rand() % 10 ? 2 : 4); /* 生成数字2或4，生成概率为9:1 */
  220.                 return;
  221.             }
  222.         }
  223.     }
  224. }
  226. /* 获取空位置数量 函数定义 */
  227. int get_null_count() {
  228.     int n = 0;
  229.     int i;
  230.     for (i = 0; i < 4; ++i) {
  231.         int j;
  232.         for (j = 0; j < 4; ++j) {
  233.             board[i][j] == 0 ? ++n : 1;
  234.         }
  235.     }
  236.     return n;
  237. }
  239. /* 检查游戏是否结束 函数定义 */
  240. void check_game_over() {
  241.     int i;
  242.     for (i = 0; i < 4; ++i) {
  243.         int j;
  244.         for (j = 0; j < 3; ++j) {
  245.             /* 横向和纵向比较挨着的两个元素是否相等，若有相等则游戏不结束 */
  246.             if (board[i][j] == board[i][j + 1] || board[j][i] == board[j + 1][i]) {
  247.                 if_game_over = 0;
  248.                 return;
  249.             }
  250.         }
  251.     }
  252.     if_game_over = 1;
  253. }
  255. /*
  256. * 如下四个函数，实现上下左右移动时数字面板的变化算法
  257. * 左和右移动的本质一样，区别仅仅是列项的遍历方向相反
  258. * 上和下移动的本质一样，区别仅仅是行项的遍历方向相反
  259. * 左和上移动的本质也一样，区别仅仅是遍历时行和列互换
  260. */
  262. /*  左移 函数定义 */
  263. void move_left() {
  264.     /* 变量i用来遍历行项的下标，并且在移动时所有行相互独立，互不影响 */
  265.     int i;
  266.     for (i = 0; i < 4; ++i) {
  267.         /* 变量j为列下标，变量k为待比较（合并）项的下标，循环进入时k<j */
  268.         int j, k;
  269.         for (j = 1, k = 0; j < 4; ++j) {
  270.             if (board[i][j] > 0) /* 找出k后面第一个不为空的项，下标为j，之后分三种情况 */
  271.             {
  272.                 if (board[i][k] == board[i][j]) {
  273.                     /* 情况1：k项和j项相等，此时合并方块并计分 */
  274.                     score += board[i][k++] *= 2;
  275.                     board[i][j] = 0;
  276.                     if_need_add_num = 1; /* 需要生成随机数和刷新界面 */
  277.                 } else if (board[i][k] == 0) {
  278.                     /* 情况2：k项为空，则把j项赋值给k项，相当于j方块移动到k方块 */
  279.                     board[i][k] = board[i][j];
  280.                     board[i][j] = 0;
  281.                     if_need_add_num = 1;
  282.                 } else {
  283.                     /* 情况3：k项不为空，且和j项不相等，此时把j项赋值给k+1项，相当于移动到k+1的位置 */
  284.                     board[i][++k] = board[i][j];
  285.                     if (j != k) {
  286.                         /* 判断j项和k项是否原先就挨在一起，若不是则把j项赋值为空（值为0） */
  287.                         board[i][j] = 0;
  288.                         if_need_add_num = 1;
  289.                     }
  290.                 }
  291.             }
  292.         }
  293.     }
  294. }
  296. /* 右移 函数定义 */
  297. void move_right() {
  298.     /* 仿照左移操作，区别仅仅是j和k都反向遍历 */
  299.     int i;
  300.     for (i = 0; i < 4; ++i) {
  301.         int j, k;
  302.         for (j = 2, k = 3; j >= 0; --j) {
  303.             if (board[i][j] > 0) {
  304.                 if (board[i][k] == board[i][j]) {
  305.                     score += board[i][k--] *= 2;
  306.                     board[i][j] = 0;
  307.                     if_need_add_num = 1;
  308.                 } else if (board[i][k] == 0) {
  309.                     board[i][k] = board[i][j];
  310.                     board[i][j] = 0;
  311.                     if_need_add_num = 1;
  312.                 } else {
  313.                     board[i][--k] = board[i][j];
  314.                     if (j != k) {
  315.                         board[i][j] = 0;
  316.                         if_need_add_num = 1;
  317.                     }
  318.                 }
  319.             }
  320.         }
  321.     }
  322. }
  324. /* 上移 函数定义 */
  325. void move_up() {
  326.     /* 仿照左移操作，区别仅仅是行列互换后遍历 */
  327.     int i;
  328.     for (i = 0; i < 4; ++i) {
  329.         int j, k;
  330.         for (j = 1, k = 0; j < 4; ++j) {
  331.             if (board[j][i] > 0) {
  332.                 if (board[k][i] == board[j][i]) {
  333.                     score += board[k++][i] *= 2;
  334.                     board[j][i] = 0;
  335.                     if_need_add_num = 1;
  336.                 } else if (board[k][i] == 0) {
  337.                     board[k][i] = board[j][i];
  338.                     board[j][i] = 0;
  339.                     if_need_add_num = 1;
  340.                 } else {
  341.                     board[++k][i] = board[j][i];
  342.                     if (j != k) {
  343.                         board[j][i] = 0;
  344.                         if_need_add_num = 1;
  345.                     }
  346.                 }
  347.             }
  348.         }
  349.     }
  350. }
  352. /* 下移 函数定义 */
  353. void move_down() {
  354.     /* 仿照左移操作，区别仅仅是行列互换后遍历，且j和k都反向遍历 */
  355.     int i;
  356.     for (i = 0; i < 4; ++i) {
  357.         int j, k;
  358.         for (j = 2, k = 3; j >= 0; --j) {
  359.             if (board[j][i] > 0) {
  360.                 if (board[k][i] == board[j][i]) {
  361.                     score += board[k--][i] *= 2;
  362.                     board[j][i] = 0;
  363.                     if_need_add_num = 1;
  364.                 } else if (board[k][i] == 0) {
  365.                     board[k][i] = board[j][i];
  366.                     board[j][i] = 0;
  367.                     if_need_add_num = 1;
  368.                 } else {
  369.                     board[--k][i] = board[j][i];
  370.                     if (j != k) {
  371.                         board[j][i] = 0;
  372.                         if_need_add_num = 1;
  373.                     }
  374.                 }
  375.             }
  376.         }
  377.     }
  378. }
  380. /* 清屏 */
  381. void clear_screen() {
  382. #ifdef _WIN32
  383.     /* 重设光标输出位置清屏可以减少闪烁，system("cls")为备用清屏命令，均为Windows平台相关*/
  384.     COORD pos = {0, 0};
  385.     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
  386.     CONSOLE_CURSOR_INFO info = {1, 0};
  387.     SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
  388. #else
  389.     printf("\033c");     /* linux下的清屏命令 */
  390.     printf("\033[?25l"); /* linux下的隐藏输入光标 */
  391. #endif
  392. }
  394. /* 刷新界面 函数定义 */
  395. void refresh_show() {
  396.     clear_screen();
  398.     printf("\n\n\n\n");
  399.     printf("                  GAME: 2048     SCORE: %05d     BEST: %06d\n", score, best);
  400.     printf("               --------------------------------------------------");
  402.     /* 绘制方格和数字 */
  403.     printf("\n\n                             ┌────┬────┬────┬────┐\n");
  404.     int i;
  405.     for (i = 0; i < 4; ++i) {
  406.         printf("                             │");
  407.         int j;
  408.         for (j = 0; j < 4; ++j) {
  409.             if (board[i][j] != 0) {
  410.                 if (board[i][j] < 10) {
  411.                     printf("  %d │", board[i][j]);
  412.                 } else if (board[i][j] < 100) {
  413.                     printf(" %d │", board[i][j]);
  414.                 } else if (board[i][j] < 1000) {
  415.                     printf(" %d│", board[i][j]);
  416.                 } else if (board[i][j] < 10000) {
  417.                     printf("%4d│", board[i][j]);
  418.                 } else {
  419.                     int n = board[i][j];
  420.                     int k;
  421.                     for (k = 1; k < 20; ++k) {
  422.                         n = n >> 1;
  423.                         if (n == 1) {
  424.                             printf("2^%02d│", k); /* 超过四位的数字用2的幂形式表示，如2^13形式 */
  425.                             break;
  426.                         }
  427.                     }
  428.                 }
  429.             } else printf("    │");
  430.         }
  432.         if (i < 3) {
  433.             printf("\n                             ├────┼────┼────┼────┤\n");
  434.         } else {
  435.             printf("\n                             └────┴────┴────┴────┘\n");
  436.         }
  437.     }
  438.     printf("\n");
  439.     printf("               --------------------------------------------------\n");
  440.     printf("                  [W]:UP [S]:DOWN [A]:LEFT [D]:RIGHT [Q]:EXIT");
  442.     if (get_null_count() == 0) {
  443.         check_game_over();
  445.         /* 判断是否输掉游戏 */
  446.         if (if_game_over) {
  447.             printf("\r                      GAME OVER! TRY THE GAME AGAIN? [Y/N]:     \b\b\b\b");
  448. #ifdef _WIN32
  449.             CONSOLE_CURSOR_INFO info = {1, 1};
  450.             SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
  451. #else
  452.             printf("\033[?25h"); /* linux下的显示输入光标 */
  453. #endif
  454.         }
  455.     }
  457.     /* 判断是否准备退出游戏 */
  458.     if (if_prepare_exit) {
  459.         printf("\r                   DO YOU REALLY WANT TO QUIT THE GAME? [Y/N]:   \b\b");
  460. #ifdef _WIN32
  461.         CONSOLE_CURSOR_INFO info = {1, 1};
  462.             SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
  463. #else
  464.         printf("\033[?25h"); /* linux下的显示输入光标 */
  465. #endif
  466.     }
  468.     fflush(0); /* 刷新输出缓冲区 */
  469. }
  471. /* 初始化游戏 */
  472. void init_game() {
  473. #ifdef _WIN32
  474.     system("cls");
  476.     /* 获取游戏存档路径，Windows下放在C:\Users\UserName\AppData\Local\2048目录下 */
  477.     char m_lpszDefaultDir[MAX_PATH];
  478.     char szDocument[MAX_PATH] = {0};
  479.     memset(m_lpszDefaultDir, 0, _MAX_PATH);
  480.     LPITEMIDLIST pidl = NULL;
  481.     SHGetSpecialFolderLocation(NULL, CSIDL_LOCAL_APPDATA, &pidl);
  482.     if (pidl && SHGetPathFromIDList(pidl, szDocument)) {
  483.     GetShortPathName(szDocument, m_lpszDefaultDir, _MAX_PATH);
  484.     }
  485.     sprintf(config_path, "%s\\2048", m_lpszDefaultDir);
  486.     if (_access(config_path, 0) == -1) {
  487.     _mkdir(config_path);
  488.     }
  489.     sprintf(config_path, "%s\\2048\\2048.dat", m_lpszDefaultDir);
  490. #else
  491.     /* 获取游戏存档路径，Linux下放在当前用户主目录下 */
  492.     sprintf(config_path, "%s/.2048", getenv("HOME"));
  494.     tcgetattr(0, &old_config);              /* 获取终端属性 */
  495.     struct termios new_config = old_config; /* 创建新的终端属性 */
  496.     new_config.c_lflag &= ~ICANON;          /* 设置非正规模式 */
  497.     new_config.c_lflag &= ~ECHO;            /* 关闭输入回显 */
  498.     new_config.c_cc[VMIN] = 1;              /* 设置非正规模式下的最小字符数 */
  499.     new_config.c_cc[VTIME] = 0;             /* 设置非正规模式下的读延时 */
  500.     tcsetattr(0, TCSANOW, &new_config);     /* 设置新的终端属性 */
  502.     printf("\033[?25l");
  504.     signal(SIGINT, release_game);
  505. #endif
  507.     /* 读取游戏最高分数 */
  508.     FILE *fp = fopen(config_path, "r");
  509.     if (fp) {
  510.         fread(&best, sizeof(best), 1, fp);
  511.         fclose(fp);
  512.     } else {
  513.         best = 0;
  514.         fp = fopen(config_path, "w");
  515.         if (fp) {
  516.             fwrite(&best, sizeof(best), 1, fp);
  517.             fclose(fp);
  518.         }
  519.     }
  521.     reset_game();
  522. }
  524. /* 释放游戏 */
  525. void release_game(int signal) {
  526. #ifdef _WIN32
  527.     system("cls");
  528.     CONSOLE_CURSOR_INFO info = {1, 1};
  529.     SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
  530. #else
  531.     if (signal == SIGINT) {
  532.         printf("\n");
  533.     }
  534.     tcsetattr(0, TCSANOW, &old_config); /* 还原回旧的终端属性 */
  535.     printf("\033[?25h");
  536. #endif
  537.     exit(0);
  538. }
五、运行界面如下，仅供读者参考玩乐：
       其中，按方向键，或者w、s、a、d键为上、下、左、右移动，按q键为退出游戏。
   633203-20180801225242102-703620021.png
转载于:https://www.cnblogs.com/judgeyoung/p/3760515.html