游戏2048源代码 - C语言控制台界面版

〇、前言

     本文最初是在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的例子,流程表示如下:

   

     一行内移动合并算法描述如下(此例为左移情况,其他方向与之类似,区别仅仅是遍历二维数组的行项和列项的方式):

 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 }

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 */
  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 }

五、运行界面如下,仅供读者参考玩乐:

     其中,按方向键,或者w、s、a、d键为上、下、左、右移动,按q键为退出游戏。

六、版本移植问题

     在本文中的源代码是Windows系统的版本,但游戏的核心算法无论在那个系统上都是一样的,区别仅仅是界面绘制刷新的实现部分可能存在差异。比如在Linux上的getch()函数有回显,所以可能会需要更好的命令输入逻辑,而且conio.h并不属于C标准库中,所以在Linux下引用不到此头文件,而Linux下getch()函数存在于curses.h头文件中,所以需要更改头文件。还有,在本文源代码中关于清屏的代码在Linux下失效,所以若想移植需要修改清屏逻辑,达到刷新界面的逻辑,比如调用Linux下的清屏命令system("clear"),效果如何,读者可以试试。

七、版本移植

     当前最新版本已经支持Windows和Linux双系统下编译运行了,读者可以下载源码参考学习,给出意见建议,然后编译运行,顺便挑战一下最高分~

posted @ 2014-05-30 09:47  Judge Young  阅读(50842)  评论(14编辑  收藏  举报