linux c 实现2048游戏_linux2048小游戏代码的每步解析

作者：AllinToyou | 2024-03-05 15:18:39

踩

linux2048小游戏代码的每步解析

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/191968