C语言实现2048小游戏

最新推荐文章于 2023-12-07 18:16:18 发布
最新推荐文章于 2023-12-07 18:16:18 发布
阅读量1.5k 收藏 7
点赞数 1
文章标签： c语言 数学建模 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31716541/article/details/131139748
版权

大部分同学学习C语言编程以后不知道能通过什么样的项目才可以锻炼自己的思维功力，2048相信大家都应该熟悉，不管是手机上还是网页版的相信大家都玩过,这个简单的控制台版本的游戏是我曾经在伟易达上班时一个嵌入式应用游戏部门的大佬设计的，适合于喜欢用C语言写一些简易的游戏的朋友,逻辑性很强。

一、2048游戏原理

在最初的游戏, 它始于一个空4 x 4游戏板。

1)在空位置的游戏板上，每一轮游戏产生一个“2”或“4”随机的数字。

2)接下来,玩家输入的上移，下移，左移或右移命令移动块。两个相邻块相同的号码,若是Q,可以组合成一个块数量2Q。

3)如果没有空间产生一个新的数字块,玩家则game over。

4)想赢得游戏,玩家需要产生一块2048数字块。

二、2048游戏文档

当然，这些游戏的逻辑不是大家闷着脑子就能空想出来的，它一定有很规范的说明文档，由专业的人来书写，最后软件工程师参考对应的文档编写自己的代码

篇幅有限，详细的下载链接：

链接：https://pan.baidu.com/s/1Daan58WN-A95BeYQcmSyDA
提取码：m6ie

当然也可以访问Github网站，这是一个开源的项目，后面各位牛逼的大佬经过移植后，运行在各个平台下，原版本链接如下:

http://gabrielecirulli.github.io/2048/

三、2048游戏源代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <conio.h>

//num
#define FALSE	0
#define TRUE	1

#define EMPTY_CELL     	0

#define GMAE_ROW	 	4
#define GMAE_COL		4

//GameState
#define STATE_SELECT   	0
#define STATE_PREPARE  	1
#define STATE_PALYING  	2
#define STATE_EXIT      3

//GameMode
#define MODE_NONE      	0
#define MODE_NORMAL    	1
#define MODE_DEBUG     	2

//Select Index
#define INDEX_MAXNUM    3
#define INDEX_NORMAL    0
#define INDEX_DEBUG     1
#define INDEX_EXIT      2

//Command
#define COM_LEFT		'a'
#define COM_RIGHT		'd'
#define COM_UP			'w'
#define COM_DOWN 		's'
#define COM_QUIT		'q'

//direction
#define DIR_HEAD        0xe0
#define KEY_UP			0xe048
#define KEY_DOWN 		0xe050
#define KEY_LEFT		0xe04b
#define KEY_RIGHT		0xe04d


#define ESC 			0x1B
#define ENTER			0x0D

//type
typedef unsigned int    Uint;
typedef unsigned short  Ushort;
typedef unsigned char   Uchar;

//declaration
static void GM_Init(void);
static void GM_End(void);

static Uint GM_SelectInit(void);
static Uint GM_SelectHandle(void);
static Uint GM_SelectEnd(void);

static Uint GM_PrepareInit(void);
static Uint GM_PrepareHandle(void);
static Uint GM_PrepareEnd(void);

static Uint GM_PlayingInit(void);
static Uint GM_PlayingHandle(void);
static Uint GM_PlayingEnd(void);


static Uint GM_SelectHandleEnter(void);
static Uint GM_SelectHandleEsc(void);
static void GM_PrintSelectMode(void);
static void GM_RandAddOneNum(void);
static Uchar GM_FromFileAddNum(void);
static Uchar GM_InputAddOneNum(void);
static Uchar GM_NotMoreMove(void);
static void GM_PrintBoard(void);

static Uchar GM_CheckWin2048(void);
static Uchar GM_PlayingPull(void);
static Uchar GM_CombineRight(Uint *array, int num);
static Uchar GM_CombineLeft(Uint *array, int num);
static Uchar GM_MoveRight(Uint *array, int num);
static Uchar GM_MoveLeft (Uint *array, int num);

//struct
typedef  struct gameinfo {
	Uint  Board[GMAE_ROW][GMAE_COL];
	
	Uchar GameState;
	Uchar GameMode;
	
	Uchar StateSelectIndex;
	
	Uint  PlayingCommand;
	
}GameInfo, *P_GameInfo;

GameInfo GM;

int main(void)
{
	GM_Init();

	while(1)
	{	
		switch(GM.GameState)
		{
			case STATE_SELECT:		
				GM_SelectHandle();	
				break;
			case STATE_PREPARE:
				GM_PrepareHandle();
				break;	
			case STATE_PALYING:
				GM_PlayingHandle();
				break;	
			case STATE_EXIT:
			    goto GAME_EXIT;
			default:
				break;	  	
		}	       	   
    }

GAME_EXIT:
    GM_End();
    return 0;	
}

static void GM_Init(void)
{
	memset(&GM, 0, sizeof(GameInfo));
	srand((int)time(NULL));
	
	GM_SelectInit();
}

static void GM_End(void)
{	
	memset(&GM, 0, sizeof(GameInfo));	
	
	fflush(stdin);	
	printf("\nCommand [q] can quit\n");
	while('q' != getch());
	
}

static Uint GM_SelectInit(void)
{
	GM.GameState = STATE_SELECT;
    GM.StateSelectIndex = INDEX_NORMAL;
	GM_PrintSelectMode();
}

static Uint GM_SelectHandle(void)
{	
	GM_PrintSelectMode();	
	
    fflush(stdin);
    Uchar  ch1 = getch();
	if( ENTER == ch1)
	{
		GM_SelectHandleEnter();	
	}
	else if( ESC == ch1 )
	{	
		GM_SelectEnd();
		GM.GameState = STATE_EXIT;
	}
	else if ( DIR_HEAD == ch1)
	{
		Uchar  ch2 = getch();
		Ushort Key = (ch1 << 8)&0xff00 | ch2;
		switch(Key)
		{	    
			case KEY_UP:
				GM.StateSelectIndex = (GM.StateSelectIndex + INDEX_MAXNUM - 1) % INDEX_MAXNUM;
				break;
			
			case KEY_DOWN:
				GM.StateSelectIndex = (GM.StateSelectIndex + 1) % INDEX_MAXNUM;
				break;

			default:
				break;	
		}
	}
}

static Uint GM_SelectEnd(void){}


static Uint GM_PrepareInit(void)
{
	Uchar OldState = GM.GameState;
    GM.GameState = STATE_PREPARE;
	
	//from STATE_SELECT -->  STATE_PREPARE
	if(STATE_SELECT == OldState)
	{
		if(MODE_NORMAL == GM.GameMode)
		{
			GM_RandAddOneNum();
			GM_RandAddOneNum();	
		}
		else
		{
			GM_FromFileAddNum();	
		}
	}	
	//from STATE_PALYING -->  STATE_PREPARE
	else
	{
		if(MODE_NORMAL == GM.GameMode)
		{
			GM_RandAddOneNum();
		}
		else
		{
			GM_PrintBoard();		
			while(FALSE == GM_InputAddOneNum());
		}	
	}
	GM_PrintBoard();
}

static Uint GM_PrepareHandle(void)
{
	if(TRUE != GM_NotMoreMove())
	{
	    GM_PrepareEnd();
		GM_PlayingInit();
	}
	else
	{
		printf("Game Over!\n");	
		GM.GameState = STATE_EXIT;	
	}	
	
}

static Uint GM_PrepareEnd(void){}

static Uint GM_PlayingInit(void)
{
	GM.GameState = STATE_PALYING;
	printf( "PULL: [a]LEFT [d]RIGHT [w]UP [s]DOWN [q]QUIT\n" );	
	printf( "Command: ");
    fflush(stdout);
}

static Uint GM_PlayingHandle(void)
{		
	fflush(stdin);
	GM.PlayingCommand = getch();

	
	switch(GM.PlayingCommand)
	{
		case COM_LEFT:
		case COM_RIGHT:
		case COM_UP:
		case COM_DOWN:
			if( FALSE == GM_PlayingPull())
			{	
				printf("[Error] invalid direction\n");		
				printf( "Command: ");	
			}
			else
			{
				if( TRUE == GM_CheckWin2048() )
				{
					GM_PrintBoard();
					printf("you win !\n");
					GM.GameState = STATE_EXIT;
				}
				else
				{
					GM_PlayingEnd();
					GM_PrepareInit();
				}
			}
			break;
		case COM_QUIT:
			printf("Bye !\n");	
			GM.GameState = STATE_EXIT;	
			break;
		default:
			printf("[Error] Command is a, d, w, s, q \n");
			printf( "Command: ");
			fflush(stdout);
			break;
	}
	//GM_PrintBoard();
}

static Uint GM_PlayingEnd(void)
{
	GM.PlayingCommand = 0;
}


static Uint GM_SelectHandleEnter(void)
{
	switch(GM.StateSelectIndex)
	{
		case INDEX_NORMAL:			
		case INDEX_DEBUG:
		    if(INDEX_NORMAL == GM.StateSelectIndex)
			{
				GM.GameMode = MODE_NORMAL;
			}
		    else
			{
				GM.GameMode = MODE_DEBUG;
			}
			GM_SelectEnd();
			GM_PrepareInit();
			break;
			
		case INDEX_EXIT:
			GM_SelectEnd();
			GM.GameState = STATE_EXIT;	
			break;
			
		default:
			printf("error\n");
			break;
	}					
		
}

static Uint GM_SelectHandleEsc(void){}


static void GM_PrintSelectMode(void)
{
	system("cls");
	printf("# -  -  -  -  -  -  -  - #\n");
	printf("#     welcome to 2048    #\n");	
	printf("# -  -  -  -  -  -  -  - #\n");		
	printf("      MODU  SELECT        \n");
	
	printf("\n      ");
	printf(GM.StateSelectIndex==INDEX_NORMAL?"-->NORMAL":"   NORMAL");	 
    printf("\n      ");	
	printf(GM.StateSelectIndex==INDEX_DEBUG? "-->DEBUG ":"   DEBUG ");
	printf("\n      ");	
	printf(GM.StateSelectIndex==INDEX_EXIT?  "-->EXIT  ":"   EXIT  ");
}


static void GM_RandAddOneNum(void)
{
	int row, col;
		
	while (1)
	{
		row = rand() % GMAE_ROW;
		col = rand() % GMAE_COL;
		if ( GM.Board[row][col] == EMPTY_CELL )
		{
			GM.Board[row][col] = ((rand() % 2) + 1) * 2;
			break;
		}
	}	
}

static Uchar GM_FromFileAddNum(void)
{
	FILE  *infp;
	Uchar tmp[6],tmp1;
	Uchar ret = 0;
	Uchar i,j;
	
	if(infp = fopen("map.txt", "rb"))
	{
	    for(i = 0; i < GMAE_ROW * GMAE_COL; i++)
		{
			j = 0;
			memset(tmp, 0, sizeof(tmp));
			while(1)
			{
				if(!fread(&tmp[j], 1, 1, infp))
					ret |= 0x02;
				
				if(tmp[j] == ' ' || tmp[j] == '\n' || tmp[j] == 0)
					break;
				
				j++;	
			}	
			*(&GM.Board[0][0]+i) =  atoi((const char *)tmp);		
		}
	}
	else
	{
		ret |= 0x01;
	}
	
	if(NULL != infp)
	{
		fclose(infp);
	}
	
	if(ret != 0)
	{
		printf("read map txt fail\n");
	}
	return ret;
				
}

static Uchar GM_InputAddOneNum(void)
{
	int row, col, value;
	int ret = TRUE;
	printf("please input add one num！\n");
	printf("Row,Col,Value :");
	fflush(stdout);
	fflush(stdin);
	scanf("%d,%d,%d", &row, &col, &value);
		
	if(row >= GMAE_ROW || row < 0)
	{
		printf("[Error] Row is between 0 and %d !\n", GMAE_ROW-1);
		ret = FALSE;
	}
	
	if(col >= GMAE_COL || col < 0)
	{
		printf("[Error] Col is between 0 and %d !\n", GMAE_COL-1);
		ret = FALSE;
	}	
	
	if(ret == TRUE && GM.Board[row][col] != 0)
	{
		printf("[Error] ( %d , %d ) is occupied!\n", row, col);
		ret = FALSE;
	}
	
	if(value != 2 && value != 4)
	{
		printf("[Error] Cell Value is either 2 or 4\n");
		ret = FALSE;
	}
	
	if(ret == TRUE)
	{
		GM.Board[row][col] = value;
	}
	return ret;
}

static Uchar GM_NotMoreMove(void)
{
	int NotMoreMove = TRUE;
	int row, col;
	for ( row = 0; row < GMAE_ROW; row++)
	{
		for ( col = 0; col < GMAE_COL; col++)
		{		
			if(GM.Board[row][col] == 0)
			{
				NotMoreMove = FALSE;
				break;	
			}
			
			if( col+1 < GMAE_COL && GM.Board[row][col] == GM.Board[row][col+1])
			{
				NotMoreMove = FALSE;
				break;
			}	
			
			if( row+1 < GMAE_ROW && GM.Board[row][col] == GM.Board[row+1][col])
			{
				NotMoreMove = FALSE;	
			    break;	
			}							
		}
		if(FALSE == NotMoreMove)
			break;
	}	
	return NotMoreMove;
}

static void GM_PrintBoard(void)
{
	int row, col;	
	system("cls");
	printf("# -  -  -  -  -  -  -  - #\n");
	printf("#     welcome to 2048    #\n");	
	printf("# -  -  -  -  -  -  -  - #\n");	
	for ( row = 0; row < GMAE_ROW; row++)
	{
		for ( col = 0; col < GMAE_COL; col++)
		{
			printf(" + - -", GM.Board[row][col]);
		}
		printf(" +\n");
		for ( col = 0; col < GMAE_COL; col++)
		{
			if(0 == GM.Board[row][col])
				printf(" |    ");
			else	
				printf(" |%4d", GM.Board[row][col]);
		}
		printf(" |\n");
	}
	printf(" + + + + + + + + + + + + + \n");	
	
}

static Uchar GM_CheckWin2048(void)
{
	int row,col;
	 
	for ( row = 0; row < GMAE_ROW; row++)
	{
		for ( col = 0; col < GMAE_COL; col++)
		{
			if( GM.Board[row][col] == 2048 )
			{
				return TRUE;	
			}			
		}
	}			
	return FALSE;
}

static Uchar GM_PlayingPull(void)
{
	//GMAE_ROW  行 4
	//GMAE_COL  列 4	
	
	int index;
	int col, row;
	Uchar PullFlag = FALSE;
	Uint array[GMAE_ROW > GMAE_COL? GMAE_ROW:GMAE_COL];

	//******************COM_LEFT*******************
	if( COM_LEFT == GM.PlayingCommand)	
	for ( row = 0; row < GMAE_ROW; row++)
	{
		PullFlag |= GM_MoveLeft( (Uint *)GM.Board[row], GMAE_COL );
		PullFlag |= GM_CombineLeft( (Uint *)GM.Board[row], GMAE_COL );
		PullFlag |= GM_MoveLeft( (Uint *)GM.Board[row], GMAE_COL );	
	}
		
	//******************COM_RIGHT******************	
	else if( COM_RIGHT == GM.PlayingCommand)	
	for ( row = 0; row < GMAE_ROW; row++)
	{	
		PullFlag |= GM_MoveRight( (Uint *)GM.Board[row], GMAE_COL );
		PullFlag |= GM_CombineRight( (Uint *)GM.Board[row], GMAE_COL );
		PullFlag |= GM_MoveRight( (Uint *)GM.Board[row], GMAE_COL );		
	}
		
	//******************COM_UP*********************
	else if( COM_UP == GM.PlayingCommand)			
	for ( col = 0; col < GMAE_COL; col++)
	{
		for ( row = 0; row < GMAE_ROW; row++)
		{
			array[row] = GM.Board[row][col];				
		}
		
		//a col move Left		
		PullFlag |= GM_MoveLeft( (Uint *)array, GMAE_ROW );
		PullFlag |= GM_CombineLeft( (Uint *)array, GMAE_ROW );
		PullFlag |=	GM_MoveLeft( (Uint *)array, GMAE_ROW );	
				
		//write a col
		for ( row = 0; row < GMAE_ROW; row++)
		{
			GM.Board[row][col] = array[row];				
		}			
	}		

	//******************COM_DOWN******************
	else if( COM_DOWN == GM.PlayingCommand)			
	for ( col = 0; col < GMAE_COL; col++)
	{	
		//read a col
		for ( row = 0; row < GMAE_ROW; row++)
		{
			array[row] = GM.Board[row][col];				
		}
		
		//a col move right		
		PullFlag |= GM_MoveRight( (Uint *)array, GMAE_ROW );
		PullFlag |= GM_CombineRight( (Uint *)array, GMAE_ROW );	
		PullFlag |=	GM_MoveRight( (Uint *)array, GMAE_ROW );
	
		//write a col
		for ( row = 0; row < GMAE_ROW; row++)
		{
			GM.Board[row][col] = array[row];				
		}									
	}		

	return 	PullFlag;	
}

static Uchar GM_CombineLeft(Uint *array, int num)
{
	int i;
	Uchar CombineFlag = FALSE;
	for ( i = 0; i < num-1; i++ )
	{
		if( array[i] != 0 && array[i] == array[i+1] )
		{
			array[i]  *= 2;
			array[i+1] = 0;
			CombineFlag = TRUE;
		}						
	}		
	return CombineFlag;
}


static Uchar GM_CombineRight(Uint *array, int num)
{
	int i;
	Uchar CombineFlag = FALSE;
	for ( i = num-1; i >= 1; i-- )
	{
		if( array[i] != 0 && array[i] == array[i-1] )
		{
			array[i]  *= 2;
			array[i-1] = 0;
			CombineFlag = TRUE;
		}						
	}		
	return CombineFlag;
}


static Uchar GM_MoveRight(Uint *array, int num)
{
	int i;
	int index = num - 1;
	Uchar moveflg = FALSE;
		
	for(i = num-1; i >= 0; i--)
	{
		
		if(array[i] != 0)
		{
			if(array[i] != array[index])
			{
				array[index] = array[i];							
				moveflg = TRUE;
			}	
			index--;			
		}		
	}
	
	while(index != -1)
	{
		array[index] = 0;
		index--;
	}
	
	return moveflg;
	
}


static Uchar GM_MoveLeft(Uint *array, int num)
{
	int i;
	int index = 0;
	Uchar moveflg = FALSE;
		
	for(i = 0; i < num; i++)
	{
		
		if(array[i] != 0)
		{
			if(array[i] != array[index])
			{
				array[index] = array[i];							
				moveflg = TRUE;
			}	
			index++;			
		}		
	}
	
	while(index != num)
	{
		array[index] = 0;
		index++;
	}
	
	return moveflg;
	
}
 

四、运行结果
 

 

游戏主菜单界面，通过方向键选择，分别有NORMAL(正常进行游戏)、DEBUG(调试模式)、EXIT(退出游戏)
 

按回车键进入对应的模式。
 

 

用字母a、d、w、s、q分别代替左右上下以及退出键。
 

如果最后游戏成功了，则会提示成功，如果失败则会退出程序。
 

详细的游戏逻辑可通过代码以及文档进行了解。
 

 

-- End --
 

 

                

        

        

    




    

      

        

            

              
                
                  「已注销」
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    7
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
【C语言小游戏】2048

				
			

			

				

					走向CTO的路上...
				

				

					08-03
					
					664
					
				

			

		

		

			
				
每次移动操作，所有数字方块会朝着指定方向同时滑动，并在靠近边界或其他数字方块时停止。如果两个相邻的数字方块数字相同，则它们会合并成一个方块，数字值为原先相同方块的数字值相加。2048是一款数字益智类游戏，玩家需要使用键盘控制数字方块的移动，合并相同数字的方块，最终达到数字方块上出现“2048”的目标。

			
		

	



                

              
                



	

		

			

				
					
2048小游戏C语言实现代码

				
			

			

				

					08-27
				

			

		

		

			
				
主要为大家详细介绍了2048小游戏C语言实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

			
		

	



                


  
              

                


	

		

			

				
					
2048小游戏的C语言实现方式

				
			

			

				

					T、的博客
				

				

					06-22
					
					4582
					
				

			

		

		

			
				
项目介绍：每次可以选择上下左右其中一个方向去滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢外，系统也会在空白的地方随机出现一个数字方块2或4，相同数字的方块在靠拢、相撞时会相加。不断的叠加最终拼凑出2048这个数字就算成功。

...

			
		

	





	

		

			

				
					
纯C语言2048，超详细

				
			

			

				

					zhou_zhou_04的博客
				

				

					01-23
					
					9126
					
				

			

		

		

			
				
突然想写2048，就模仿人家写的2048，写了2048，但有所改良😁（改良了一点小毛病，但绝大部分都一样）

			
		

	



		

			
		



	

		

			

				
					
C语言2048源码

				
			

			

				

					lxylxylxy的博客
				

				

					11-26
					
					1353
					
				

			

		

		

			
				
在运行的窗口实现，该代码也是编写图形模式的基础详细解释看我之前的那篇不过本文多了记分功能，还有历史最高分对比。

			
		

	





	

		

			

				
					
2048游戏（C语言）

				
			

			

				

					Qqmnz的博客
				

				

					08-27
					
					4713
					
				

			

		

		

			
				
2048游戏C语言代码是通过文件链接的方式实现的，主要的文件包含main.c（代码实现入口文件）、game2048.c（游戏内容处理）、game2048.h（头文件）、direction.c（方向键处理）、derection.h（头文件）、tools.c（显示界面、随机位置生成2、判断是否失败）、tools.h（头文件），下面也展现了它的 makefile 文件。......

			
		

	





	

		

			

				
					
【知识教程】C语言编写2048

				
			

			

				

					C语言C++学习俱乐部：765860056
				

				

					01-30
					
					4782
					
				

			

		

		

			
				
一、游戏介绍

《2048》是较流行的一款数字游戏。原版2048首先在github上发布，原作者是Gabriele Cirulli。它是基于《1024》和《小3传奇》（Threes!）的玩法开发而成的新型数字游戏。





二、游戏规则

游戏的规则很简单，你需要控制所有方块向同一个方向运动，两个相同数字的方块撞在一起之后合并成为他们的和，每次操作之后会在空白的方格处随机生成一个2或者4（生成2的概率要大一些），最终得到一个“2048”的方块就算胜利了。

三、核心算法

1、方块移动和合并算法。

主.

			
		

	





	

		

			

				
					
C语言 2048源码（每步细致讲解更新ing）

					
热门推荐

				
			

			

				

					weixin_44954896的博客
				

				

					04-30
					
					2万+
					
				

			

		

		

			
				
前言
提示：这里可以添加本文要记录的大概内容：
昨天晚上突然想用c写个2048，觉得学了这么久，没写点什么东西有点心空空，就乘着备考时间来写写看，以前就想过，也就想想，一直没去写，今天没什么课，而且还是网课，然后就先看看别人写的代码之后，自己理解之后又重新敲了一遍，写了一天也算是写了个简易的2048。
2048的代码也不难，主要就是使用数组对数组的操作，再对数组移动改变的时候的逻辑清楚就没问题了。
写的很仓促，代码不怎么好看，以后有时间会慢慢优化并增加一些功能。

提示：以下是本篇文章正文内容，下面案例可.

			
		

	





	

		

			

				
					
C语言实现2048

				
			

			

				

					hb_hltall的博客
				

				

					11-06
					
					4764
					
				

			

		

		

			
				
C语言实现2048小游戏
众所周知，推箱子、2048、贪吃蛇被称为大学编程课三大经典小项目。很多刚学编程的小伙伴都想写出一个自己的小游戏，这次介绍其中的2048。
游戏规则：WASD移动，V撤回，P主动结束游戏。
数字会显示颜色，不同数值颜色不尽相同。
可以设置游戏行列大小以及难度。
可在windows下运行，根据注释提示修改部分函数名之后也能在linux下运行。
移动算法思路如图：

源代码如下：欢迎讨论。
#include"tzfe.h"

int ttafe[X][Y] = {0};
int efat

			
		

	





	

		

			

				
					
C语言——2048完整版

					
最新发布

				
			

			

				

					cjy040921的博客
				

				

					12-07
					
					2511
					
				

			

		

		

			
				
2048

			
		

	





	

		

			

				
					
用C语言实现2048小游戏

				
			

			

				

					07-02
				

			

		

		

			
				
就一个.c文件，打开即可使用

			
		

	





	

		

			

				
					
Linux环境C语言实现2048小游戏

				
			

			

				

					04-29
				

			

		

		

			
				
Linux环境C语言实现2048小游戏，支持方向键控制，记录步数和相应得分

			
		

	





	

		

			

				
					
利用C语言实现2048小游戏的方法

				
			

			

				

					12-31
				

			

		

		

			
				
首先上一张图，因为这里只是在用C语言验证算法，所以没有对界面做很好的优化，丑是理所应当的。    了解了游戏的工作原理，实际上可以将游戏描述为四个带有方向的同一操作：  1、将所有数字向一个方向移动至中间...

			
		

	





	

		

			

				
					
C语言用顺序表实现的2048小游戏源代码

				
			

			

				

					pen_pen_的博客
				

				

					01-28
					
					1758
					
				

			

		

		

			
				
使用顺序表来实现的2048小游戏

一、构造结构体
1、构造一个大小为十六顺序表结构体
#define DATA 16
typedef struct Node
{
	int data[DATA];
	int length;
}Node,*NodePtr;

二、顺序表的初始化
1、以下代码是顺序表初始化开辟64个字节大小的空间
void Init2048(NodePtr sizestrlen)
{...

			
		

	





	

		

			

				
					
C语言版---2048小游戏，简单易懂，看过就会

				
			

			

				

					AABond的博客
				

				

					08-24
					
					6131
					
				

			

		

		

			
				
C语言版---2048小游戏，简单易懂，看过就会，做小游戏如此简单

			
		

	





	

		

			

				
					
C/C++项目实战：《2048》，900行源码带你完美实现经典数字游戏

				
			

			

				

					致力于C语言C++知识分享！
				

				

					01-14
					
					5231
					
				

			

		

		

			
				
这是个益智游戏，规则很简单，按上、下、左、右键，使游戏区域的所有方块向该方向滑动，每次滑动时，相碰的两个相同数字会合并。同时，空白的地方也会在随机出现一个数字方块（2 或者 4）。游戏目标，是想办法合成 2048 这个数字方块。

			
		

	





	

		

			

				
					
【C语言实现游戏】（三）2048游戏

				
			

			

				

					wqnhbskl的博客
				

				

					11-12
					
					1万+
					
				

			

		

		

			
				
前言

游戏规则：游戏开始，在4x4的棋盘上随机两个方块出现数字2，通过方向键控制所有方块向同一个方向移动，两个相同数字方块撞在一起之后合并成为他们的和。每次移动，棋盘上都会在一个随机位置增加一个数字2，相同的数字会相加合并到一起，最终得到一个“2048”的方块就算胜利了。

简单吧？简单……个鬼啊，我以前玩了几个小时都失败了最后放弃了。



一、游戏思路



1、程序开始时出现菜单，让玩家选择开始游戏或者退出游戏。

2、玩家选择开始游戏后，出现棋盘，通过方向键选择移动的方向。

...

			
		

	





	

		

			

				
					
2048小游戏（C语言实现）

				
			

			

				

					Scholar618的博客
				

				

					05-13
					
					2546
					
				

			

		

		

			
				
2048小游戏（C语言实现）

			
		

	





	

		

			

				
					
2048c语言程序,C语言实现2048小游戏

				
			

			

				

					06-07
				

			

		

		

			
				
下面是一个简单的C语言实现2048小游戏的程序，仅供参考：

```
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROWS 4
#define COLS 4

int board[ROWS][COLS];

void init_board()
{
    int i, j;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            board[i][j] = 0;
        }
    }
}

void print_board()
{
    int i, j;
    printf("\n");
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            printf("%d\t", board[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int generate_random_number(int min, int max)
{
    int num;
    srand(time(NULL));
    num = (rand() % (max - min + 1)) + min;
    return num;
}

void generate_new_number()
{
    int i, j;
    int num = generate_random_number(1, 2) * 2;
    do {
        i = generate_random_number(0, ROWS - 1);
        j = generate_random_number(0, COLS - 1);
    } while (board[i][j] != 0);
    board[i][j] = num;
}

void move_left()
{
    int i, j, k;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS - 1; j++) {
            for (k = j + 1; k < COLS; k++) {
                if (board[i][k] != 0) {
                    if (board[i][j] == 0) {
                        board[i][j] = board[i][k];
                        board[i][k] = 0;
                        j--;
                    } else if (board[i][j] == board[i][k]) {
                        board[i][j] *= 2;
                        board[i][k] = 0;
                    }
                    break;
                }
            }
        }
    }
}

void move_right()
{
    int i, j, k;
    for (i = 0; i < ROWS; i++) {
        for (j = COLS - 1; j > 0; j--) {
            for (k = j - 1; k >= 0; k--) {
                if (board[i][k] != 0) {
                    if (board[i][j] == 0) {
                        board[i][j] = board[i][k];
                        board[i][k] = 0;
                        j++;
                    } else if (board[i][j] == board[i][k]) {
                        board[i][j] *= 2;
                        board[i][k] = 0;
                    }
                    break;
                }
            }
        }
    }
}

void move_up()
{
    int i, j, k;
    for (j = 0; j < COLS; j++) {
        for (i = 0; i < ROWS - 1; i++) {
            for (k = i + 1; k < ROWS; k++) {
                if (board[k][j] != 0) {
                    if (board[i][j] == 0) {
                        board[i][j] = board[k][j];
                        board[k][j] = 0;
                        i--;
                    } else if (board[i][j] == board[k][j]) {
                        board[i][j] *= 2;
                        board[k][j] = 0;
                    }
                    break;
                }
            }
        }
    }
}

void move_down()
{
    int i, j, k;
    for (j = 0; j < COLS; j++) {
        for (i = ROWS - 1; i > 0; i--) {
            for (k = i - 1; k >= 0; k--) {
                if (board[k][j] != 0) {
                    if (board[i][j] == 0) {
                        board[i][j] = board[k][j];
                        board[k][j] = 0;
                        i++;
                    } else if (board[i][j] == board[k][j]) {
                        board[i][j] *= 2;
                        board[k][j] = 0;
                    }
                    break;
                }
            }
        }
    }
}

int check_game_over()
{
    int i, j;
    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++) {
            if (board[i][j] == 0) {
                return 0;
            }
            if (i < ROWS - 1 && board[i][j] == board[i + 1][j]) {
                return 0;
            }
            if (j < COLS - 1 && board[i][j] == board[i][j + 1]) {
                return 0;
            }
        }
    }
    return 1;
}

int main()
{
    int choice;
    init_board();
    generate_new_number();
    generate_new_number();
    print_board();
    do {
        printf("Enter your choice (1: left, 2: right, 3: up, 4: down): ");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                move_left();
                break;
            case 2:
                move_right();
                break;
            case 3:
                move_up();
                break;
            case 4:
                move_down();
                break;
            default:
                printf("Invalid choice!");
                break;
        }
        if (!check_game_over()) {
            generate_new_number();
            print_board();
        } else {
            printf("Game over!");
            break;
        }
    } while (1);
    return 0;
}
```

程序中使用了一个二维数组 `board` 来表示2048游戏的棋盘，其中每个元素代表棋盘上的一个格子，初始值为0。`generate_random_number` 函数用来生成一个随机数，`generate_new_number` 函数用来在空格子上生成一个新的数字。`move_left`、`move_right`、`move_up`、`move_down` 函数分别用来实现向左、向右、向上、向下移动格子的操作。`check_game_over` 函数用来检查游戏是否结束。

在 `main` 函数中，程序先初始化棋盘，生成两个初始数字，并输出棋盘。然后进入循环，每次循环中用户输入一个操作，程序根据用户的选择更新棋盘，并检查游戏是否结束。如果游戏没有结束，则生成一个新的数字并输出棋盘。如果游戏结束，程序退出循环并输出 "Game over!"。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值