遊戲2048源代碼 - C語言控制檯界面版

〇、前言

     本文最初是在2014年發表的，當時只是Windows版本的，前段時間有位讀者給我發郵件諮詢Linux下版本移植問題，因而便花時間支持了Linux下的版本，並修改完善了代碼，加入記錄最高分的功能，供讀者參考學習。

1、遊戲介紹

     所謂《2048》是最近比較流行的一款數字遊戲。原版2048首先在github上發佈，原做者是Gabriele Cirulli。它是基於《1024》和《小3傳奇》（Threes!）的玩法開發而成的新型數字遊戲。

2、遊戲規則

     遊戲的規則很簡單，你須要控制全部方塊向同一個方向運動，兩個相同數字的方塊撞在一塊兒以後合併成爲他們的和，每次操做以後會在空白的方格處隨機生成一個2或者4（生成2的機率要大一些），最終獲得一個「2048」的方塊就算勝利了。

3、核心算法

一、方塊的移動和合並

     主要思想：把遊戲數字面板抽象成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的例子，流程表示以下：

   

     一行內移動合併算法描述以下（此例爲左移狀況，其餘方向與之相似，區別僅僅是遍歷二維數組的行項和列項的方式）：

 1 int j, k;
 2 for (j = 1, k = 0; j < 4; j++) {
 3     if (b[j] > 0) { /* 找出k後面第一個不爲空的項，下標爲j，以後分三種狀況 */
 4         if (b[k] == b[j]) { /* P1狀況，合併 */
 5             b[k] = 2 * b[k];
 6             b[j] = 0;
 7             k = k + 1;
 8         } else if (b[k] == 0) { /* P2狀況，移動 */
 9             b[k] = b[j];
10             b[j] = 0;
11         } else { /* P3狀況，碰撞 */
12             b[k + 1] = b[j];
13             if (j != k + 1) { /* 原先兩數不挨着 */
14                 b[j] = 0;
15             }
16             k = k + 1;
17         }
18     }
19 }

二、判斷遊戲是否結束

     核心思想：遍歷二維數組，看是否存在橫向和縱向兩個相鄰的元素相等，若存在，則遊戲不結束，若不存在，則遊戲結束。

     算法代碼描述以下（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 }

三、生成隨機數

     核心思想：根據生成的隨機數，對必定的值進行取模，達到生成必定機率的數。在本遊戲中，設定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 }

四、繪製界面

     核心思想：利用系統提供的控制檯界面清屏功能，達到刷新界面的效果，利用控制製表符位置，達到繪製遊戲數字面板的效果。

     因爲繪製界面不算是本遊戲的本質，且代碼段相對較長，因此算法描述在這裏省略，讀者能夠參考完整源代碼。

五、計算得分

     核心思想：兩塊帶數字的方格合併後的數字爲合併的得分，一次上下左右移動後遊戲面板上全部合併的得分總和爲一次移動的得分，屢次移動的得分進行累加做爲當前總得分。

     若是當前總得分（SCORE）超過最高分（BEST），則最高分被改寫爲當前總得分，並存儲下來，下次啓動遊戲時會自動載入本機存儲的最高分。

4、完整源代碼以下，敬請讀者批評指正：

  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 */
  7 
  8 #include <time.h>   /* 包含設定隨機數種子所須要的time()函數 */
  9 #include <stdio.h>  /* 包含C的IO讀寫功能 */
 10 #include <stdlib.h> /* 包含C標準庫的功能 */
 11 
 12 #ifdef _WIN32
 13 
 14 /* 包含Windows平臺相關函數，包括控制檯界面清屏及光標設定等功能 */
 15 #include <conio.h>
 16 #include <windows.h>
 17 #include <io.h>
 18 #include <direct.h>
 19 #include <Shlobj.h>
 20 
 21 #else
 22 
 23 /* 包含Linux平臺相關函數，包括控制檯界面清屏及光標設定等功能 */
 24 #include <termio.h>
 25 #include <unistd.h>
 26 #include <bits/signum.h>
 27 #include <signal.h>
 28 
 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
 34 
 35 struct termios old_config; /* linux下終端屬性配置備份 */
 36 
 37 #endif
 38 
 39 static char config_path[4096] = {0}; /* 配置文件路徑 */
 40 
 41 static void init_game();    /* 初始化遊戲 */
 42 static void loop_game();    /* 遊戲循環 */
 43 static void reset_game();   /* 重置遊戲 */
 44 static void release_game(int signal); /* 釋放遊戲 */
 45 
 46 static int read_keyboard();
 47 
 48 static void move_left();  /* 左移 */
 49 static void move_right(); /* 右移 */
 50 static void move_up();    /* 上移 */
 51 static void move_down();  /* 下移 */
 52 
 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();    /* 刷新界面顯示 */
 58 
 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表示否 */
 65 
 66 /* main函數 函數定義 */
 67 int main(int argc, char *argv[]) {
 68     init_game();
 69     loop_game();
 70     release_game(0);
 71     return 0;
 72 }
 73 
 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 }
 86 
 87 /* 開始遊戲 函數定義 */
 88 void loop_game() {
 89     while (1) {
 90         int cmd = read_keyboard(); /* 接收標準輸入流字符命令 */
 91 
 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         }
107 
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         }
122 
123         if_need_add_num = 0; /* 先設定不默認須要生成隨機數，須要時再設定爲1 */
124 
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         }
174 
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 }
184 
185 /* 重置遊戲 函數定義 */
186 void reset_game() {
187     score = 0;
188     if_need_add_num = 1;
189     if_game_over = 0;
190     if_prepare_exit = 0;
191 
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     }
201 
202     /* 前面已經生成了一個2，這裏再生成一個隨機的2或者4，機率之比9:1 */
203     add_rand_num();
204 
205     /* 在這裏刷新界面並顯示的時候，界面上已經默認出現了兩個數字，其餘的都爲空（值爲0） */
206     refresh_show();
207 }
208 
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 }
225 
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 }
238 
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 }
254 
255 /*
256  * 以下四個函數，實現上下左右移動時數字面板的變化算法
257  * 左和右移動的本質同樣，區別僅僅是列項的遍歷方向相反
258  * 上和下移動的本質同樣，區別僅僅是行項的遍歷方向相反
259  * 左和上移動的本質也同樣，區別僅僅是遍歷時行和列互換
260 */
261 
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 }
295 
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 }
323 
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 }
351 
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 }
379 
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 }
393 
394 /* 刷新界面 函數定義 */
395 void refresh_show() {
396     clear_screen();
397 
398     printf("\n\n\n\n");
399     printf("                  GAME: 2048     SCORE: %05d     BEST: %06d\n", score, best);
400     printf("               --------------------------------------------------");
401 
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         }
431 
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");
441 
442     if (get_null_count() == 0) {
443         check_game_over();
444 
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     }
456 
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     }
467 
468     fflush(0); /* 刷新輸出緩衝區 */
469 }
470 
471 /* 初始化遊戲 */
472 void init_game() {
473 #ifdef _WIN32
474     system("cls");
475 
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"));
493 
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);     /* 設置新的終端屬性 */
501 
502     printf("\033[?25l");
503 
504     signal(SIGINT, release_game);
505 #endif
506 
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     }
520 
521     reset_game();
522 }
523 
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 }

5、運行界面以下，僅供讀者參考玩樂：

     其中，按方向鍵，或者w、s、a、d鍵爲上、下、左、右移動，按q鍵爲退出遊戲。

6、版本移植問題

     在本文中的源代碼是Windows系統的版本，但遊戲的核心算法不管在那個系統上都是同樣的，區別僅僅是界面繪製刷新的實現部分可能存在差別。好比在Linux上的getch()函數有回顯，因此可能會須要更好的命令輸入邏輯，並且conio.h並不屬於C標準庫中，因此在Linux下引用不到此頭文件，而Linux下getch()函數存在於curses.h頭文件中，因此須要更改頭文件。還有，在本文源代碼中關於清屏的代碼在Linux下失效，因此若想移植須要修改清屏邏輯，達到刷新界面的邏輯，好比調用Linux下的清屏命令system("clear")，效果如何，讀者能夠試試。

7、版本移植

     當前最新版本已經支持Windows和Linux雙系統下編譯運行了，讀者能夠下載源碼參考學習，給出意見建議，而後編譯運行，順便挑戰一下最高分～