C语言2048C实现

最新推荐文章于 2023-12-07 18:16:18 发布
最新推荐文章于 2023-12-07 18:16:18 发布
阅读量261 收藏
点赞数
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24830869/article/details/125443417
版权 
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <strsafe.h>

//函数返还
#define FALSE 0
#define OK 1
//操作输入
#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
//游戏数据
#define SIZE 4
#define HIDE 0
#define TOWER 0

typedef int status;
typedef int Map_2048;
typedef struct Sentry
{
    Map_2048 *TravelSentry;
    Map_2048 *CheckSentry;
} SentryDouble; //哨兵工具包

static void _SetPos(int x, int y); //移动光标到X、Y位置
static void HidePos();             //隐藏光标

static status GAME_PLAY();                                                                                             //游戏启动
static status GAME_DataShow();                                                                                         //打印游戏数据
static status GAME_DataInitialize();                                                                                   //图案初始化
static status GAME_DataCreate();                                                                                       //随机生成的2
static status GAME_DataDeal(int Player_Input);                                                                         //根据输入处理已有数据
static status GAME_XDataDeal(int Player_Input);                                                                        //行处理
static status GAME_YDataDeal(int Player_Input);                                                                        //列处理
static status GAME_XPartDataDeal(int Player_Input, SentryDouble *Sentry, int i);                                       //行部分处理
static status GAME_YPartDataDeal(int Player_Input, SentryDouble *Sentry, int i);                                       //列部分处理
static status SentryInitialize(int Player_Input, SentryDouble *Sentry, int i);                                         //根据Player_Input推进哨兵进入下一阶段
static status CheckSentryDeal(int Player_Input, SentryDouble *Sentry);                                                 // CheckSentry运行
static status DataMerge(SentryDouble *Sentry);                                                                         //数据合并
static status RangeSentryDeal(int Player_Input, SentryDouble Sentry);                                                  //通过RangeSentry查询CheckSentry——TravelSentry之间是否全零
static status DataReorganize(int Player_Input);                                                                        //数据整理
static status GAME_DataTowerDeal();                                                                                    //数据查满
static status GAME_OverJudge();                                                                                        //结束查询
static status GAME_OverPartJudge(int Player_Input, Map_2048 DataSumTemp, Map_2048 DataSum, Map_2048 Over[][SIZE + 1]); //四方向判断
static status Node_Beautiy(int i, int j, int color);                                                                   //节点美化
Map_2048 Map[SIZE + 1][SIZE + 1] = {HIDE};                                                                             //游戏地图初始化,Map[0][]与Map[][0],用于判断行列是否已满

void main()
{

    GAME_PLAY();
    getchar();
}

static status GAME_DataInitialize()
{
    for (int i = 0; i < 2; i++)
    {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 51);
        _SetPos(0, i * 13);
        printf("■■■■■■■■■■■■■■");
        for (int j = 0; j < 14; j++)
        {
            _SetPos(i * 26, j);
            printf("■");
        }
    }
    return OK;
}

static status GAME_OverPartJudge(int Player_Input, Map_2048 DataSumTemp, Map_2048 DataSum, Map_2048 Over[][SIZE + 1])
{
    DataSum = 0;
    GAME_DataDeal(Player_Input);
    GAME_DataCreate();
    for (int i = 1; i <= SIZE; i++)
        for (int j = 1; j <= SIZE; j++)
        {
            if (Over[i][j] != Map[i][j])
            {
                for (int w = 0; w <= SIZE; w++)
                    for (int r = 0; r <= SIZE; r++)
                    {
                        Map[w][r] = Over[w][r];
                    }
                return FALSE;
            }
        }
    return OK;
}

static status GAME_OverJudge()
{
    if (Map[TOWER][TOWER])
    {
        Map_2048 Over[SIZE + 1][SIZE + 1];
        Map_2048 DataSumTemp, DataSum;
        for (int i = 0; i <= SIZE; i++)
            for (int j = 0; j <= SIZE; j++)
            {
                DataSumTemp += Map[i][j];
                Over[i][j] = Map[i][j];
            }
        DataSumTemp -= 9;
        if (!GAME_OverPartJudge(UP, DataSumTemp, DataSum, Over))
            return 2;
        if (!GAME_OverPartJudge(DOWN, DataSumTemp, DataSum, Over))
            return 2;
        if (!GAME_OverPartJudge(LEFT, DataSumTemp, DataSum, Over))
            return 2;
        if (!GAME_OverPartJudge(RIGHT, DataSumTemp, DataSum, Over))
            return 2;
        return OK;
    }
    else
        return FALSE;
}

static void _SetPos(int x, int y)
{
    COORD position;
    HANDLE handle;
    position.X = x;
    position.Y = y;
    handle = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(handle, position);
}

static void HidePos()
{
    CONSOLE_CURSOR_INFO cursor_info = {1, FALSE};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}

static status GAME_DataCreate()
{
    int x, y;
    int Weight;
    Weight = rand() % 10;
    srand(time(NULL));
    if (Map[TOWER][TOWER])
        return FALSE;
    while (1)
    {
        x = rand() % SIZE + 1;
        y = rand() % SIZE + 1;
        if (!Map[x][y])
            if (Weight)
            {
                Map[x][y] = 2;
                break;
            }
            else
            {
                Map[x][y] = 4;
                break;
            }
    }

    return OK;
}

static status GAME_YDataDeal(int Player_Input)
{
    SentryDouble Sentry;
    for (int i = 1; i <= SIZE; i++)
        GAME_YPartDataDeal(Player_Input, &Sentry, i);
    return OK;
}

static status GAME_XDataDeal(int Player_Input)
{
    SentryDouble Sentry;
    for (int i = 1; i <= SIZE; i++)
        GAME_XPartDataDeal(Player_Input, &Sentry, i);
    return OK;
}

static status GAME_DataDeal(int Player_Input)
{
    switch (Player_Input)
    {
    case UP:
    case DOWN:
        GAME_YDataDeal(Player_Input);
        break;
    case LEFT:
    case RIGHT:
        GAME_XDataDeal(Player_Input);
        break;
    default:
        break;
    }
    return OK;
}

static status CheckSentryDeal(int Player_Input, SentryDouble *Sentry)
{

    switch (Player_Input)
    {
    case UP:
        Sentry->CheckSentry = Sentry->CheckSentry + SIZE + 1;
        break;
    case DOWN:
        Sentry->CheckSentry = Sentry->CheckSentry - (SIZE + 1);
        break;
    case LEFT:
        Sentry->CheckSentry = Sentry->CheckSentry + 1;
        break;
    case RIGHT:
        Sentry->CheckSentry = Sentry->CheckSentry - 1;
        break;
    default:
        break;
    }
    if ((*Sentry->CheckSentry == *Sentry->TravelSentry) && (*Sentry->CheckSentry != 0))
        if (RangeSentryDeal(Player_Input, *Sentry) && *Sentry->TravelSentry != 2048)
        {
            DataMerge(Sentry);
            return OK;
        }
    return FALSE;
}

static status RangeSentryDeal(int Player_Input, SentryDouble Sentry)
{
    int I;
    int Sew; //缀
    Map_2048 *RangeSentry;
    switch (Player_Input)
    {
    case UP:
    case LEFT:
        Sew = Player_Input == UP ? (SIZE + 1) : 1;
        I = (Sentry.CheckSentry - Sentry.TravelSentry) / Sew;
        RangeSentry = Sentry.TravelSentry;
        while (I--)
        {
            RangeSentry = RangeSentry + Sew;
            if (*RangeSentry != 0 && *RangeSentry != *Sentry.TravelSentry)
                return FALSE;
        }
        break;
    case DOWN:
    case RIGHT:
        Sew = Player_Input == DOWN ? (SIZE + 1) : 1;
        I = (Sentry.TravelSentry - Sentry.CheckSentry) / Sew;
        RangeSentry = Sentry.CheckSentry;
        while (I--)
        {
            RangeSentry = RangeSentry + Sew;
            if (*RangeSentry != 0 && *RangeSentry != *Sentry.CheckSentry)
                return FALSE;
        }
        break;
    default:
        break;
    }
    return OK;
}

static status SentryInitialize(int Player_Input, SentryDouble *Sentry, int i)
{
    switch (Player_Input)
    {
    case UP:
        Sentry->TravelSentry = Sentry->CheckSentry = &Map[1][i];
        break;
    case LEFT:
        Sentry->TravelSentry = Sentry->CheckSentry = &Map[i][1];
        break;
    case DOWN:
        Sentry->TravelSentry = Sentry->CheckSentry = &Map[SIZE][SIZE - i + 1];
        break;
    case RIGHT:
        Sentry->TravelSentry = Sentry->CheckSentry = &Map[SIZE - i + 1][SIZE];
        break;
    default:
        break;
    }
    return OK;
}

static status GAME_XPartDataDeal(int Player_Input, SentryDouble *Sentry, int i)
{
    SentryInitialize(Player_Input, Sentry, i); //哨兵初始化

    Map_2048 *ExSentry;
    ExSentry = (Player_Input == LEFT ? (&Map[i][SIZE]) : (&Map[SIZE - i + 1][1])); //塔
    int Sew = Player_Input == LEFT ? 1 : -1;                                       //缀

    while ((*Sentry->TravelSentry == 0) && (Sentry->TravelSentry != ExSentry)) //排除零
        Sentry->CheckSentry = Sentry->TravelSentry = Sentry->TravelSentry + Sew;
    

    while (Sentry->TravelSentry != ExSentry)
    {
        Sentry->CheckSentry = Sentry->TravelSentry;
        while (Sentry->CheckSentry != ExSentry)
        {
            CheckSentryDeal(Player_Input, Sentry);
        }
        Sentry->TravelSentry = Sentry->TravelSentry + Sew;
    }
    return OK;
}

static status GAME_YPartDataDeal(int Player_Input, SentryDouble *Sentry, int i)
{
    SentryInitialize(Player_Input, Sentry, i); //哨兵初始化
    Map_2048 *ExSentry;

    ExSentry = (Player_Input == UP ? &Map[SIZE][i] : &Map[1][SIZE - i + 1]); //塔
    int Sew = (Player_Input == UP ? (SIZE + 1) : -(SIZE + 1));               //缀

    while ((*Sentry->TravelSentry == 0) && (Sentry->TravelSentry != ExSentry)) //排除零
        Sentry->CheckSentry = Sentry->TravelSentry = Sentry->TravelSentry + Sew;
    while (Sentry->TravelSentry != ExSentry)
    {
        Sentry->CheckSentry = Sentry->TravelSentry;
        while (Sentry->CheckSentry != ExSentry)
            CheckSentryDeal(Player_Input, Sentry);
        Sentry->TravelSentry = Sentry->TravelSentry + Sew;
    }
    return OK;
}

static status DataMerge(SentryDouble *Sentry)
{
    *Sentry->TravelSentry = (*Sentry->TravelSentry) * 2;
    *Sentry->CheckSentry = HIDE;
    return OK;
}

static status DataReorganize(int Player_Input)
{
    SentryDouble Sentry;
    Map_2048 *ExSentry; //塔
    int Sew;            //缀
    for (int i = 1; i <= SIZE; i++)
    {
        if (Player_Input == LEFT || Player_Input == RIGHT)
        {
            ExSentry = (Player_Input == LEFT ? &Map[i][SIZE] : &Map[SIZE - i + 1][1]); //塔
            Sew = (Player_Input == LEFT ? 1 : -1);                                     //缀
        }
        else if (Player_Input == UP || Player_Input == DOWN)
        {
            ExSentry = (Player_Input == UP ? &Map[SIZE][i] : &Map[1][SIZE - i + 1]); //塔
            Sew = (Player_Input == UP ? SIZE + 1 : -(SIZE + 1));                     //缀
        }
        SentryInitialize(Player_Input, &Sentry, i);
        while (Sentry.TravelSentry != ExSentry)
        {
            if (*Sentry.TravelSentry == 0)
            {
                Sentry.CheckSentry = Sentry.TravelSentry;
                while (Sentry.CheckSentry != ExSentry)
                {
                    Sentry.CheckSentry = Sentry.CheckSentry + Sew;
                    if (*Sentry.CheckSentry != 0)
                    {
                        *Sentry.TravelSentry = *Sentry.CheckSentry;
                        *Sentry.CheckSentry = 0;
                        break;
                    }
                }
            }
            Sentry.TravelSentry = Sentry.TravelSentry + Sew;
        }
    }
    return OK;
}

static status Node_Beautiy(int i, int j, int color)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);
    for (int w = 1; w <= 3; w++)
    {
        _SetPos(2 + 6 * i, w + 3 * j);
        w == 2 ? printf("%4d  ", Map[j + 1][i + 1]) : printf("      ");
    }
    return OK;
}

static status GAME_DataShow()
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            switch (Map[j + 1][i + 1])
            {
            case 2:
                Node_Beautiy(i, j, 191);
                break;
            case 4:
                Node_Beautiy(i, j, 159);
                break;
            case 8:
                Node_Beautiy(i, j, 175);
                break;
            case 16:
                Node_Beautiy(i, j, 223);
                break;
            case 32:
                Node_Beautiy(i, j, 207);
                break;
            case 64:
                Node_Beautiy(i, j, 71);
                break;
            case 128:
                Node_Beautiy(i, j, 143);
                break;
            case 256:
                Node_Beautiy(i, j, 63);
                break;
            case 512:
                Node_Beautiy(i, j, 31);
                break;
            case 1024:
                Node_Beautiy(i, j, 79);
                break;
            case 2048:
                Node_Beautiy(i, j, 78);
                break;
            case 0:
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 255);
                _SetPos(2 + 6 * i, 1 + 3 * j);
                printf("      ");
                _SetPos(2 + 6 * i, 2 + 3 * j);
                printf("      ");
                _SetPos(2 + 6 * i, 3 + 3 * j);
                printf("      ");
                break;
            default:
                break;
            }
        }
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);
    return OK;
}

static status GAME_DataTowerDeal()//
{
    int j, i;
    for (i = 1; i <= SIZE; i++)
    {
        for (j = 1; j <= SIZE; j++)
            if (!Map[i][j])
                break;
        if (j == SIZE + 1)
            Map[i][TOWER] = 1;
        else
            Map[i][TOWER] = 0;
    }

    for (i = 1; i <= SIZE; i++)
    {
        for (j = 1; j <= SIZE; j++)
            if (!Map[j][i])
                break;
        if (j == SIZE + 1)
            Map[TOWER][i] = 1;
        else
            Map[TOWER][i] = 0;
    }
    for (i = 1; i <= SIZE; i++)
        if (!Map[i][TOWER] || !Map[TOWER][i])
            break;
    Map[TOWER][TOWER] = (i == SIZE + 1 ? 1 : 0);
    return OK;
}

static status GAME_PLAY()
{
    system("mode con cols=28 lines=17 ");
    char Player_inPut;
    HidePos();
    GAME_DataInitialize();
    int Player_Input, count = 0;
    for (int i = 0; i <= SIZE; i++)
        for (int j = 0; j <= SIZE; j++)
            Map[i][j] = HIDE;
    for (int i = 0; i < 3; i++) //初始化
        GAME_DataCreate();
    GAME_DataShow();
    _SetPos(0, 14);
    printf("                                  ");
    _SetPos(0, 15);
    printf("                                  ");
    while (1)
    {
        HidePos();
        _SetPos(0, 14);
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);
        printf("得分:%5d ", count);
        printf("重开:R");
        HidePos();
    InputAgain:
        Player_Input = _getch();
        if (Player_Input == 224)
            Player_Input = _getch();
        else if (Player_Input == (int)'R' || Player_Input == (int)'r')
            main();
        else
            goto InputAgain;

        GAME_DataDeal(Player_Input);
        DataReorganize(Player_Input);
        GAME_DataTowerDeal();
        GAME_DataShow();

        Sleep(100);
        GAME_DataCreate();
        GAME_DataTowerDeal();
        GAME_DataShow();

        if (GAME_OverJudge() == 1)
            break;
        else if (!GAME_OverJudge())
            count++;
        HidePos();
    }
    _SetPos(0, 15);
    printf("游戏结束 ");
    printf("是否再来一次？(Y)/(N)");
Again:
    Player_inPut = getchar();
    if (Player_inPut == 'Y' || Player_inPut == 'y')
        main();
    else if (Player_inPut == 'N' || Player_inPut == 'n')
        return OK;
    else
        goto Again;
}

Lyrics_lib
关注
C语言实现2048
hb_hltall的博客
11-06 4921
C语言实现2048小游戏 众所周知，推箱子、2048、贪吃蛇被称为大学编程课三大经典小项目。很多刚学编程的小伙伴都想写出一个自己的小游戏，这次介绍其中的2048。 游戏规则：WASD移动，V撤回，P主动结束游戏。 数字会显示颜色，不同数值颜色不尽相同。 可以设置游戏行列大小以及难度。 可在windows下运行，根据注释提示修改部分函数名之后也能在linux下运行。 移动算法思路如图： 源代码如下：欢迎讨论。 #include"tzfe.h" int ttafe[X][Y] = {0}; int efat
用C语言实现2048
12-19
我的2048有几个好处： 1.简单又容易玩 2.用wasd来控制上下左右 下载后请评论，谢谢
2048 (C语言)
Y_skepticism的博客
07-23 776
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <time.h> #include <getch.h> // 创建二维数组 int arr[4][4]; // 是否移动或合并过 bool IS_MOVE_MERGE = true; // 显示界面...
游戏2048.c
06-07
基于FGA的游戏代码2048，vga小游戏。大概能完成saasdasdasd
C语言小游戏: 2048.c
weixin_34268579的博客
01-14 690
概要：2048.c是一个C语言编写的2048游戏，本文将详细分析它的源码和实现。C语言是一种经典实用的编程语言，本身也不复杂，但是学会C语言和能够编写实用的程序还是有一道鸿沟的。本文试图通过一个例子展示如何用C语言实现一个简单但有用的程序。 一、程序简介 本文分析的代码是mevdschee在GitHub上的项目2048.c，游戏的规则和安装说明都可以到主页查看，本文不再赘述。顺便一提，这个程序...
2048 C语言版本
qq_36382679的博客
01-24 544
#include <stdio.h> //标准输入输出函数库（printf、scanf） #include <conio.h> //为了读取方向键 #include <windows.h>//控制dos界面（获取控制台上坐标位置、设置字体颜色） #include <math.h> //pow函数 /*******函 数 声 明*******/ void gotoxy(int x, int y); //获取屏幕光标位置 int color(in
rsa2048.rar RSA2048的C语言实现代码
05-18
在本文中，我们将深入探讨RSA2048的C语言实现及其相关知识点。 1. RSA算法基础： RSA算法由Ron Rivest、Adi Shamir和Leonard Adleman于1977年提出，它是一种非对称加密算法，意味着加密和解密使用不同的密钥。RSA...
C语言代码实现2048游戏
08-25
C语言实现2048游戏的设计与实现 在本文中，我们将详细介绍如何使用C语言实现2048游戏。2048是一款非常popular的数字游戏，游戏的规则非常简单，即将相同的数字合并起来，直到最后达到2048为止。在本文中，我们将...
c语言版2048
10-28
《C语言实现2048游戏详解》 2048是一款广受欢迎的数字合并游戏，它的核心玩法是将相同的数字合并成更大的数字，直至达到2048这个目标。本篇文章将深入探讨如何使用C语言来实现这样一个游戏，帮助读者理解C语言编程...
用C语言实现2048小游戏
07-02
就一个.c文件，打开即可使用
2048源代码（C语言）
11-29
2048游戏的C语言实现，里面有详细注释，适合新手学习。
2048小游戏c语言实现
08-24
欢迎试玩！
2048c语言变形版
05-28
对2048进行修改后，使用c语言的具体实现，里面有具体的解释
2048C语言源码linux
尘心的博客
08-12 420
#include <stdio.h> #include <stdlib.h> #include <curses.h> #include <unistd.h> #include <signal.h> #include <time.h> int a[4][4] = {0}; int empty; int old_y, old_x...
c语言-2048
jiayouliying的博客
10-06 1887
/*2048*/ #include #include #include #include //全局变量 int x[4][4]={0}; int score=0; int can_move; int empty() { int i,j; int n=0; for(i=0;i<4;i++) { for(j=0;j<4;j++) {
2048的C语言实现
yan1042141077的博客
04-20 233
本人作为一个萌新，没事喜欢玩一些小游戏，最近对2048比较感兴趣，就自己动手写了一个，其中有些地方还有一些不足，希望众位大佬能够指点指点。2048.h ///////////////////////////// #define bool int //对bool类型进行定义 #define true 1 //bool的两种值 #define false 0 int MAP[4][4] = {
C语言——2048完整版
最新发布
cjy040921的博客
12-07 4197
2048
C语言实现2048游戏源代码解析
"这篇资源提供了使用C语言实现2048小游戏的代码示例，适合对C语言编程和游戏开发感兴趣的读者参考学习。代码在VC6.0环境下编译运行，虽然作者承认代码可能不够完美，但对于初学者来说仍然有很好的参考价值。" 在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值