C语言，2048

最新推荐文章于 2024-09-05 23:31:31 发布
最新推荐文章于 2024-09-05 23:31:31 发布
阅读量97 收藏
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：https://my.oschina.net/u/3202498/blog/819047
版权

#include<stdlib.h>
#include<stdio.h>
#include <windows.h>
#include<conio.h>
#include<time.h>
#include<process.h>
void PrintChar(char *ch,UINT count,UINT x,UINT y);
void Operate();
void Map();
void ChangeNum(char a[4],int n);
void CreatNum(int a[][4],struct NODE *pHead);
void Show(int a[][4]);
void Insert(struct NODE *pHead,int a,int b);
void Delete(struct NODE  *pHead,int a,int b );
struct NODE
{
    int x;
    int y;
    struct NODE *next;
};
int iCount=16;
int main()
{
    Map();    
    Operate();
    
    return 0;
}
void ChangeNum(char a[4],int n)
{
    int temp;
    int i=3;
    if(n!=0)
    {
        while(n!=0)
        {
            temp=n/10;
            a[i]=n-temp*10+48;
            n=temp;
            i--;
        }
        while(i>=0)
        {
            a[i]=' ';
            i--;        
        }
    }
    else
    {
        for(i=0;i<4;i++)
            a[i]=' ';    
    }

        
}
void Map()
{
    int i;
    int j;
    for(i=0;i<=8;i+=2)
    {
        for(j=0;j<=20;j++)
            PrintChar("*",1,j,i);
    }
    for(i=0;i<=20;i+=5)
    {
        for(j=0;j<=8;j++)
            PrintChar("|",1,i,j);    
    }
}
void PrintChar(char *ch,UINT count,UINT x,UINT y)  //在坐标(x,y)处输出字符串ch,ch里有count个字符
{
     HANDLE h=GetStdHandle(STD_OUTPUT_HANDLE);
     COORD pos;
     ULONG unuse;
     pos.X=x;
     pos.Y=y;
     CONSOLE_SCREEN_BUFFER_INFO bInfo; // 窗口缓冲区信息
     GetConsoleScreenBufferInfo(h, &bInfo );
     WriteConsoleOutputCharacterA(h,ch,count,pos,&unuse);
}
void Operate()
{
    int a[4][4];
    int (*p)[4];

    int i,j,k,h;
    struct NODE *pHead,*pEnd,*t;
    pHead=pEnd=(struct NODE*)malloc(sizeof(struct NODE));//建立链表保存没有数字的坐标

    char ch;
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
            a[i][j]=0;
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
        {
            t=(struct NODE*)malloc(sizeof(struct NODE));
            t->x=i;
            t->y=j;
            pEnd->next=t;
            pEnd=t;
        }
    pEnd->next=NULL;
    CreatNum(a,pHead);
    CreatNum(a,pHead);
    Show(a);
    

    while(1)
    {
        while(!kbhit());
        while(kbhit())
            ch=getch();
    
        switch(ch)
        {
        case 77:       //right
            p=&a[0];
            for(i=0;i<4;i++)    //MERGE
            {
                for(j=3;j>0;j--)
                {
                    h=j-1;
                    if(*(*(p+i)+j))
                    {while(h>=0&&*(*(p+i)+h)==0)h--;
                    if(h>=0)
                    {
                        if(*(*(p+i)+h)==*(*(p+i)+j))
                        {
                        
                            *(*(p+i)+j)*=2;
                            *(*(p+i)+h)=0;
                            iCount++;
                            Insert(pHead,i,h);
                        
                        }
                    
                    }
                    }
                
                }                            
            }
            for(i=0;i<4;i++)       //MOVE
            {
                for(j=2;j>=0;j--)
                {
                    k=0;
                    if(*(*(p+i)+j)!=0)
                    {
                        for(h=j+1;h<=3;h++)
                            if(*(*(p+i)+h)==0)
                            {k++;}
                        if(k)
                        {
                            *(*(p+i)+j+k)=*(*(p+i)+j);
                            *(*(p+i)+j)=0;
                            Delete(pHead,i,j+k);
                            Insert(pHead,i,j);
                            
                        }                        
                    }
                
                }
                        
            }            
            Show(a);
            break;
        case 75:              //left
            p=&a[0];
            for(i=0;i<4;i++)    //MERGE
            {
                for(j=3;j>0;j--)
                {
                    h=j-1;
                    if(*(*(p+i)+j))
                    {
                        while(h>=0&&*(*(p+i)+h)==0)h--;
                        if(h>=0)
                        {
                            if(*(*(p+i)+h)==*(*(p+i)+j))
                            {
                                
                                *(*(p+i)+j)*=2;
                                *(*(p+i)+h)=0;
                                iCount++;
                                Insert(pHead,i,h);
                        
                            }
                    
                        }
                    }
                }                            
            }
            for(i=0;i<4;i++)  //Move
            {
                for(j=1;j<4;j++)
                {
                    k=0;
                    if(*(*(p+i)+j))
                    {
                        for(h=j-1;h>=0;h--)
                            if(*(*(p+i)+h)==0)
                            {k++;}
                            if(k)
                            {                                
                                *(*(p+i)+j-k)=*(*(p+i)+j);
                                *(*(p+i)+j)=0;
                                Delete(pHead,i,j-k);
                                Insert(pHead,i,j);                                
                            }
                    
                    }
                
                
                }
            
            
            
            }
            Show(a);
            break;
        case 72:              //up
            for(j=0;j<4;j++)  //Merge
            {
                for(i=0;i<3;i++)
                {
                    h=i+1;
                    if(a[i][j])
                    {
                        while(h<4&&a[h][j]==0)h++;
                        if(h<4)
                        {
                            if(a[i][j]==a[h][j])
                            {
                                
                                a[i][j]*=2;
                                a[h][j]=0;
                                iCount++;
                                Insert(pHead,h,j);
                            
                            }
                        
                        }
                    
                    }                
                }
                    
            }
            for(j=0;j<4;j++) //Move
            {
                for(i=1;i<4;i++)
                {
                    k=0;
                    if(a[i][j])
                    {
                        for(h=i-1;h>=0;h--)
                            if(a[h][j]==0)
                            {k++;}
                        if(k)
                        {
                            a[i-k][j]=a[i][j];
                            a[i][j]=0;
                            Delete(pHead,i-k,j);
                            Insert(pHead,i,j);
                        
                        }
                    
                    }
                
                }
            
            
            }
            Show(a);
            break;
        case 80:               //down
            for(j=0;j<4;j++)   //Merge
            {
                for(i=0;i<4;i++)
                {
                    h=i+1;
                    if(a[i][j])
                    {
                        while(h<4&&a[h][j]==0)h++;
                        if(h<4)
                        {
                            if(a[i][j]==a[h][j])
                            {
                                
                                a[i][j]*=2;
                                a[h][j]=0;
                                iCount++;
                                Insert(pHead,h,j);
                            
                            }
                        
                        }
                    
                    }                
                }
                    
            }
            for(j=0;j<4;j++)
            {
                for(i=2;i>=0;i--)
                {
                    k=0;
                    if(a[i][j])
                    {
                        for(h=i+1;h<4;h++)
                            if(a[h][j]==0)
                            {k++;}
                        if(k)
                        {
                            a[i+k][j]=a[i][j];
                            a[i][j]=0;
                            Delete(pHead,i+k,j);
                            Insert(pHead,i,j);
                        
                        
                        }
                    
                    
                    }
                
                
                }
                
            }
            Show(a);
            break;
        }
        if(0==iCount)
        {system("cls");printf("GAME OVER  ");break;}

        CreatNum(a,pHead);
        Show(a);
    
    }


}
void CreatNum(int a[][4],struct NODE *pHead)
{
    int i=0;
    int b;
    int num;
    struct NODE *t,*t1;
    t=pHead;
    srand((unsigned)time( NULL ));
    num=rand()%100;
    if(num<90)
        num=2;
    else
        num=4;
    srand((unsigned)time( NULL ));
    b=rand()%iCount+1;
    while(i!=(b-1))
    {
        t=t->next;
        i++;
    }
    a[t->next->x][t->next->y]=num;
    t1=t->next;
    t->next=t1->next;
    free(t1);
    iCount--;
}
void Show(int a[][4])
{
    int i;
    int j;
    char p[4];
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
        {
            ChangeNum(p,a[i][j]);
            PrintChar(p,4,5*j+1,2*i+1);
        
        }

}

void  Delete(struct NODE  *pHead,int a,int b )
{
    struct NODE *tq,*th;
    tq=pHead;
    th=pHead->next;
    while(th!=NULL)
    {
        if(th->x==a&&th->y==b)
            break;
        else
        {
            tq=tq->next;
            th=th->next;    
        }
    }
    tq->next=th->next;
    free(th);
}
void Insert(struct NODE *pHead,int a,int b)
{
    struct NODE *t;
    t=(struct NODE*)malloc(sizeof(struct NODE));
    t->x=a;
    t->y=b;
    t->next=pHead->next;
    pHead->next=t;
}

转载于:https://my.oschina.net/u/3202498/blog/819047

chibin0558
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言2048小游戏报告,C语言写的2048小游戏
weixin_29568097的博客
05-19 627
基于"基于C_语言的2048算法设计_颜冠鹏.pdf"这一篇文献提供的思路在中国知网上能找到 就不贴具体内容了[摘 要] 针对2048的游戏规则，分析了该游戏的算法特点，对其相关的功能需求和算法设计进行了简单介绍，提出了一种 新的设计方案。解决了该设计在方阵数据结构、运动算法和游戏结束判断方面的问题，并阐述了以队列方式进行坐标运算和操 作扩展的关键技术。软件测试表明，该设计的方块数值最大值受方阵阶...
简单实现C语言2048游戏
08-27
简单实现C语言2048游戏 本文将详细介绍如何使用C语言来实现2048游戏。该游戏是一种流行的数字游戏，玩家通过滑动方块来合并数字，最终目标是获取2048的数字。 游戏原理 游戏的核心是使用二维数组来存储游戏板上的...
2048C语言代码有链表,关于JS中的链表
weixin_39640444的博客
05-21 93
最近在看数据结构与算法JavaScript描述，在链表这一章遇到了点问题，问题描述如下要享一多很。等考指的似是很面一也者效下行插删除链表中的item节点，prevNode是item节点的朋支不器几事为的时后级功发发来久都这样含制层是请些间例业多在上屏屏有到前一个节点书中用了 prevNode.next = prevNode.next.next; 来改变链表的指向。但是我的理解是prevNode.n...
C语言2048源码
lxylxylxy的博客
11-26 1481
在运行的窗口实现，该代码也是编写图形模式的基础详细解释看我之前的那篇不过本文多了记分功能，还有历史最高分对比。
C语言 2048 增加一些功能
weixin_44954896的博客
05-19 1178
2048 C语言 2048（每步细致讲解） 20482048前言存取功能存总结 前言 接着之前写的2048基础上进行增加和优化。 增加存储的得分功能和读取得分功能， 改变字体颜色， 窗口界面之间跳转 增加窗口选择界面 增加游戏介绍界面 存取功能 存 void Save(){ FILE *f;//指向文件的指针 f=fopen("HScore.txt","w");//打开HScore文件，若没有会自动创建 fprintf(f, "%d",score);//把得分存入 fclose(f);
C语言 2048源码（每步细致讲解更新ing）
热门推荐
weixin_44954896的博客
04-30 2万+
前言 提示：这里可以添加本文要记录的大概内容： 昨天晚上突然想用c写个2048，觉得学了这么久，没写点什么东西有点心空空，就乘着备考时间来写写看，以前就想过，也就想想，一直没去写，今天没什么课，而且还是网课，然后就先看看别人写的代码之后，自己理解之后又重新敲了一遍，写了一天也算是写了个简易的2048。 2048的代码也不难，主要就是使用数组对数组的操作，再对数组移动改变的时候的逻辑清楚就没问题了。 写的很仓促，代码不怎么好看，以后有时间会慢慢优化并增加一些功能。 提示：以下是本篇文章正文内容，下面案例可.
c语言2048项目报告,c语言----<项目>_小游戏<2048>
weixin_35143292的博客
05-19 886
2048 小游戏 主要是针对逻辑思维的一个训练.主要学习方面:1.随机数产生的概率.2.行与列在进行移动的时候几种情况.3.messagebox的使用#include #include #include #include using namespace std;int board[4][4] = {0}; //二维数组int if_need_ran...
纯C语言2048，超详细
zhou_zhou_04的博客
01-23 1万+
突然想写2048，就模仿人家写的2048，写了2048，但有所改良😁（改良了一点小毛病，但绝大部分都一样）
linux下c语言2048,C语言实现2048小游戏
weixin_32158567的博客
05-12 397
本文实例为大家分享了C语言实现2048小游戏的具体代码，供大家参考，具体内容如下具有以下特点：1.linux下完成2.非堵塞键盘读取3.随机生成2和4#include #include #include #define TTY_PATH "/dev/tty"#define STTY_ON "stty raw -echo -F"#define STTY_OFF "stty -raw echo -F"...
C语言——2048完整版
cjy040921的博客
12-07 3966
2048
C语言2048源代码
cprimesplus的博客
10-27 1万+
前言： 想到做过就贴出来系列… 前后左右的移动道理相同。 代码： //2048 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;windows.h&gt; void move_up(int a[][4]) { int i,j,k,n; int flag=0; for(j=0;j&lt;4;j++) //列 { ...
C语言2048小游戏.zip
06-13
【标题】"C语言2048小游戏"指的是使用C编程语言实现的2048游戏。2048是一款非常流行的数字拼图游戏，玩家需要在4x4的格子上滑动数字方块，每次操作后，会有两个随机出现的数字2或4加入棋盘，相同数字的方块会合并成...
C语言2048小游戏
01-01
老师布置的作业，不是很成熟，有需求可以参考一下
【C++】STL—vector的使用
2301_77112794的博客
09-04 688
本文介绍了vector重点函数接口的使用
c++11---包装器
2302_80221042的博客
09-03 449
3.既然this是指针类型，为什么第二种包装方法把参数写成对象也可以，这是因为包装器底层其实是把可调用对象作为成员变量存起来，使用包装器时先调用包装器的operator（）重载，把参数传给operator（），然后operator（）利用参数调用这个对象，所以实际上，这里是operator（）用Plus*或者Plus（）调用被包装的可调用对象，而不论是对象还是对象指针都可以调用成员函数，所以两种都可以。bind是一个函数模版，他可以在一个可调用对象的基础上改变其的参数个数，参数顺序，并返回一个新函数对象。
Transiting from CUDA to HIP （二）
weixin_44500921的博客
09-03 1333
为了解决这个问题，HIP（Heterogeneous-compute Interface for Portability）提供了一套宏定义，使得开发者可以编写可移植的代码，这些代码可以在 NVIDIA 的 CUDA 平台和 AMD 的 ROCm 平台上运行。是一个预定义的宏，用于指示当前编译的代码所针对的 NVIDIA GPU 的计算能力（Compute Capability）。为了正确编译包含 HIP 代码的文件，您需要确保编译器能够找到 HIP 的头文件，并且定义了正确的宏。
QWidget(c++)嵌入window环境的exe
最新发布
sunflower_2020的博客
09-05 239
QWidget(c++)嵌入window环境的exe
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1014
C++复习参考文，待完善
C语言学习笔记 Day16（C10文件管理--下）
给bug两拳的博客
09-04 1280
1、查询文件状态；2、文件的随机读写：fseek()、rewind()；3、文件的删除和重命名：remove()、rename()；4、文件缓冲区：基础概念、更新缓冲区
c语言2048游戏代码
05-29
以下是一个简单的C语言2048游戏代码： ``` #include #include #include // 定义游戏面板大小 #define BOARD_SIZE 4 // 定义游戏状态 typedef enum { GAME_NOT_OVER = 0, GAME_WIN, GAME_LOSE } GAME_STATE;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值