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 <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <termios.h> //这个以及后面用到的请参考: https://www.cnblogs.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 <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <termios.h>
#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
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
