2048这个游戏相信大家应该都玩过，那么今天我在linux下用C语言实现一个2048游戏。

额。。实现完成后就长这个样子。

先来说一下游戏规则：

每次通过【I】向上移动、【K】向下移动、【J】向左移动、【L】向右移动，每移动一次，所有的数字都会往移动方向靠拢，然后在其余空白的地方出现一个数字，我这里只给出 2 ，相同数字的靠拢、相撞会相加。玩家要想办法在这个16个格子中凑出2048这个数字块，即过关。

其实这里说的是移动，但是没有真的在移动，只是每次用清屏函数清一下屏，然后重新打印出来。4 * 4的格子可以用二维数组来存这些数字，那么我就用一维数组了。

先说一下大致思路，然后讲解代码。用一个整型数组存16个格子中的数字，数组该开始全部初始化为0，那么我在打印这个格子的时候做了一些处理，当数组当中数字是0的时候，打印的时候如果是数字0则用%c打印，出来是空白。刚开始随机两个格子填充为2，就是上面图片那个样子。按上下左右移动时都会往按的方向移动，如果数字相同，就会合成一个更大的数字，如果不同就移动就可以了。举个例子：

向左移动

可以看到原来的两个2合成了一个4，然后又随机出来一个2。向左移动发生了什么呢？现在只看第3行，向左移动，从左向右看，首先看第一个，判断数组当中的数字是否为0？那么很明显不是0，又因为已经到最左边了，不需要移动，那么看第二个数字，为0不用管，第3个也是0不用管，第4个不是0，那么这个数字移动首先和第3个数字比较，因为第3个数字是0，说明这个格子空着，可以移动到这个格子，所以把第三个格子中的数字设置为第4个格子中的数字，然后把第4个格子中的数字设置为0，表示这块空了，此时完成一步操作，然后继续和第2个比较，发现第2个格子还是空白，说明可以移动，然后交换，然后继续向左走，这时候第1个和第2个都有数字，那么看这两个数字相等吗？如果相等，进行合并，如果不相等 就不用移动了，也不需要合并，那么现在的情况是两个2是相等的，那么需要合并，因为是向左移动，所以把第1个格子中的数字乘以2，把第2个格子中的数字设置为0。此时完成一行的移动和合并操作，其余三行是一样的道理，并且上下左右也一样，只是方向不同。现在我把这个移动合并的动作分解为三步，第一次做移动操作，但是不合并数字，只是把数字中间的空白去除，第二次做合并操作，把相同数字合并，那么这时候就又会产生空白，那么第三步，再做一次移动操作就把空白去掉了。我画图解释一下：

这个就是第一步，移动，目的把空白去掉，不管数字是否相同全部移动到一边。然后做第二步合并：

可以看到此时合并过后又会产生空白，就是那个红圈圈，然后再做第三步，移动清除空白：

那么最后这个结果就是正确结果。下来通过代码讲解：#include

#include

#include

#include //这个以及后面用到的请参考: https://www..com/zhouyinhui/archive/2010/10/12/1849011.html

#define SIZE 16

#define UP 0x69 // 小写 i

#define UP_B 0x49 // 大写 I

#define DOWN 0x6b // 小写 k

#define DOWN_B 0x4b // 大写 K

#define RIGHT 0x6c // 小写 l

#define RIGHT_B 0x4c // 大写 L

#define LEFT 0x6a // 小写 j

#define LEFT_B 0x4a // 大写 J

int arr[SIZE] = {0};

int is_move = 0; // 这个标志是判断是否有移动过没有

int is_merge = 0; // 这个标志是判断是否有合并过没有

int max; // 当前最大数字

int total; // 统计总分数

static struct termios oldt;

void restore_terminal_settings(void)

{

tcsetattr(0, TCSANOW, &oldt);

}

void disable_terminal_return(void)

{

struct termios newt;

tcgetattr(0, &oldt);

newt = oldt;

newt.c_lflag &= ~(ICANON | ECHO);

tcsetattr(0, TCSANOW, &newt);

atexit(restore_terminal_settings);

}

//初始化数组，产生两个不同的随机数，从0-15产生，对应数组下标，然后把该下标数组的值设置为2

void init(void)

{

int i, random1, random2;

random1 = rand() % SIZE;

for(i = 0; i < 1; i++)

{

random2 = rand() % SIZE;

if(random1 == random2)

{

i--;

}

}

arr[random1] = 2;

arr[random2] = 2;

}

//判断是否不能移动并且合并，就是game over了

int is_dead()

{

int i, j;

for(i = 0; i < SIZE; i++)

{

if(!arr[i]) //如果数组当中还有0，说明还能移动，返回0，说明游戏还没结束呢

{

return 0;

}

}

//到这里说明，的确在一个方向不能移动了，但是，有可能换个方向还可以移动，所以能到这里说明，16个格子全部有数字，都不为0，接下来判断4行，4列

//每相邻两个数字,是否有相同的如果有说明通过移动还可以动，这时候还没死呢

for(i = 0; i < SIZE; i += 4)

{

for(j = i; j < i + 3; j++)

{

if(arr[j] == arr[j + 1]) //这里就是判断4行，一行一行看，每相邻两个格子如果数字有相同的，return 0，说明游戏还可以继续

{

return 0;

}

}

}

for(i = 0; i < 4; i++)

{

for(j = i; j < i + 12; j += 4)

{

if(arr[j] == arr[j + 4]) //这里判断4列，一列一列看，每相邻两个格子如果有数字相同的，return 0，说明游戏还可以继续

{

return 0;

}

}

}

return 1; // 能到这里，说明16个格子全部都有数字，都不为0，而且各个方向无论怎么移动都不能合并，那么游戏结束game over，return 1

}

// 这个函数返回当前最大的数字

int max_num(void)

{

int i;

static int count = 0;

for(i = 0; i < SIZE; i++)

{

if(arr[i] > max)

{

max = arr[i]; //找最大数

}

}

if(!count && 2048 == max) //判断如果最大数==2048，过关，按任意键继续玩

{

count++;

printf("恭喜过关，请按任意键继续！");

getchar();

}

return max;

}

//这个函数，负责每次打印图形，每次移动操作都会修改数组，改一次，打印一次

void print_game(void)

{

system("clear");

int i;

printf("按【I】向上移动\n按【K】向下移动\n按【J】向左移动\n按【L】向右移动\n按【Ctrl + Z】退出游戏\n最大的数是：%d\n总分是：%d\n", max_num(), total);

printf("\n");

printf("+------------- 2048 --------------+\n");

printf("+-----------------------------------+\n");

printf("| | | | |\n");

for(i = 0; i < SIZE; i++)

{

if(0 == i || 4 == i || 8 == i || 12 == i)

{

printf("|");

}

printf(0 == arr[i] ? "%9c|" : "%8d|", arr[i]); //这里有个对数组中数字0的处理，如果是0 ， 那么按%c格式打印是空白，好看些

if(3 == i || 7 == i || 11 == i)

{

printf("\n");

printf("|--------+--------+--------+--------|\n");

printf("| | | | |\n");

}

}

printf("\n");

printf("+-----------------------------------+\n");

printf("+------------ by chenxin -----------+\n");

printf("\n\n\n");

if(is_dead()) //如果能进这个if，说明game over，然后按任意键重新玩，

{

int i;

printf("game over!\n");

printf("请按任意键重新开始！\n");

getchar();

for(i = 0; i < SIZE; i++) //数组清0

{

arr[i] = 0;

}

init(); //重新初始化

print_game();

}

}

//这个函数是每次移动这个动作完成时，在剩下的格子中产生一个随机数字，对应数组下标，然后把该下标数组值设置为2，即每次移动完在剩下空白的地方出现一个2

void rand_num(void)

{

while(is_move || is_merge) //如果可以移动，或者可以合并，那么才能产生数字，

{

int random = rand() % SIZE;

if(!arr[random]) //这个就是保证产生的随机数是空白中的，已经格子中已经有的就不行，重新产生

{

arr[random] = 2;

break;

}

}

is_move = 0;

is_merge = 0;

}

//移动的主要函数，最重要的地方，这个函数接收三个参数，loop_count，需要循环的次数，current_i，当前移动的元素数组下标，

//direction这个是因为有上下左右四个方向，比如当前元素是 arr[5],那么它左边的格子就是arr[5-1],右边就是arr[5+1],

//上边就是arr[5-4],下边就是arr[5+4],这里的 1，-1,4，-4就是direction，就是把四个方向的函数提取出相同的部分，公用这一个移动方法，用direction区分方向

//移动是被move_up ...等等这些函数调用的，所以请先去看move_up ...等等函数的作用

//先说一下，move_up_pre这个函数结合了移动、合并，这个函数调用了move_up这个函数，而move_up 又会调用move_go这个函数，所以先去看move_up_pre函数是干啥的

//OK，从move_up 这个函数过来了，那么我举个例子吧：

//比如现在当前的i是5 ，即第二行第2个数字2，需要向上移动，那么它的循环次数是1次，direction=-4，说明它上面的那个数字下标比当前这个小4

//if(arr[current_i] && !arr[current_i + direction]) 如果当前这个数字不为0，并且它上面的那个数字为0那么就可以向上移动

void move_go(int loop_count, int current_i, int direction)

{

int i;

for(i = 0; i < loop_count; i++)

{

if(arr[current_i] && !arr[current_i + direction])

{

arr[current_i + direction] = arr[current_i]; //把它上面那个数字改成当前这个数字，

arr[current_i] = 0; //把当前这个数字改成0

current_i += direction; //再把当前的current_i ,-4,继续看它上面是什么情况，能移动就移动不能移动就算了

is_move = 1; //能进来说明能移动，所以把标志 是否能移动 设置为1

}

}

}

//OK这个函数完了，就完成了一次单纯的移动操作，那么向左，向右，向下一个道理，我就不说了，下来去看move_up_pre函数去

//好OK，这个函数就是负责向上移动，不用管数字是否相同还是不同，全部一个顶一个一个顶一个移动到一个方向

void move_up(void)

{

// loop_count循环次数，为啥会有这个变量，因为向上移动有的数字需要移动一次，有的需要移动2,3次，而最上边的数字则不需要移动所以，

//loop_count控制循环次数，direction，控制方向，向上移动所以是以从下往上的角度看的，那么direction=-4，意思就是上一个元素的下标比当前元素小4

//所以是-4.

int i, loop_count, direction;

for(i = 0; i < SIZE; i++)

{

if(arr[i]) //移动时，如果这个格子的数字不为0才移动，为0的话不用管了，能进到这个if说明当前要移动的数字不为0，也就是不是空白，空白不需要移动

{

loop_count = i / 4;

//计算循环次数，0 1 2 3，是最上层的数字不用移动，所以i /4=0,不用移动，第二行4,5,6,7，最多需要移动1次，i/4=1,依次类推

direction = -4;

//把当前格子中的数组下标，需要循环的次数，还有方向传给move_go 这个函数，接下来去看move_go 这个函数

move_go(loop_count, i, direction);

}

}

}

void move_down(void)

{

int i, loop_count, direction;

for(i = SIZE - 1; i >= 0; i--)

{

if(arr[i])

{

loop_count = (4 - 1) - i / 4;

direction = 4;

move_go(loop_count, i, direction);

}

}

}

void move_right(void)

{

int i, loop_count, direction;

for(i = SIZE - 1; i >= 0; i--)

{

if(arr[i])

{

loop_count = (4 - 1) - (i + 4) % 4;

direction = 1;

move_go(loop_count, i, direction);

}

}

}

void move_left(void)

{

int i, loop_count, direction;

for(i = 0; i < SIZE; i++)

{

if(arr[i])

{

loop_count = (i + 4) % 4;

direction = -1;

move_go(loop_count, i, direction);

}

}

}

//合并函数，只负责一次合并，把接收当前数字下标，把它上或者下或者左或者右的格子合并一个

void merge(int current_i, int direction)

{

//如果当前这个格子和它四个方向相邻的格子都不为0时并且，这两个数字相等时才进行合并操作

if(arr[current_i] && arr[current_i + direction] && arr[current_i] == arr[current_i + direction])

{

arr[current_i] = arr[current_i + direction] * 2;

total += arr[current_i];

arr[current_i + direction] = 0;

is_merge = 1;

}

}

//这个就是我之前说的分三步，第一步移动清楚空白，第二步合并，第三步移动清楚空白完成一次移动合并操作，下来我仔细讲一下

void move_up_pre(void)

{

move_up(); //先调用移动方法去除空白，那么先去move_up 看这个函数是干啥的，OK看完move_up 函数，再往下看

// 两个move_up 中间夹着的就是合并的动作，同样merge合并的这个函数也是接收一个direction参数，四个方向的合并公用一个方法

// 继续上面的向上移动上去的那个接着画个图

//那么合并操作完成，应该是这个样子，粉色的2其实已经合并了，是不存在的我先放在那里，是想说明我的合并方法会产生空白，所以需要再做一遍移动操作

//向上合并，那么我从上往下看，现在先看第一行的第一个数字，当然如果没有数字那就不合并了，现在假设都有数字

//和它下面的数字比较，就是竖着往下走，如果相同，把第一个数字乘2，第二个数字设置为0 ，然后看第二个数字

//和第三个数字，那么这会其实没必要比较第二个和第三个，直接去比较第三个和第第四个就行了，但是

//我不想分情况了，就直接往下比较吧，白做一次比较，然后就这样依次往后比较

int i, j, direction = 4; //合并是从上往下看，所以direction=4，即它下面的那个格子数组下标比当前这个大4

for(i = 0; i < 4; i++)

// 这里的i从0 到3 ，即0,1,2,3，控制列数，即0开头的那一列，1开头的那一列，以此类推

{

for(j = i; j < i + 12; j += 4)

// 当i=0时,j 是0,4,8，当i=1时，j是1,5,9以此类推,传给merge进行合并，关于下、左、右合并道理类似，我就不说了

{

merge(j, direction);

}

}

move_up();

}

void move_down_pre(void)

{

move_down();

int i, j, direction = -4;

for(i = 4 - 1; i >= 0; i--)

{

for(j = i + 12; j >= 4; j -= 4)

{

merge(j, direction);

}

}

move_down();

}

void move_right_pre(void)

{

move_right();

int i, j, direction = -1;

for(i = 4 - 1; i >= 0; i--)

{

for(j = 4 * i + 3; j > 4 * i; j--)

{

merge(j, direction);

}

}

move_right();

}

void move_left_pre(void)

{

move_left();

int i, j, direction = 1;

for(i = 0; i <= 3; i++)

{

for(j = 4 * i; j < 4 * i + 3; j++)

{

merge(j, direction);

}

}

move_left();

}

int main(void)

{

srand(time(NULL));

init();

print_game();

disable_terminal_return();

while(1)

{

switch(getchar())

{

case UP:

case UP_B:

move_up_pre();

rand_num();

print_game();

break;

case DOWN:

case DOWN_B:

move_down_pre();

rand_num();

print_game();

break;

case RIGHT:

case RIGHT_B:

move_right_pre();

rand_num();

print_game();

break;

case LEFT:

case LEFT_B:

move_left_pre();

rand_num();

print_game();

break;

default:

break;

}

}

return 0;

}

下面附上没有注释的完成代码：#include

#include

#include

#include

#define SIZE 16

#define UP 0x69

#define UP_B 0x49

#define DOWN 0x6b

#define DOWN_B 0x4b

#define RIGHT 0x6c

#define RIGHT_B 0x4c

#define LEFT 0x6a

#define LEFT_B 0x4a

int arr[SIZE] = {0};

int is_move = 0;

int is_merge = 0;

int max;

int total;

static struct termios oldt;

void restore_terminal_settings(void)

{

tcsetattr(0, TCSANOW, &oldt);

}

void disable_terminal_return(void)

{

struct termios newt;

tcgetattr(0, &oldt);

newt = oldt;

newt.c_lflag &= ~(ICANON | ECHO);

tcsetattr(0, TCSANOW, &newt);

atexit(restore_terminal_settings);

}

void init(void)

{

int i, random1, random2;

random1 = rand() % SIZE;

for(i = 0; i < 1; i++)

{

random2 = rand() % SIZE;

if(random1 == random2)

{

i--;

}

}

arr[random1] = 2;

arr[random2] = 2;

}

int is_dead()

{

int i, j;

for(i = 0; i < SIZE; i++)

{

if(!arr[i])

{

return 0;

}

}

for(i = 0; i < SIZE; i += 4)

{

for(j = i; j < i + 3; j++)

{

if(arr[j] == arr[j + 1])

{

return 0;

}

}

}

for(i = 0; i < 4; i++)

{

for(j = i; j < i + 12; j += 4)

{

if(arr[j] == arr[j + 4])

{

return 0;

}

}

}

return 1;

}

int max_num(void)

{

int i;

static int count = 0;

for(i = 0; i < SIZE; i++)

{

if(arr[i] > max)

{

max = arr[i];

}

}

if(!count && 2048 == max)

{

count++;

printf("恭喜过关，请按任意键继续！");

getchar();

}

return max;

}

void print_game(void)

{

system("clear");

int i;

printf("按【I】向上移动\n按【K】向下移动\n按【J】向左移动\n按【L】向右移动\n按【Ctrl + Z】退出游戏\n最大的数是：%d\n总分是：%d\n", max_num(), total);

printf("\n");

printf("+------------- 2048 --------------+\n");

printf("+-----------------------------------+\n");

printf("| | | | |\n");

for(i = 0; i < SIZE; i++)

{

if(0 == i || 4 == i || 8 == i || 12 == i)

{

printf("|");

}

printf(0 == arr[i] ? "%9c|" : "%8d|", arr[i]);

if(3 == i || 7 == i || 11 == i)

{

printf("\n");

printf("|--------+--------+--------+--------|\n");

printf("| | | | |\n");

}

}

printf("\n");

printf("+-----------------------------------+\n");

printf("+------------ by chenxin -----------+\n");

printf("\n\n\n");

if(is_dead())

{

int i;

printf("game over!\n");

printf("请按任意键重新开始！\n");

getchar();

for(i = 0; i < SIZE; i++)

{

arr[i] = 0;

}

init();

print_game();

}

}

void rand_num(void)

{

while(is_move || is_merge)

{

int random = rand() % SIZE;

if(!arr[random])

{

arr[random] = 2;

break;

}

}

is_move = 0;

is_merge = 0;

}

void move_go(int loop_count, int current_i, int direction)

{

int i;

for(i = 0; i < loop_count; i++)

{

if(arr[current_i] && !arr[current_i + direction])

{

arr[current_i + direction] = arr[current_i];

arr[current_i] = 0;

current_i += direction;

is_move = 1;

}

}

}

void move_up(void)

{

int i, loop_count, direction;

for(i = 0; i < SIZE; i++)

{

if(arr[i])

{

loop_count = i / 4;

direction = -4;

move_go(loop_count, i, direction);

}

}

}

void move_down(void)

{

int i, loop_count, direction;

for(i = SIZE - 1; i >= 0; i--)

{

if(arr[i])

{

loop_count = (4 - 1) - i / 4;

direction = 4;

move_go(loop_count, i, direction);

}

}

}

void move_right(void)

{

int i, loop_count, direction;

for(i = SIZE - 1; i >= 0; i--)

{

if(arr[i])

{

loop_count = (4 - 1) - (i + 4) % 4;

direction = 1;

move_go(loop_count, i, direction);

}

}

}

void move_left(void)

{

int i, loop_count, direction;

for(i = 0; i < SIZE; i++)

{

if(arr[i])

{

loop_count = (i + 4) % 4;

direction = -1;

move_go(loop_count, i, direction);

}

}

}

void merge(int current_i, int direction)

{

if(arr[current_i] && arr[current_i + direction] && arr[current_i] == arr[current_i + direction])

{

arr[current_i] = arr[current_i + direction] * 2;

total += arr[current_i];

arr[current_i + direction] = 0;

//current_i += direction;

is_merge = 1;

}

}

void move_up_pre(void)

{

move_up();

int i, j, direction = 4;

for(i = 0; i < 4; i++)

{

for(j = i; j < i + 12; j += 4)

{

merge(j, direction);

}

}

move_up();

}

void move_down_pre(void)

{

move_down();

int i, j, direction = -4;

for(i = 4 - 1; i >= 0; i--)

{

for(j = i + 12; j >= 4; j -= 4)

{

merge(j, direction);

}

}

move_down();

}

void move_right_pre(void)

{

move_right();

int i, j, direction = -1;

for(i = 4 - 1; i >= 0; i--)

{

for(j = 4 * i + 3; j > 4 * i; j--)

{

merge(j, direction);

}

}

move_right();

}

void move_left_pre(void)

{

move_left();

int i, j, direction = 1;

for(i = 0; i <= 3; i++)

{

for(j = 4 * i; j < 4 * i + 3; j++)

{

merge(j, direction);

}

}

move_left();

}

int main(void)

{

srand(time(NULL));

init();

print_game();

disable_terminal_return();

while(1)

{

switch(getchar())

{

case UP:

case UP_B:

move_up_pre();

rand_num();

print_game();

break;

case DOWN:

case DOWN_B:

move_down_pre();

rand_num();

print_game();

break;

case RIGHT:

case RIGHT_B:

move_right_pre();

rand_num();

print_game();

break;

case LEFT:

case LEFT_B:

move_left_pre();

rand_num();

print_game();

break;

default:

break;

}

}

return 0;

}

如果有任何问题，欢迎妹子打扰，男的就算了。

QQ：353120194