2048%E7%9A%84%E6%B8%B8%E6%88%8F%E9%80%BB%E8%BE%91%E4%B8%8E%E9%A2%84%E8%A7%88%E5%9B%BE

2048游戏的基本规则是：玩家需要通过上、下、左、右四个方向滑动屏幕来移动方块，每次移动都会随机位置生成一个数字2到空闲的位置上。当两个相同数字的方块碰撞时，它们会合并成一个数字。游戏的目标是在屏幕上生成一个2048的方块

游戏开始时创建两个随机数以及后面的按键触发后空位置产生随机数

为有数字的格子添加该数字的贴图(待实现)

%E6%9E%84%E9%80%A0%E6%95%B0%E7%BB%84%E5%92%8C%E6%B8%B8%E6%88%8F%E5%BC%80%E5%A7%8B%E6%97%B6%E9%9A%8F%E6%9C%BA%E6%95%B0

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdbool.h>
#include<conio.h>
int main() {
	int a[4][4] = { 0 };
    // 初始化随机数生成器
    srand((unsigned)time(NULL));

    // 生成0到4之间的随机数
    printf("这是一个简单的2048游戏\n");
    printf("输入a向左移动，输入d向右移动，输入s向下移动，输入w向上移动\n");
    int stk = 0;
    while (stk < 2) {
        int x = rand() % 4;
        int y = rand() % 4;
        if (a[x][y] == 0) {
            a[x][y] = 2;
            stk++;
        }
    }
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    return 0;
    }

%E6%8E%A5%E4%B8%8B%E6%9D%A5%E7%9A%84%E6%80%9D%E8%B7%AF

写一个检测移动的函数，根据键盘的输入进行上下左右的移动

每次移动完加入随机数在空闲位置，并且输出一次矩阵图

%E6%A3%80%E6%B5%8B%E7%A7%BB%E5%8A%A8%E7%9A%84%E5%87%BD%E6%95%B0

bool moveG(int view[4][4], char ch,bool *endflag) {
    bool flag = false;
    switch (ch)
    {
    case 'w': {
        for (int y = 0; y < 4; y++)
        {
            //判断截止符 ,避免2222变成8000而不是4400
            int end = 0;
            //迭代
            for (int x = 1; x < 4; x++)
            {
                for (int i = x; i > end; i--)
                {
                    //view[i][y]>0才进行是否移动或者合并判断
                    if (view[i][y])
                    {
                        if (0 == view[i - 1][y])
                        {
                            // 移动
                            view[i - 1][y] = view[i][y];
                            view[i][y] = 0;
                            flag = true;
                        }
                        else if (view[i][y] == view[i - 1][y])
                        {
                            //	合并
                            view[i - 1][y] *= 2;
                            if (view[i - 1][y] == 2048) {
                                *endflag = true;
                            }
                            view[i][y] = 0;
                            //在合并的位置截止，后面的每次判断就到此为止
                            end = i;
                            flag = true;
                        }
                    }
                }
            }
        }
        break;
    }
    case 's': {
        for (int y = 0; y < 4; y++)
        {
            int end = 4;
            for (int x = 3; x > 0; x--)
            {
                for (int i = x; i < end; i++)
                {
                    if (view[i - 1][y])
                    {
                        if (0 == view[i][y])
                        {
                            // 移动
                            view[i][y] = view[i - 1][y];
                            view[i - 1][y] = 0;
                            flag = true;
                        }
                        else if (view[i - 1][y] == view[i][y])
                        {
                            //  合并
                            view[i][y] *= 2;
                            if (view[i][y] == 2048) {
                                *endflag = true;
                            }
                            view[i - 1][y] = 0;
                            end = i - 1;
                            flag = true;
                        }
                    }
                }
            }
        }
        break;
    }
    case 'a': {

        for (int x = 0; x < 4; x++)
        {
            int end = 0;
            for (int y = 1; y < 4; y++)
            {
                for (int i = y; i > end; i--)
                {
                    if (view[x][i])
                    {
                        if (0 == view[x][i - 1])
                        {
                            // 移动
                            view[x][i - 1] = view[x][i];
                            view[x][i] = 0;
                            flag = true;
                        }
                        else if (view[x][i] == view[x][i - 1])
                        {
                            //  合并
                            view[x][i - 1] *= 2;
                            if (view[x][i - 1]==2048) {
                                *endflag = true;
                            }
                            view[x][i] = 0;
                            end = i;
                            //score += view[x][i - 1];
                            flag = true;
                        }
                    }
                }
            }
        }
        break;
    }
    case 'd': {


        for (int x = 0; x < 4; x++)
        {
            int end = 4;
            for (int y = 3; y > 0; y--)
            {
                for (int i = y; i < end; i++)
                {
                    if (view[x][i - 1])
                    {
                        if (0 == view[x][i])
                        {
                            // 移动
                            view[x][i] = view[x][i - 1];
                            view[x][i - 1] = 0;
                            flag = true;
                        }
                        else if (view[x][i - 1] == view[x][i])
                        {
                            //  合并
                            view[x][i] *= 2;
                            if (view[x][i] == 2048) {
                                *endflag = true;
                            }
                            view[x][i - 1] = 0;
                            end = i - 1;
                            flag = true;
                        }
                    }
                }
            }
        }
            break;
        }
    default:
        break;
    }
    }

%E7%A7%BB%E5%8A%A8%E5%90%8E%E7%9A%84%E6%8F%92%E5%85%A5

        bool flag = moveG(a, move,&endflag);

        int x = rand() % 4;
        int y = rand() % 4;
        int isAdd = 0;
        while((move=='a' || move == 'd' || move == 'w' || move == 's') && a[x][y] == 0 && isAdd == 0) {
            a[x][y] = 2;
            isAdd = 1;
        }
        isAdd = 0;

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdbool.h>
#include<conio.h>

//    . y
//   x

bool moveG(int view[4][4], char ch,bool *endflag) {
    bool flag = false;
    switch (ch)
    {
    case 'w': {
        for (int y = 0; y < 4; y++)
        {
            //判断截止符 ,避免2222变成8000而不是4400
            int end = 0;
            //迭代
            for (int x = 1; x < 4; x++)
            {
                for (int i = x; i > end; i--)
                {
                    //view[i][y]>0才进行是否移动或者合并判断
                    if (view[i][y])
                    {
                        if (0 == view[i - 1][y])
                        {
                            // 移动
                            view[i - 1][y] = view[i][y];
                            view[i][y] = 0;
                            flag = true;
                        }
                        else if (view[i][y] == view[i - 1][y])
                        {
                            //	合并
                            view[i - 1][y] *= 2;
                            if (view[i - 1][y] == 2048) {
                                *endflag = true;
                            }
                            view[i][y] = 0;
                            //在合并的位置截止，后面的每次判断就到此为止
                            end = i;
                            flag = true;
                        }
                    }
                }
            }
        }
        break;
    }
    case 's': {
        for (int y = 0; y < 4; y++)
        {
            int end = 4;
            for (int x = 3; x > 0; x--)
            {
                for (int i = x; i < end; i++)
                {
                    if (view[i - 1][y])
                    {
                        if (0 == view[i][y])
                        {
                            // 移动
                            view[i][y] = view[i - 1][y];
                            view[i - 1][y] = 0;
                            flag = true;
                        }
                        else if (view[i - 1][y] == view[i][y])
                        {
                            //  合并
                            view[i][y] *= 2;
                            if (view[i][y] == 2048) {
                                *endflag = true;
                            }
                            view[i - 1][y] = 0;
                            end = i - 1;
                            flag = true;
                        }
                    }
                }
            }
        }
        break;
    }
    case 'a': {

        for (int x = 0; x < 4; x++)
        {
            int end = 0;
            for (int y = 1; y < 4; y++)
            {
                for (int i = y; i > end; i--)
                {
                    if (view[x][i])
                    {
                        if (0 == view[x][i - 1])
                        {
                            // 移动
                            view[x][i - 1] = view[x][i];
                            view[x][i] = 0;
                            flag = true;
                        }
                        else if (view[x][i] == view[x][i - 1])
                        {
                            //  合并
                            view[x][i - 1] *= 2;
                            if (view[x][i - 1]==2048) {
                                *endflag = true;
                            }
                            view[x][i] = 0;
                            end = i;
                            //score += view[x][i - 1];
                            flag = true;
                        }
                    }
                }
            }
        }
        break;
    }
    case 'd': {


        for (int x = 0; x < 4; x++)
        {
            int end = 4;
            for (int y = 3; y > 0; y--)
            {
                for (int i = y; i < end; i++)
                {
                    if (view[x][i - 1])
                    {
                        if (0 == view[x][i])
                        {
                            // 移动
                            view[x][i] = view[x][i - 1];
                            view[x][i - 1] = 0;
                            flag = true;
                        }
                        else if (view[x][i - 1] == view[x][i])
                        {
                            //  合并
                            view[x][i] *= 2;
                            if (view[x][i] == 2048) {
                                *endflag = true;
                            }
                            view[x][i - 1] = 0;
                            end = i - 1;
                            flag = true;
                        }
                    }
                }
            }
        }
            break;
        }
    default:
        break;
    }
    }

int main() {
	int a[4][4] = { 0 };
    // 初始化随机数生成器
    srand((unsigned)time(NULL));

    // 生成0到4之间的随机数
    printf("这是一个简单的2048游戏\n");
    printf("输入a向左移动，输入d向右移动，输入s向下移动，输入w向上移动\n");
    int stk = 0;
    while (stk < 2) {
        int x = rand() % 4;
        int y = rand() % 4;
        if (a[x][y] == 0) {
            a[x][y] = 2;
            stk++;
        }
    }
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    while (1) {
        char move ;
        //scanf("%c", &move);
        move = _getch();
        bool endflag = false;
        bool flag = moveG(a, move,&endflag);

        int x = rand() % 4;
        int y = rand() % 4;
        int isAdd = 0;
        while((move=='a' || move == 'd' || move == 'w' || move == 's') && a[x][y] == 0 && isAdd == 0) {
            a[x][y] = 2;
            isAdd = 1;
        }
        isAdd = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                printf("%d ", a[i][j]);
            }
            printf("\n");
        }
        printf("\n");
        if (endflag) {
            printf("2048达成\n");
            break;
        }
        if (!flag) {
            printf("you pause no change end game");
            break;
        }
    }
    return 0;
}

我正在参与2024腾讯技术创作特训营最新征文，快来和我瓜分大奖！

用C语言控制台界面实现一个简单的2048游戏

用C语言控制台界面实现一个简单的2048游戏

2048的游戏逻辑与预览图

制作思路

构造数组和游戏开始时随机数

接下来的思路

检测移动的函数

移动后的插入

全部代码

运行截图

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐