九折俄罗斯方块？我上我也行！

最新推荐文章于 2024-11-17 16:56:14 发布
最新推荐文章于 2024-11-17 16:56:14 发布
阅读量1.7k 收藏 1
点赞数 8
分类专栏： C++学习 文章标签： c++ 游戏 程序人生 其他 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vangoudan/article/details/107573561
版权

如果你对其他的C++案例或知识感兴趣，请考虑阅读我的专栏：

C++学习【专栏】

须知

本文仅作学习笔记使用，仅在CSDN网站发布，如果在其他网站发现，均为侵权行为，请举报。作者：小王在努力。

俄罗斯方块

说明

 本案例使用的是Easyx实现的，如果没有安装Easyx的朋友可能不能运行这个案例的源码（但是下方的exe文件还是可以运行的），Easyx的官网地址如下：
 Easyx官网，官网中有详细的下载教程、安装过程、以及Easyx的帮助文档等。

一、游戏展示

 1.游戏文件

  百度网盘地址：俄罗斯方块.exe(无BGM)。 提取码：elsf
  百度网盘地址：俄罗斯方块.zip(有BGM) 。 提取码：elsf
  强烈推荐大家下载带BGM版本的。如果大家对百度云的网速不信任的话，请点赞，然后再评论区留下你的邮箱，我会将游戏源码以及游戏文件发送到你的邮箱中。

 2.游戏画面

在这里插入图片描述

 3.游戏挑战

  目前游戏难度最高为等级4。由于前几天属实闲的没事，便玩了一会，破了自己的记录，大家有兴趣的可以挑战一下这个分数：
在这里插入图片描述

二、案例实现

 1.案例分析

我将整个游戏的主界面划分为三个部分：背景部分、界面部分、方块部分。按照这个思想就能实现这个游戏，接下来详细介绍这几个部分如何实现。

  1.1 背景部分

    这里说的背景部分指的是下面这张图片：
在这里插入图片描述
    这个东西想必大家都可以看出来，也就是方块的活动区域，这个部分我们只需要让他显示在方块后面即可，他需要做的只有一件事：
    1.输出背景：Back类 void showBack();

  1.2 界面部分

    这里说的界面部分指的是：

在这里插入图片描述
    界面部分是我们显示游戏信息、操作按钮的区域。这部分我们要完成的操作也很简单：
    1.在指定位置输出当前的分数和等级信息：Surface类.void showSurface();
    2.在指定位置输出下一个方块的信息：Surface类.void showSurface();

  1.3 方块部分

    这里说的方块部分指的是俄罗斯方块中的七种方块（图片来自网络，侵删）：
在这里插入图片描述
    这些方块我是通过一个个方格组合起来的，方格：
在这里插入图片描述

   那么是如何组合起来的呢？我们以第一个正方形方块为例：
    1.首先定义一个大小为18的一维数组，同时将正方形的方块信息存储在这个数组中：

int d[18]={0,
			0,0,0,0,
			0,0,0,0,
			1,1,0,0,
			1,1,0,0};

    2.将这个一维数组转换为二维数组(自定义函数set()实现)

this->bl[4].set(d);//此处的set函数的功能就是一维转二维

    3.根据这个二维数组的元素值输出方格，如果是0就不输出图片，如果是1就输出方格。这样讲整个二维数组遍历输出一边就能得到一个方块。

//输出当前下落的方块
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
			if(this->bl[this->i].s[i][j]==1)//判断方块信息数组  
				putimage(this->bl_xy[this->i][1]+(j-1)*30,this->bl_xy[this->i][2]+(i-1)*30,&this->img);//输出当前下落的方块

    在了解了一个二维数组代表了一个方块的信息之后，我们就应该明确方块要做哪些事情：
    1.输出方块：Block类void showBlock();
    2.方块自动下落：Block类void move();
    3.方块变换（左/右移、逆时针旋转）：Block类void transform();
    4.判断游戏是否结束：Block类void isVectory();

  1.4 总结

    我们只需要将每一部分要完成的任务完成，这个游戏就能做出来了。至于每一部分的任务如何实现，后面都有对应类对应的函数来实现它，大家可以在下面类的设计中寻找相应的函数,关于具体功能如何实现的，函数中有较为明确的说明。

 2.类的设计

根据上述的三个部分，我们决定设计三个类：背景部分（Back类）、界面部分（Surface类）、方块类（Block类）。

  2.1 Back类

    头文件：

#pragma once
#include<graphics.h>
class Back
{
private:
	IMAGE img;//存储图片的对象

public:
	
	Back(void);
	~Back(void);
	void showBack();//输出背景
};

    源文件：

#include "Back.h"


Back::Back(void)
{
	loadimage(&this->img,_T("IMAGE"),_T("背景.jpg"));//将背景图片加载到 img中
}


Back::~Back(void)
{
}


void Back::showBack()
{
	putimage(0,0,&this->img);//将img中的图片输出到指定位置
}

  2.2 Surface类

    头文件：

#pragma once
#include<graphics.h>
#include"Block.h"
class Surface
{
private:
	IMAGE img;//存储图片的对象
public:
	Surface(void);
	~Surface(void);

	void showSurface(Block b);//输出界面函数
};

    源文件：

#include "Surface.h"


Surface::Surface(void)
{
	loadimage(&this->img,_T("IMAGE"),_T("界面.jpg"));//将界面.jpg图片加载到img对象中
}


Surface::~Surface(void)
{

}

//输出界面函数
//界面函数主要包括几部分：1、分数和等级
//						  2、下一个方块 


void Surface::showSurface(Block b)
{
	putimage(300,0,&this->img);//在指定位置输出img对象中保存的图片

	int temp_x=343;
	int temp_y=63;
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
			if(b.bl[b.nexti].s[i][j]==1)//根据下一块方块信息，输出下一块方块
				putimage(temp_x+(j-1)*30,temp_y+(i-1)*30,&b.img);//在指定位置输出下一块方块

	setbkmode(TRANSPARENT);
	settextstyle(24,16,_T("楷体"));//设置字体的格式
	settextcolor(LIGHTGRAY);//设置字体颜色
	TCHAR grade[10];
	_stprintf_s(grade, _T("%d"), b.grade);
	outtextxy(390, 205, grade);//在指定位置输出分数
	TCHAR level[10];
	_stprintf_s(level, _T("%d"), b.level);
	outtextxy(390, 241, level);//在指定位置输出游戏等级 
}

  2.1 Block类

    头文件：

#pragma once
#include"Shape.h"
#include<graphics.h>
#include<windows.h>
#include<cstdlib>
#include<ctime>
#include"Back.h"
class Block
{
public:
	IMAGE img;//存储图片的对象
	Shape bl[8];//用于方块信息的对象数组，其中Shape为二维数组（由于不会用三维数组）
	int bc[21][11];//背景数组（将整个游戏区域划分为10×20的数组）
	int i;//当前方块的序号
	int nexti;//下一个方块的序号
	int bl_xy[8][3];//输出图片的左上角坐标
	int b_flag;//标志
	int a[3];//存放方块序号的数组
	int grade;//游戏分数
	int level;//游戏等级
public:
	Block(void);
	~Block(void);

	void showBlock();//输出方块
	void move(Back b,int &flag);//方块移动函数
	void transform(int x,Back b,int &flag);//方块变换函数
	void newBlock();//随机产生下一个方块的函数
	void isVectory(Back b,int &flag);//判断游戏结束函数
	void rotate();//方块旋转函数
};

    源文件：

#include "Block.h"


Block::Block(void)
{
	
	int a[18]={0,
			0,0,0,0,
			0,0,0,0,
			0,1,0,0,
			1,1,1,0};
	this->bl[1].set(a);//第一个方块的数组值赋值

	int b[18]={0,
			0,0,0,0,
			0,0,0,0,
			1,1,0,0,
			0,1,1,0};
	this->bl[2].set(b);//第二个方块的数组值赋值

	int c[18]={0,
			0,0,0,0,
			0,0,0,0,
			0,1,1,0,
			1,1,0,0};
	this->bl[3].set(c);//第三个方块的数组值赋值

	int d[18]={0,
			0,0,0,0,
			0,0,0,0,
			1,1,0,0,
			1,1,0,0};
	this->bl[4].set(d);//第四个方块的数组值赋值

	int e[18]={0,
			0,0,0,0,
			1,0,0,0,
			1,0,0,0,
			1,1,0,0};
	this->bl[5].set(e);//第五个方块的数组值赋值

	int f[18]={0,
			0,0,0,0,
			0,1,0,0,
			0,1,0,0,
			1,1,0,0};
	this->bl[6].set(f);//第六个方块的数组值赋值

	int g[18]={0,
			0,1,0,0,
			0,1,0,0,
			0,1,0,0,
			0,1,0,0};
	this->bl[7].set(g);//第七个方块的数组值赋值

	loadimage(&this->img,_T("IMAGE"),_T("方块.jpg"));//加载图片到img对象中，方便后续输出


	for(int i=1;i<=20;i++)//初始化背景数组
		for(int j=1;j<=10;j++)
			this->bc[i][j]=0;
	

	this->i=0;
	srand((int(time(0))));//设置随机数种子
	

	this->bl_xy[this->i][1]=90;//设置每个方块的起始x坐标
	this->bl_xy[this->i][2]=-90;//设置每个方块的起始y坐标

	this->b_flag=1;
	this->grade=0;//设置游戏初始分数为0
	this->level=1;//设置游戏初始难度等级为1

}


Block::~Block(void)
{
}

//输出方块函数
//输出当前下落的方块以及已经下落的方块
void Block::showBlock()
{
	//输出当前下落的方块
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
			if(this->bl[this->i].s[i][j]==1)//判断方块信息数组  
				putimage(this->bl_xy[this->i][1]+(j-1)*30,this->bl_xy[this->i][2]+(i-1)*30,&this->img);//输出当前下落的方块
				
	
	//输出以及下落的方块
	for(int i=1;i<=20;i++)
		for(int j=1;j<=10;j++)
			if(this->bc[i][j]==1)
				putimage((j-1)*30,(i-1)*30,&this->img);


	
}

//方块移动函数
//实现方法：1、先找到当前方块的最低点坐标
//			2、判断是否达到下界
//			3、达到下界就将当前方块加入到已经下落方块中，输出背景，输出方块
//			4、没有达到下界就继续移动，判断是否与已经下落的方块重合
//			5、重合的话就停止下降，并将此方块加入到已经下落方块中，输出背景，输出方块
//			6、如果没有重合，继续下降
void Block::move(Back b,int &flag)
{
	int a= 0; 
	for(int j=4;j>=1;j--)
	{
		for(int i=1;i<=4;i++)
			if(this->bl[this->i].s[j][i]==1)//找到当前方块最下面的方格
			{
				if(this->bl_xy[this->i][2]+(j+1)*30<=600)//下一步移动 没有到达下界
				{
					for(int j=1;j<=4;j++)
									for(int i=1;i<=4;i++)
										if(this->bl[this->i].s[j][i]==1)//判断最下面一行的方块
											if(this->bc[(this->bl_xy[this->i][2])/30+j+1][(this->bl_xy[this->i][1])/30+i]==1)//判断与背景的方块是否有重合
											{
												for(int i=1;i<=4;i++)
													for(int j=1;j<=4;j++)
														if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j]==0)
															this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j] = this->bl[this->i].s[i][j];//修改背景方块信息
												b.showBack();//输出方块
												showBlock();//输出背景
												flag=1;//设置返回信息
												break;
											}
								if(!flag)//如果与背景不重合
								{
									this->bl_xy[this->i][2]+=30;//方块继续下降
									b.showBack();//输出方块
									showBlock();//输出背景
								}
						}else//下一步移动达到下界
						{
							for(int i=1;i<=4;i++)
								for(int j=1;j<=4;j++)
									if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j]==0)
										this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j] = this->bl[this->i].s[i][j];//修改背景方块信息
							b.showBack();
							showBlock();
							flag=1;//设置返回信息
							break;

						}

									a=1;
									break;
					}
					
								if(a) break;
				}
			
	
	
}

//方块变换函数
//实现方块的：左/右移动、旋转、加速下降
void Block::transform(int x,Back b,int &flag)
{
	int temp=0;
	for(int j=4;j>=1;j--)
		for(int i=1;i<=4;i++)
		{
			if(this->bl[this->i].s[j][i]==1)
				{
					temp=j;
					break;
				}
		}
	if(this->bl_xy[this->i][2]+(temp+1)*30<=600)//当没有下降到最低点的时候
	{
		int flag=0;
			switch(x)
				{
				case 's':
					{
						int a= 0; 
						for(int j=4;j>=1;j--)
						{
							for(int i=1;i<=4;i++)
								if(this->bl[this->i].s[j][i]==1)//判断最下面一行的方块
								{
									if(this->bl_xy[this->i][2]+(j+1)*30<=600)
									{
									for(int j=1;j<=4;j++)
										for(int i=1;i<=4;i++)
											if(this->bl[this->i].s[j][i]==1)//判断最下面一行的方块
												if(this->bc[(this->bl_xy[this->i][2])/30+j+1][(this->bl_xy[this->i][1])/30+i]==1)//判断与背景的方块是否有重合
												{
													for(int i=1;i<=4;i++)
														for(int j=1;j<=4;j++)
															if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j]==0)
																this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j] = this->bl[this->i].s[i][j];//修改背景方块信息
													b.showBack();
													showBlock();
													flag=1;//设置返回信息
													break;
												}
									if(!flag)//如果与背景不重合
									{
										this->bl_xy[this->i][2]+=30;
										b.showBack();
										showBlock();
									}


								}
									a=1;
									break;
								}
								if(a) break;
						}

					};break;
				case 'a':
					{
						int a=0;
						for(int j=1;j<=4;j++)
						{
								for(int i=1;i<=4;i++)
									if(this->bl[this->i].s[i][j]==1)//找到最左边的方块
									{
										if(this->bl_xy[this->i][1]+(j-2)*30>=0)//判断是否在左边界处
											{
												for(int j=1;j<=4;j++)
													for(int i=1;i<=4;i++)
														if(this->bl[this->i].s[i][j]==1)//判断最左边一列的方块
															if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j-1]==1)//判断与背景的方块是否有重合
															{
		
																flag=1;//设置返回信息
																break;

															}
												if(!flag)
												{
												this->bl_xy[this->i][1]-=30;
												b.showBack();
												showBlock();
												}
											}
										a=1;
										break;
									}
									if(a) break;
						}
					};break;
				case 'd':
					{
						int a=0;
						for(int j=4;j>=1;j--)
						{
								for(int i=1;i<=4;i++)
									if(this->bl[this->i].s[i][j]==1)//找到最右边的方块
									{
										if(this->bl_xy[this->i][1]+j*30<300)//判断是否在边界处
											{
											for(int j=1;j<=4;j++)
												for(int i=1;i<=4;i++)
													if(this->bl[this->i].s[i][j]==1)//判断最左边一列的方块
														if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j+1]==1)//判断与背景的方块是否有重合
														{
		
															flag=1;//设置返回信息
															break;

														}
											if(!flag)
											{
											this->bl_xy[this->i][1]+=30;
											b.showBack();
											showBlock();
											}

										}
										a=1;
										break;
									}
									if(a) break;
						}
					};break;
				case 'w':
					{
						rotate();
						b.showBack();
						showBlock();
					};break;
				}
	}
	else
	{
		for(int i=1;i<=4;i++)
			for(int j=1;j<=4;j++)
				if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j]==0)
				this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j] = this->bl[this->i].s[i][j];
		b.showBack();
		showBlock();
		//Sleep(1000-(speed-1)*200);

	}
}

//随机产生方块函数
//随机产生两个新的方块的序号
//一个是当前的方块的序号。另一个是下一个方块的序号
//实现方法：在一开始，产生两个随机数，第一个为当前方块的序号
//			第二个为下一个方块的序号，然后每次只用产生一个方
//			块的序号即可
void Block::newBlock()
{

	if(this->b_flag)//一开始，产生两个随机数，代表随机产生两个方块
	{
		this->a[1] = (rand()%7)+1;
		this->a[2] = (rand()%7)+1;
		this->b_flag=0;
	}
	else//后面就只需要产生第二个方块的序号即可
		this->a[2] = (rand()%7)+1;
	this->i=a[1];//第一个方块的序号赋值
	a[1]=a[2];//数组元素前移
	this->nexti=a[2];//第二个方块的序号赋值

	this->bl_xy[this->i][1]=90;//
	this->bl_xy[this->i][2]=-90;//
}
//判断游戏结束函数
//实现功能：消除和判断游戏结束
void Block::isVectory(Back b,int &flag)
{
	for(int i=1;i<=20;i++)//逐行判断 有一行满了就将该行全部清0 输出
	{
		int sum=0;
		for(int j =1;j<=10;j++)
		{
			if(this->bc[i][j]==1)
				sum++;
			
		}
		if(sum==10)
		{
			//for(int j =1;j<=10;j++)//将被消除的一行数组元素值设置为0代表被消除
			//	this->bc[i][j]=0;

			for(int p=i;p>=2;p--)
				for(int q=1;q<=10;q++)
					this->bc[p][q]=this->bc[p-1][q];
			for(int q=1;q<=10;q++)
				this->bc[1][q]=0;
			this->grade+=(10*this->level);
			switch(this->grade)
			{
			case 100:this->level+=1;;break;
			case 300:this->level+=1;break;
			case 900:this->level+=1;break;
			}
			b.showBack();
			showBlock();

		}
	}



	int sum=0;
	for(int i=1;i<=20;i++)//逐列判断  如果有一列全满，就设置结束标志  游戏结束
	{
		for(int j = 1;j<=10;j++)
			if(this->bc[i][j]==1)
			{
				sum++;
				break;
			}
	}
	if(sum==20)
	{
		flag = 2;
		setbkmode(TRANSPARENT);
		settextcolor(DARKGRAY);
		settextstyle(50,32,_T("黑体"));
		outtextxy(10, 250, _T("游戏结束！"));
	}
			
}


//方块旋转函数
//实现方块的逆时针旋转
//大体思路也就是将存储方块信息的二维数组逆时针旋转90度
//举个简单的例子：
//将原数组a[3][3]：{1，2，3，
//					4，5，6，
//					7，8，9}逆时针旋转90度
//
//旋转后的数组a`[3][3]：{1，4，7，
//						 2，5，8，
//						 3，6，9}
//只要找到他们之间的对应关系，然后对原数组赋值就可以实现旋转了(用temp保存原数组值，因为过程中原数组值被修改了)
//他们之间对应的关系为：a[i][j]=temp[j][i];
void Block::rotate()
{

	if(this->i!=4)//正方形方块
		if(this->i==7)//长条方块
		{
			


				if(this->bl[this->i].s[1][2]==1)
				{
					int g[18]={0,
					0,0,0,0,
					0,0,0,0,
					1,1,1,1,
					0,0,0,0};
					this->bl[7].set(g);//第七个方块的数组值赋值
					//右边界判断
						int flag_r=0;
						for(int j=4;j>=1;j--)
						{
							for(int i=1;i<=4;i++)
								if(this->bl[this->i].s[i][j]==1)//找到最右边的方块
										if(this->bl_xy[this->i][1]+j*30>300)//判断是否在边界处
										{
											flag_r=1;
											break;
										}
										if(flag_r) break;
						}
						//左边界判断
						int flag_l=0;
						for(int j=1;j<=4;j++)
						{
							for(int i=1;i<=4;i++)
								if(this->bl[this->i].s[i][j]==1)//找到最左边的方块
									if(this->bl_xy[this->i][1]+(j-1)*30<0)//判断是否在左边界处
									{
										flag_l=1;
										break;
									}
									if(flag_l) break;
						}
						int flag=0;
						for(int j=1;j<=4;j++)
						{	
							for(int i=1;i<=4;i++)
									if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j-1]==1)//判断与背景的方块是否有重合
									{
										flag=1;
										break;
									}
							if(flag) break;
						}
						if(flag||flag_r||flag_l)
						{
							int g[18]={0,
							0,1,0,0,
							0,1,0,0,
							0,1,0,0,
							0,1,0,0};
							this->bl[7].set(g);//第七个方块的数组值赋值	
							
						}
						
				}
				else
				{
						int g[18]={0,
						0,1,0,0,
						0,1,0,0,
						0,1,0,0,
						0,1,0,0};
						this->bl[7].set(g);//第七个方块的数组值赋值	

						//右边界判断
						int flag_r=0;
						for(int j=4;j>=1;j--)
						{
							for(int i=1;i<=4;i++)
								if(this->bl[this->i].s[i][j]==1)//找到最右边的方块
										if(this->bl_xy[this->i][1]+j*30>300)//判断是否在边界处
										{
											flag_r=1;
											break;
										}
										if(flag_r) break;
						}
						//左边界判断
						int flag_l=0;
						for(int j=1;j<=4;j++)
						{
							for(int i=1;i<=4;i++)
								if(this->bl[this->i].s[i][j]==1)//找到最左边的方块
									if(this->bl_xy[this->i][1]+(j-1)*30<0)//判断是否在左边界处
									{
										flag_l=1;
										break;
									}
									if(flag_l) break;
						}
						int flag=0;
						for(int j=1;j<=4;j++)
						{	
							for(int i=1;i<=4;i++)
									if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j-1]==1)//判断与背景的方块是否有重合
									{
										flag=1;
										break;
									}
							if(flag) break;
						}
						if(flag||flag_r||flag_l)
						{
							int g[18]={0,
							0,0,0,0,
							0,0,0,0,
							1,1,1,1,
							0,0,0,0};
							this->bl[7].set(g);//第七个方块的数组值赋值
						}
				}
		}
		else
		{
			int temp[4][4];
			for(int i=1;i<=3;i++)
				for(int j=1;j<=3;j++)
					temp[i][j]=this->bl[this->i].s[i+1][j];

			for(int i=2;i<=4;i++)
				for(int j=1;j<=3;j++)
					this->bl[this->i].s[i][j]=temp[j][5-i];
			//右边界判断
			int flag_r=0;
			for(int j=4;j>=1;j--)
			{
				for(int i=1;i<=4;i++)
					if(this->bl[this->i].s[i][j]==1)//找到最右边的方块
							if(this->bl_xy[this->i][1]+j*30>300)//判断是否在边界处
							{
								for(int i=1;i<=3;i++)
								for(int j=1;j<=3;j++)
									this->bl[this->i].s[i+1][j]=temp[i][j];
								flag_r=1;
								break;
							}
							if(flag_r) break;
			}
			//左边界判断
			int flag_l=0;
			for(int j=1;j<=4;j++)
			{
				for(int i=1;i<=4;i++)
					if(this->bl[this->i].s[i][j]==1)//找到最左边的方块
						if(this->bl_xy[this->i][1]+(j-1)*30<0)//判断是否在左边界处
						{
							for(int i=1;i<=3;i++)
								for(int j=1;j<=3;j++)
									this->bl[this->i].s[i+1][j]=temp[i][j];
							flag_l=1;
							break;
						}
						if(flag_l) break;
			}
			//背景判断
			int flag_b=0;
			for(int j=1;j<=4;j++)
			{
				for(int i=1;i<=4;i++)
					if(this->bl[this->i].s[j][i]==1)//判断最下面一行的方块
						if(this->bc[(this->bl_xy[this->i][2])/30+i][(this->bl_xy[this->i][1])/30+j-1]==1)//判断与背景的方块是否有重合
						{
							for(int i=1;i<=3;i++)
								for(int j=1;j<=3;j++)
									this->bl[this->i].s[i+1][j]=temp[i][j];
							flag_b=1;
							break;
						}

				if(flag_b) break;
			}

		}
}

三、完整源码

  如果大家对完整源码感兴趣，请点赞博文，然后再评论区留下邮箱，我会发送到大家的邮箱中的。（只留邮箱不点赞的，恕不发送，请尊重每个人的劳动成果）

后话

  1. 首先给大家说一下，博主经常在线，如果有什么问题或者想法，可以在下方评论，我会积极反馈的。
  2. 其次还是要请大家能够多多指出问题，我也会在评论区等候大家！
    在这里插入图片描述 .
小王在努力
关注
专栏目录
从零学Java（8）之变量，小AD竟学会了赏金计算
编程界明世隐的博客
07-16 2390
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 系列目录 从零学Java（7）之数据类型 从零学Java（6）之字面量和常量 从零学Java（5）之关键字和保留字 从零学Java（4）之编程规范 从零学Java（3）之第一个实例HelloWorld 从零学Java（2）之搭建开发环境 从零学Java（1）之面向对
Lisp真的是屠龙之技吗？
JonnyWei的专栏
07-27 5万+
Lisp真的是屠龙之技吗？对Lisp的学习有一段时间了，Lisp这门50多年的语言在天朝这样一个浮躁的环境里面的确生存空间极小，除了有名的伞哥现在从事Common Lisp的开发工作之外，其他没有听说过几个。51job和智联以Lisp为关键字搜素，相关职位不到1页，几乎全部是AutoCAD Lisp开发，或者要求应聘者熟悉的一门函数语言里面出现，并且还是和perl/erlang并列的形式出现，要求
什么是 Shell ？(超详细)
happylls666的博客
12-29 1059
shell学习笔记
github上优秀的源码
Eminem1147的博客
11-02 2万+
以下内容来自转载（非常感谢此文第一作者）： 一、ListView 二、ActionBar 三、Menu 四、ViewPager 、Gallery 五、GridView 六、ImageView 七、ProgressBar 八、其他 GitHub上优秀Android开源项目 3. Android开发神器 1.Xabber客户端 2.oschina客户端 3
网络编程资源大集合(包含前端、java、linux、安卓、github开源项目、开发工具等)
sym的博客
03-14 1万+
以下内容来自转载（非常感谢此文第一作者）：1.安卓各组件介绍一、ListView二、ActionBar三、Menu四、ViewPager 、Gallery五、GridView六、ImageView七、ProgressBar八、其他2.GitHub上优秀Android开源项目3. Android开发神器1.Xabber客户端2.oschina客户端3.手机安全管家4.星座连萌5.玲闹铃6.魔乐盒7....
知乎：在卡内基梅隆大学 (Carnegie Mellon University) 就读是怎样一番体验？
weixin_30381317的博客
08-14 4565
转自：http://www.zhihu.com/question/24295398 知乎 Yu Zhang 知乎搜索 首页 话题 发现 消息 调查类问题名校就读体验修改 在卡内基梅隆大学 (Carnegie Mellon University) 就读是怎样一番体验？修改 写补充说明 举报 ...
Github上优秀的开源项目
disadministrator的专栏
11-26 8194
转自：http://blog.csdn.net/llixiangjian/article/details/52888617 原文地址为http://www.trinea.cn/android/android-open-source-projects-view/，作者Trinea 主要介绍那些不错个性化的View，包括ListView、ActionBar、Menu、ViewPager
【Android 应用开发】GitHub 优秀的 Android 开源项目
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-09 8万+
文章转载自 : http://blog.csdn.net/zhixiang2010/article/details/18032871 作者 : Elysee2014 主要介绍那些不错个性化的View，包括ListView、ActionBar、Menu、ViewPager、Gallery、GridView、ImageView、ProgressBar及其他如Dialog、Toast、Ed
开发中最常用的GitHub上 优秀的 Android 开源项目整理（精品）
星空武哥的专栏
04-24 1万+
原文地址为http://www.trinea.cn/Android/android-open-source-projects-view/，作者Trinea 参考：http://blog.csdn.net/shulianghan/article/details/18046021 参考：http://blog.csdn.net/finddreams/article/details/4092
2022 CSP 游记
glorious_dream的博客
10-31 701
2022 CSP 游记
LGame-0.3(Android与JavaSE游戏引擎)正式发布，新增SRPG制作模块
【Java究竟怎么玩?】
05-24 1万+
LGame-0.3(Android与JavaSE游戏引擎)正式发布，新增SRPG制作模块，并伴随有大量改进。
2411C++,C++26反射示例
个人进步之路
11-13 976
2411C++,C++26反射示例
C++ 中的string类
2201_75357870的博客
11-15 811
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
C++中的 std::optional
万里归来少年心
11-17 142
std::optional是C++17中的一个标准库组件，optional 对象默认是空的，也就是处于无效状态，给它赋值后因为里面有了元素，就变成了有效状态。
C/C++基础知识复习（23）
m0_72883750的博客
11-17 368
某些类型转换可能会引发未定义行为，尤其是使用或const_cast时。如果转换不合理或对原数据结构产生不正确的操作，可能会导致程序崩溃或者出现奇怪的运行时错误。int x = 10;// 错误的类型转换，可能导致程序崩溃或未定义行为。
快速上手STL中list的使用
知其然 知其所以然
11-13 779
【代码】快速上手STL中list的使用。
c语言基础知识点（十五）C语言中的指针+1与指针的二进制表示+1的区别
qq_51519091的博客
11-13 361
给一个指针加上一个整数与给该指针的二进制表示加上同样的整数，这两者之间存在本质的区别，主要体现在操作对象、操作意义以及结果上。
Cross-Inlining Binary Function Similarity Detection
最新发布
Che_Che_的博客
11-17 439
编译器在编译时将函数调用直接替换为函数体代码，从而消除函数调用的开销。代码直接嵌入到调用点，而不是通过函数调用进行。这可以减少函数调用的开销。
lambda 表达式与mutable
王尚权 qq:2515162716
11-15 1036
通常情况下，lambda表达式捕获的变量是不可变的，使用mutable关键字可以破坏这种不可变性，允许对捕获变量进行修改。在C++中，mutable关键字和引用捕获方式（&）有不同的用途和效果，它们可以在某些情况下结合使用，但它们的基本功能和影响是不同的。在这个例子中，x既是通过引用捕获的，也是mutable关键字作用的对象。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。
用python写俄罗斯方块？？
06-02
是的，你可以用 Python 编写俄罗斯方块游戏。以下是一些实现该游戏的基本步骤： 1. 导入 Pygame 库以处理游戏的图形界面。 2. 创建游戏窗口并设置其大小。 3. 创建俄罗斯方块的不同形状并定义它们的旋转动作。 4. ...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值