用c++写2048

最新推荐文章于 2024-07-19 09:25:33 发布
最新推荐文章于 2024-07-19 09:25:33 发布
阅读量3.1k 收藏 4
点赞数 2
分类专栏： c++算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010602606/article/details/47751007
版权

在一次面试过程中上机写出2048时间2个小时，但是没有写出来，后来工作的时候利用闲时自己写的供大家分享，发现其实2个小时是不够的。

当然还有一些头文件的包含等内容放在了basehead.h中此处省略

先把类结构贴出来

#pragma once
#include "BaseHead.h"

class CGame
{
public:
	friend ostream& operator<<(ostream &out, CGame game);

public:
	CGame(void);
	~CGame(void);

public:
	void init();

	void ZeroData();

	int randoms(int nRange = 0);

	 POINT getpos();

	 bool isFull();

	 bool isOver();

	 void run();

	 bool getDirectory();

	 void step();

	 bool DirectoryEnable();

	 void PosEnable();

	 void posUp();

	 void posDown();

	 void posLeft();

	 void posRight();

	 void DataEnable();
	 
	 void DataUp();

	 void DataDown();

	 void DataRight();

	 void DataLeft();

	 bool IsEnable(int (*temp)[4]);/*bool IsEnable(int temp[4][4]); bool Isable(int temp[][4])*/

	 bool IsEnable(int *temp);

private:
	bool operator==(CGame game);

	operator int*();

private:
	int _Data[ROW][COL];
	POINT _ptNew;
	TypeDirectory _type;
};


在编写过程中思路：

1.基本程序框架（略）

2.算法，4中不同方向移动过程中的怎样的算法能够保证所有的相等的数据都能合并在一起并且没有间隔

3.规则，怎样保证下一次的有效性，怎样保证程序over,怎样保证程序成功


算法说明：个人发现在4*4的空间中，需要来回两个循环可以保证所有的数据都合并但是还需要调整位置

规则说明：由于在算法的基础上，所以在判断是否产生移动不能够在通过函数的返回值类判断，需要先保存原来的数据成员然后跟移动后的数据对比，发生移动即为产生移动，在数据满的情况下，需要判断当前所有的数据是否还能够往某一个方向移动，同样在移动之前需要先保存最开始的数据，，当发现无法再进行移动之后程序over,当在其中有一个数据超过2048即为游戏完成

下面是程序的实现代码

#include "Game.h"

CGame::CGame(void)
{
	
}

CGame::~CGame(void)
{
}

ostream& operator<<(ostream &out, CGame game)
{
	game.run();

	return out;
}

void CGame::init()
{
	ZeroData();
	
	_ptNew = getpos();
	_Data[_ptNew.x][_ptNew.y]=2;

	_ptNew = getpos();
	_Data[_ptNew.x ][_ptNew.y]=2;
}

void CGame::ZeroData()
{
	for(int nrom = 0; ROW > nrom; nrom++)
	{
		for(int ncol = 0; COL > ncol; ncol++)
		{
			_Data[nrom][ncol] = 0;
		}
	}
}

int CGame::randoms(int nRange)
{
	if(0 == nRange)
	{
		return rand();
	}
	else
	{
		int nres = 0;
		do
		{
			nres = rand();
		}
		while(nRange <= nres);
		return nres;
	}
}

POINT CGame::getpos()
{
	POINT pt;
	do
	{
		pt.x = randoms(ROW);
		pt.y = randoms(COL);
	}
	while(_Data[pt.x][pt.y]);
	
	return pt;
}

bool CGame::isFull()
{
	bool bflage = true;
	for(int i = 0; ROW > i; i++)
	{
		for(int j = 0; COL > j; j++)
		{
			if(0 == _Data[i][j])
			{
				bflage = false;
				break;
			}
			else
			{
				if(2048 == _Data[i][j])
				{
					printf("game is win \n");
				}
			}
		}
	}

	return bflage;
}

bool CGame::isOver()
{
	CGame game = *this;//save
	bool bflage = false;

	CGame gametemp = *this;
	DataUp();
	posUp();
	bflage |= (*this == gametemp);

	gametemp = *this;
	if(!bflage)
	{
		run();
		printf("up bflage is %d\n",bflage);
		DataDown();
		posDown();
		bflage |= (*this == gametemp);
	}

	gametemp = *this;
	if(!bflage)
	{
		run();
		printf("down bflage is %d\n",bflage);
		DataLeft();
		posLeft();
		bflage |= (*this == gametemp);
	}

	gametemp = (*this);
	if(!bflage)
	{
		run();
		printf("left bflage is %d\n",bflage);
		DataRight();
		posRight();
		bflage |= (*this == gametemp);
	}
	
	if(!bflage)
	{
		run();
		printf(" down bflage is %d\n",bflage);
	}

	*this = game;//reserver

	return bflage;
}

void CGame::run()
{
	for(int nrow = 0; ROW > nrow; nrow++)
	{
		string sdata;
		for(int ncol = 0; COL > ncol; ncol++)
		{
			int ncount = 0;
			int nres = _Data[nrow][ncol]/10;
			 while(0 < nres)
			 {
				 nres /= 10;
				ncount++;
			 }
			int ntemp = _Data[nrow][ncol];
			 if(ntemp)
			 {
				printf("%d",ntemp);
				 for(int i = 0; ROW - ncount > i; i++)
				 {
					printf("%s"," ");
				 }
			 }
			 else
			 {
				printf("%s","0    ");
			 }
		}
		printf("\n");
	}
	printf("\n");
}

bool CGame::getDirectory()
{
	char ch;
	while(1)
	{
		ch = getch();
		switch(ch)
		{
		case 'a':
		case 'A':
			_type = LEFT_DIRE;
			break;
		case 'w':
		case 'W':
			_type = UP_DIRE;
			break;
		case 's':
		case 'S':
			_type = DOWN_DIRE;
			break;
		case 'd':
		case 'D':
			_type = RIGHT_DIRE;
			break;
		default:
			_type = NULL_DIRE;
			break;
		}
		if((_type == LEFT_DIRE) || (RIGHT_DIRE == _type) || (UP_DIRE == _type) || (DOWN_DIRE == _type)) 
		{
			break;
		}
		continue;
	}

	return true;
}

void CGame::step()
{
	system("cls");
	if(!DirectoryEnable()) 
	{
		return;
	}
		
	_ptNew = getpos();
	_Data[_ptNew.x][_ptNew.y] = 2;
	run();
	if(isFull() && !isOver())
	{
		printf("game is over\n");
	}
}

bool CGame::DirectoryEnable()
{
	bool bflage = false;
	
	int nTemp[4][4];
	for(int i = 0 ; ROW > i; i++)
	{
			for(int j = 0 ; COL > j; j++)
			{
				nTemp[i][j] = _Data[i][j];
			}
	}

	CGame game = *this;
	game.run();

	DataEnable();
	PosEnable();
	
	/*return IsEnable(nTemp);*/
	return *this == game;
}

bool CGame::IsEnable(int (*temp)[4])
{
	bool bflage = false;
	for(int i = 0; ROW > i; i++)
	{
		for(int  j = 0; COL > j; j++)
		{
			if(temp[i][j] != _Data[i][j])
			{
				bflage |= true;
				break;
			}
		}
	}

	return bflage;
}

bool CGame::IsEnable(int *temp)
{
	bool bflage =  false;
	for(int i = 0; ROW > i; i++)
	{
		for(int j =0; COL > j; j++)
		{
			if(_Data[i][j] != temp[j])
			{
				bflage |= true;
				break;
			}
		}
		temp += 4;
	}

	return bflage;
}

bool CGame::operator==(CGame game)
{
	bool bfalge = false;
	if(this != &game)
	{
		bfalge |= IsEnable(game);
	}

	return bfalge;
}

CGame::operator int*()
{
	
	return &_Data[0][0];
}

void CGame::PosEnable()
{
	switch(_type)
	{
	case UP_DIRE:
		posUp();
		printf("上\n");
		break;
	case DOWN_DIRE:
		posDown();
		printf("下\n");
		break;
	case LEFT_DIRE:
		posLeft();
		printf("左\n");
		break;
	case RIGHT_DIRE:
		posRight();
		printf("右\n");
		break;
	default:
		break;
	}
}

void CGame::posUp()
{
	for(int j = 0; COL > j; j++)
	{
		int k = ROW - 1;
		for(int i = 0; ROW > i; i++)
		{
			if(0 == _Data[i][j])
			{
				k = i;
				break;
			}
		}

		for(int i = k + 1; ROW > i; i++)
		{
			if(_Data[i][j])
			{
				_Data[k][j] = _Data[i][j];
				_Data[i][j] = 0;
				k = i;
			}
		}
	}
}

void CGame::posDown()
{
	for(int j = 0; COL > j; j++)
	{
		int k = 0;
		for(int i = ROW - 1; 0 <= i ; i--)
		{
			if(0 == _Data[i][j])
			{
				k = i;
				break;
			}
		}

		for(int i = k - 1; 0 <= i; i--)
		{
			if(_Data[i][j])
			{
				_Data[k][j] = _Data[i][j];
				_Data[i][j] = 0;
				k = i;
			}
		}
	}
}

void CGame::posLeft()
{
	for(int i = 0; ROW > i ; i++)
	{
		int k = COL - 1;
		for(int j = 0; COL > j; j++)
		{
			if(0 == _Data[i][j])
			{
				k = j;
				break;
			}
		}

		for(int j =  k+ 1; COL  > j; j++)
		{
			if(_Data[i][j])
			{
				_Data[i][k] = _Data[i][j];
				_Data[i][j] = 0;
				k = j;
			}
		}
	}
}

void CGame::posRight()
{
	for(int i = 0; ROW > i; i++)
	{
		int k = 0;
		for(int j = COL - 1; 0 <=  j; j--)
		{
			if(0 == _Data[i][j])
			{
				k = j;
				break;
			}
		}

		for(int j = k - 1; 0 <= j; j--)
		{
			if(_Data[i][j])
			{
				_Data[i][k] = _Data[i][j];
				_Data[i][j] = 0;
				k = j;
			}
		}
	}
}

void CGame::DataEnable()
{
	switch(_type)
	{
	case UP_DIRE:
		DataUp();
		break;
	case DOWN_DIRE:
		DataDown();
		break;
	case LEFT_DIRE:
		DataLeft();
		break;
	case RIGHT_DIRE:
		DataRight();
		break;
	default:
		break;
	}
}

void CGame::DataUp()
{
	for(int j = 0; COL > j; j++)
	{
		for(int k = 0; ROW -1 > k;k++)
		{
			if(_Data[k][j])
			{
				if(_Data[k+1][j])
				{
					if(_Data[k][j] == _Data[k+1][j])
					{
						_Data[k+1][j] += _Data[k][j];
						_Data[k][j] = 0;
					}
				}
				else
				{
					_Data[k + 1][j] = _Data[k][j];
					_Data[k][j] = 0;
				}
			}
		}
	}
	
	for(int j = 0; COL > j ; j++)
	{
		for(int k = ROW - 1; 1 <= k;k--)
		{
			if(_Data[k][j])
			{
				if(_Data[k - 1][j])
				{
					if(_Data[k][j] == _Data[k - 1][j])
					{
						_Data[k - 1][j]  += _Data[k][j];
						_Data[k][j] = 0;
					}
				}
				else
				{
					_Data[k - 1][j] = _Data[k][j];
					_Data[k][j] = 0;
				}
			}
		}
	}
}

void CGame::DataDown()
{
	for(int j = 0; COL > j ; j++)
	{
		for(int k = ROW - 1; 1 <= k;k--)
		{
			if(_Data[k][j])
			{
				if(_Data[k - 1][j])
				{
					if(_Data[k][j] == _Data[k - 1][j])
					{
						_Data[k - 1][j]  += _Data[k][j];
						_Data[k][j] = 0;
					}
				}
				else
				{
					_Data[k - 1][j] = _Data[k][j];
					_Data[k][j] = 0;
				}
			}
		}
	}

	for(int j = 0; COL > j; j++)
	{
		for(int k = 0; ROW -1 > k;k++)
		{
			if(_Data[k][j])
			{
				if(_Data[k+1][j])
				{
					if(_Data[k][j] == _Data[k+1][j])
					{
						_Data[k+1][j] += _Data[k][j];
						_Data[k][j] = 0;
					}
				}
				else
				{
					_Data[k + 1][j] = _Data[k][j];
					_Data[k][j] = 0;
				}
			}
		}
	}
}

void CGame::DataRight()
{
	for(int i = 0; ROW > i; i++)
	{
		for(int k = COL - 1; 0 < k; k--)
		{
			if(_Data[i][k])
			{
				if(_Data[i][k - 1])
				{
					if(_Data[i][k - 1] == _Data[i][k])
					{
						_Data[i][k-1] += _Data[i][k];
						_Data[i][k] = 0;
					}
				}
				else
				{
					_Data[i][k-1] = _Data[i][k];
					_Data[i][k] = 0;
				}
			}
		}
	}

	for(int i =0 ; ROW > i; i++	)
	{
		for(int k = 0; COL-1 > k; k++)
		{
			if(_Data[i][k])
			{
				if(_Data[i][k + 1])
				{
					if(_Data[i][k+1] == _Data[i][k])
					{
						_Data[i][k+1] += _Data[i][k];
						_Data[i][k] = 0;
					}
				}
				else
				{
					_Data[i][k + 1] = _Data[i][k];
					_Data[i][k] = 0;
				}
			}
		}
	}
}

void CGame::DataLeft()
{
	for(int i =0; ROW > i; i++)
	{
		for(int k = 0; COL- 1 > k; k++)
		{
			if(_Data[i][k])
			{
				if(_Data[i][k+1])
				{
					if(_Data[i][k+1] == _Data[i][k])
					{
						_Data[i][k+1] += _Data[i][k];
						_Data[i][k] = 0;
					}
				}
				else
				{
					_Data[i][k+1] = _Data[i][k];
					_Data[i][k] = 0;
				}
			}
		}
	}

	for(int i= 0; ROW > i; i++)
	{
		for(int k = COL - 1; 0 < k; k--)
		{
			if(_Data[i][k])
			{
				if(_Data[i][k-1])
				{
					if(_Data[i][k-1] == _Data[i][k])
					{
						_Data[i][k-1] += _Data[i][k];
						_Data[i][k] = 0;
					}
				}
				else
				{
					_Data[i][k - 1] = _Data[i][k];
					_Data[i][k] = 0;
				}
			}
		}
	}
}


程序的优化之处：其实数据移动的函数只需要两个即可，因为后面都为进行posenable,所以有两个函数式多余的。。。

运行结果可以自己实现


skyliny000
关注
专栏目录
2048（c++）
dataocean的博客
03-21 675
2048 输入2，4，8，16，32，64，128，256，512,1024的个数，计算出加出2048的最小次数 基本思路： 从最大的开始加，一旦达到2048就跳出，因为最初相加是用0加的，所以要减去这一次 #include<iostream> #include<string> using namespace std; int main() { int T,co...
C++实现2048小游戏（转载）
Mark_GXc的博客
01-20 2184
2048小游戏 话不多说，直接上代码 #include<iostream> #include<vector> #include<ctime> #include<cstdlib> using namespace std; class Game_2048 { public: Game_2048(); ~Game_2048(); void introduction(); bool judgeOver();
C/C++2048游戏[2024-07-09]
最新发布
程序设计
07-19 209
（6）当新用户的成绩需要插入排名列表时，要能够修改原列表信息；4、当界面不可运动时（当界面全部被数字填满时），游戏结束；当界面中最大数字是2048时，游戏胜利。（4）用户开始新游戏时，先检测是否有历史记录，有的话可以继续未完成的游戏，也可以重新开始。（5）实现用户排名功能，要求能够将排名信息进行保存，存至文件永久保存。2048游戏共有16个格子，初始时初始数字由2或者4构成。3、每次滑动时，空白处会随机刷新出一个数字的格子。2、相同数字的两个格子，相撞时数字会相加。（2）使用图形函数生成界面等。
c++2048代码
2401_83004157的博客
03-15 1096
case 'w':case 'W'://是否存在下面一个数字和自己的相同且不是0。case 's':case 'S'://是否存在上面一个数字和自己的相同且不是0。case 'a':case 'A'://是否存在右面一个数字和自己的相同且不是0。case 'd':case 'D'://是否存在左面一个数字和自己的相同且不是0。case 'w':case 'W'://有空位则下面的非空位往上移。case 's':case 'S'://有空位则上面的非空位往下移。
C++之2048
WANGYY130110的博客
11-05 1001
C++之2048
C++2048游戏
THDFB的博客
08-06 325
最近听说2048游戏挺好玩就上网找个玩，结果没有一个完整的所以我只好自己写一个了。 效果截图： ![在这里插入图片描述](https://img-blog.csdnimg.cn/ec32df362bbc4b2ab16a4c67dab2f573.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RIREZC,size_16,color_FFFFFF,.
用c++写2048小游戏
06-18
在C++中编写2048游戏，你需要了解基本的游戏规则和游戏循环结构。以下是简要的步骤： 1. **游戏基础**： - 创建一个二维数组（如二维整型数组）来表示游戏网格，每个格子存储数字（初始为0，之后根据操作随机填充1...
用C++写的2048游戏的设计与实现
08-20
此游戏用C++语言开发，带有图形界面，不需要运行环境，点击打开压缩包中的text.exe即可运行，用键盘W,S,A,D来控制游戏的上，下，左，右。是非常实用的小程序，可适用于大作业，课程设计，毕业设计等参考。
用C/C++写2048小游戏，代码完整版。
xiaowuguiya的博客
07-02 5749
此小游戏一个分为十四个函数，先简述其作用。 //用void是因为不需要返回值 //用int是需要返回值 void printf_array()//打印棋盘以及棋盘上的16个数组 void postion()//在棋盘随机产生2和4两个基本数 int judge_left() int judge_right() int judge_up() int judge_down()//这四个用来判断能否上下左右滑动 int judge_move(char ch)//判断游戏能否再继续 int move_left(
C/C++制作益智游戏：2048（源码详解）
pangzizzzz的博客
05-29 3190
前言 C/C++作为元老级的编程语言，任时光更迭依旧屹立不倒，哪怕如今炙手可热的AI，其底层也是用其编写。C/C++可以说是永不过时的语言。 那么作为新手该如何上手这门语言？一切不敲代码的学编程手段都是扯淡 今天小编就推荐一个适合新手练手的C/C++项目：制作益智游戏2048 话不多说，咱直接开始~ C/C++制作益智游戏2048 1.编译环境 Win10专业版x64 VS2015 2.项目运行效果 3.思路简介： 游戏规则： 游戏的规则很简单，你需要控制所有方块向同一个方向运动，两个相同数字的方块
C++ 2048 游戏的实现。
weixin_43122883的博客
05-19 2469
最近无聊，就玩了几遍2048这款游戏，下面我们就用C++来实现。 首先我们来描述一下2048游戏的规则； 1.游戏开始的时候，在一个4*4的二维空间，随机产生2或者4； 2.可以选择上下左右的滑动，如果遇到相同的数字，该数字乘2； 3.滑动结束后，检测是否有剩余的空间，如果有，则在该位置随机生成2或者4； 4.然后继续步骤2. 5.如果检测到有数字2048，游戏胜利，则游戏结束；无法继续滑动，游戏...
C++版2048游戏
07-20
C++版的2048游戏，窗体界面开发，分数使用文件进行存储 基本功能： 1.主界面显示----按1键开始游戏---按2键规则介绍---按3键查看历史分数----按4键退出游戏 2.游戏规则界面显示----规则显示---按任意键返回主界面 3.历史分数界面显示----历史分数显示----按任意键返回主界面 4.游戏界面显示----分数显示----时间显示----合成最大数字的显示 5.颜色设置和位置跳转----设置文字的颜色----鼠标光标位置的跳转 6.随机显示2或4----生成数字1-10----[0,6]生成2----[7,10]生成4 7.键盘事件监听----WASD或上下左右键控制数字的移动 8.数字移动和合并----移动->合并->移动 9.判断游戏状态----胜利-----合成2048即为胜利 10.判断游戏状态----失败-----16格子全部都有数字且全盘不能移动即为失败 11.信息显示----分数的实时显示----显示游戏用时----显示合成最大数字---执行步数 12.游戏结束显示----显示游戏用时和游戏分数 13.保存本次的分数到历史记录----记录所有分数，保存到文本文件中 14.重新开始状态处理---重置所有信息----或----重新加载游戏界面
2048小游戏C++程序代码
11-18
2048小游戏的c++程序，可供C++初学者学习、玩味。
c++游戏2048
12-26
C++实现的最近非常火的2048小游戏，需要者可以酌情下载
2048 c++code
05-04
2048游戏,C++版本源代码,glut插件实现
2048c++代码
04-15
2048 游戏c++代码实现，dos界面实现，数组，遍历数组，
利用c++实现2048
qq_47705074的博客
08-04 472
#include <bits/stdc++.h> #include <stdlib.h> #include <time.h> #include <conio.h> #include<iostream> #include <cmath> #include <climits> #include <cstring> #include <string> #include <algorithm> #
c++小游戏——2048
ShineEternal的笔记小屋
10-04 307
#include <stdio.h> #include <time.h> #include <conio.h> #include <windows.h> void start_game(); void reset_game(); void move_left(); void move_r...
用C++实现2048
只是个菜鸡
12-12 7975
没事做了一个小程序2048游戏，可以试一下作者博客#include #include #include #include #include #include using namespace std; int mp[4][4],score; bool map[4][4]; bool cal[4][4]; void DeBug() { for(int i=0;i<4;++i){
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值