C++俄罗斯方块(linux环境)

最新推荐文章于 2024-08-26 09:56:58 发布
最新推荐文章于 2024-08-26 09:56:58 发布
阅读量3.8k 收藏 8
点赞数 3
分类专栏： C/C＋＋ 文章标签： linux c table null 多线程 system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simonjay2007/article/details/7345078
版权

本程序的运行环境是linux，用到了多线程。创建了一个用来绘图的线程和一个获取按键的线程。程序中有一些需要改善的地方，比如336-338行定义的全局变量以及声明的对象。本来声明的Block和Table对象应该在main函数里面，然后将这两个对象作为参数传递给线程函数getkey。但是好像只能传递一个对象参数给线程函数。希望高手能够对程序进行改进。

ps：由于用到了多线程，而pthread不是linux的默认库，所以编译的时候需要指定线程库。即：g++ -o block block.cpp -lpthread

 

#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <time.h>
#include <unistd.h>

#include<termios.h>
#include<fcntl.h>


#define TABLE_SIZE 20
#define BLOCK_SIZE 4
#define SLEEP_TIME 500

using namespace std;

struct grid{int x; int y;};        //坐标

/Block 类//
class Block
{
public:
	enum direct{UP, DOWN, LEFT, RIGHT};                 //定义方向
	grid g[BLOCK_SIZE];                                 //方块的坐标信息

	void def_block(grid g1, grid g2, grid g3, grid g4); //定义方块
	void rotate();                                      //旋转方块
	void move(int dir);                                 //移动方块
	void set_cen(grid g);                               //设置方块旋转中心
	grid get_cen();                                     //获取方块旋转中心
	void set_type(int t);								//设置方块种类
	int get_type();										//获取方块种类
	void back();										//旋转还原
	void creat_block(int x, int y);                     //随机生成方块

private:
	grid center;                                        //方块旋转中心
	int type;                                           //方块类型
	

};

void Block::def_block(grid g1, grid g2, grid g3, grid g4) {
	g[0]=g1; g[1]=g2; g[2]=g3; g[3]=g4;
}

void Block::rotate() {
	int x, y, i=0;

	for(i; i<=3; i++) {
		x=g[i].x-center.x; y=g[i].y-center.y;
		g[i].x=center.x+y; g[i].y=center.y-x;
	}
}

void Block::move(int dir) {
	int d=dir, i=0;

	switch(d) {
	case UP: { 
		for(i; i<=3; i++) g[i].y++;
		center.y++; break;
			 }
	case DOWN: {
		for(i; i<=3; i++) g[i].y--;
		center.y--; break;
			   }
	case LEFT: {
		for(i; i<=3; i++) g[i].x--;
		center.x--; break;
			   }
	case RIGHT: {
		for(i; i<=3; i++) g[i].x++;
		center.x++; break;
				}
	}
}

void Block::set_cen(grid g) {
	center=g;
}

grid Block::get_cen() {
	return center;
}

void Block::set_type(int t) {
	type=t;
}

int Block::get_type() {
	return type;
}

void Block::back() {
	int x, y, i=0;

	for(i; i<=3; i++) {
		x=g[i].x-center.x; y=g[i].y-center.y;
		g[i].x=center.x-y; g[i].y=center.y+x;
	}
}

void Block::creat_block(int x, int y) {   //随机创建方块
	int ran;
	grid g[BLOCK_SIZE];

	
	ran=1+rand()%7;
	switch(ran) {
	//L
	case 1: {
		g[0].x=x/2; g[0].y=y-3;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x; g[2].y=g[0].y+2;
		g[3].x=g[0].x+1; g[3].y=g[0].y; 
		set_cen(g[0]); set_type(1); break;
			}
	//反L
	case 2: {
		g[0].x=x/2; g[0].y=y-3;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x; g[2].y=g[0].y+2;
		g[3].x=g[0].x-1; g[3].y=g[0].y; 
		set_cen(g[0]); set_type(2); break;
			}
	//Z
	case 3: {
		g[0].x=x/2; g[0].y=y-2;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x+1; g[2].y=g[0].y+1;
		g[3].x=g[0].x-1; g[3].y=g[0].y; 
		set_cen(g[0]); set_type(3); break;
			}
	//反Z
	case 4: {
		g[0].x=x/2; g[0].y=y-2;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x+1; g[2].y=g[0].y+1;
		g[3].x=g[0].x-1; g[3].y=g[0].y; 
		set_cen(g[0]); set_type(4); break;
			}
	//田
	case 5: {
		g[0].x=x/2; g[0].y=y-2;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x+1; g[2].y=g[0].y+1;
		g[3].x=g[0].x+1; g[3].y=g[0].y; 
		set_cen(g[0]); set_type(5); break;
			}
	//1
	case 6: {
		g[0].x=x/2; g[0].y=y-3;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x; g[2].y=g[0].y+2;
		g[3].x=g[0].x; g[3].y=g[0].y-1; 
		set_cen(g[0]); set_type(6); break;
			}
	//山
	case 7: {
		g[0].x=x/2; g[0].y=y-2;
		g[1].x=g[0].x; g[1].y=g[0].y+1;
		g[2].x=g[0].x-1; g[2].y=g[0].y;
		g[3].x=g[0].x+1; g[3].y=g[0].y; 
		set_cen(g[0]); set_type(7); break;
			}
	default: ;
	}
	def_block(g[0], g[1], g[2], g[3]);
}


/

Table 类//
class Table
{
public:
	
	Table() {                         //构造棋盘
		height=20; width=10; count=0;
		init_table();
	}
	Table(int x, int y);
	int set_block(Block bl);          //安设方块
	void clr_block(Block bl);         //清除方块
	int clr_line(int y);			  //消行
	int get_h();                      //获取棋盘高度
	int get_w();					  //获取棋盘宽度
	int if_full(int y);				  //判定是否满行
	int get_table(int x, int y);      //获取棋盘上点信息
	void paint();					  //绘制棋盘
	void move_line(int y);            //整行下移
	void set_count(int c);            //记录得分
	int get_count();                  //获取得分

private:
	int table[TABLE_SIZE][TABLE_SIZE];//棋盘
	int height, width;                //棋盘的高和宽
	int count;                        //得分

	void init_table();                //棋盘初始化

};

void Table::init_table() {
	int i=0, j=0;

	for(i; i<width; i++) {
		for(j=0; j<height; j++) {
			table[i][j]=0;
		}
	}
}

Table::Table(int x, int y) {
	height=y; width=x; count=0;
	init_table();
}

int Table::set_block(Block bl) {
	int x, y;
	int i;
	for(i=0; i<=3; i++) {
		x=bl.g[i].x; y=bl.g[i].y;
		if(table[x][y]!=0 || x>=width || x<0 || y>=height || y<0) {
			return 0;
		}
	}
	for(i=0; i<=3; i++) {
		x=bl.g[i].x; y=bl.g[i].y;
		table[x][y]=1;
	}
	return 1;
}

void Table::clr_block(Block bl) {
	int x, y;

	for(int i=0; i<=3; i++) {
		x=bl.g[i].x; y=bl.g[i].y;
		table[x][y]=0;
	}
}

int Table::clr_line(int y) {
	if(y<0 || y>=height) return 0;
	for(int i=0; i<width; i++) {
		table[i][y]=0;
	}
	return 1;
}

int Table::get_h() {
	return height;
}

int Table::get_w() {
	return width;
}

int Table::if_full(int y) {
	int i=0;

	for(i; i<width; i++) {
		if(table[i][y]==0) return 0;
	}
	return 1;
}

int Table::get_table(int x, int y) {
	return table[x][y];
}

void Table::paint() {
	int i, j;

	for(i=0; i<width+2; i++) cout<<"-"<<flush;
	cout<<"\n"<<flush;
	for(i=height-1; i>=0; i--) {
		cout<<"|"<<flush;
		for(j=0; j<width; j++) {
			if(table[j][i]==0) cout<<" "<<flush;
			else cout<<"▣"<<flush;
		}
		if(i==10)
			cout<<"|    得分："<<get_count()<<endl;
		else if(i==7)
			cout<<"|    Press 'q' to quit!"<<endl;
		else
			cout<<"|"<<endl;
	}
	for(i=0; i<width+2; i++) cout<<"-"<<flush;
	cout<<"\n"<<flush;
	//cout<<"得分："<<get_count()<<endl;
}

void Table::move_line(int y) {
	int i, j;

	for(i=y; i<height-1; i++) {
		for(j=0; j<width; j++) {
			table[j][i]=table[j][i+1];
		}
	}
}

void Table::set_count(int c) {
	count+=c;
}

int Table::get_count() {
	return count;
}

///
class Mythread
{
public:
	void init();
	static void *getkey(void *arg);//线程函数在类里面定义必须定义为static型，以去除类指针。
	static void *paint_loop(void *arg);
};

void Mythread::init()
{
	pthread_t ntid,ntid2;
	int err,err2;		
	err = pthread_create(&ntid,NULL,getkey,NULL);
	err2 = pthread_create(&ntid2,NULL,paint_loop,NULL);
	if(err != 0 || err2 != 0){
		cout<<"can't create thread!"<<endl;
		exit(0);
	}
}

unsigned char flag=1,buf[2];//全局变量
Table tab(15, 20);  //构造一个15,20的棋盘
Block bl;           //构造一个落下方块
void* Mythread::paint_loop(void *arg)
{
	while(1)
	{
		system("clear");
		tab.paint();
		usleep(50000);       //暂停50 MS
	}
}
void* Mythread::getkey(void *arg)
{
	struct termios saveterm,nt;
	fd_set rfds,rs;
	struct timeval tv;
	int i=0,q,r,fd=0;
	tcgetattr(fd,&saveterm);
	nt=saveterm;

	nt.c_lflag &= ~ECHO;
	nt.c_lflag &= ~ISIG;
	nt.c_lflag &= ~ICANON;

	tcsetattr(fd,TCSANOW,&nt);

	FD_ZERO(&rs);
	FD_SET(fd,&rs);
	tv.tv_sec=0;
	tv.tv_usec=0;
	while(1)
	{	
		read(0,buf,1);
		r=select(fd+1,&rfds,NULL,NULL,&tv);
		if(r<0)
		{
			write(1,"select() error.\n",16);
		}
		rfds=rs;
		if(flag==2||buf[0]==113)//游戏结束或者用户按下'q'键，则程序退出
		{
			tcsetattr(0,TCSANOW,&saveterm);
			exit(0);
		}
		if(buf[0]<=68&&buf[0]>=65) flag=0;//如果按的键是方向键，则将标志位置0并执行相应的处理.
		if(flag==0)
		{
			if(buf[0]==65) {
			//if(dir!=0) {
				if(bl.get_type()==5) continue; //如果出现田字形则不作旋转
				tab.clr_block(bl);           //清空方块上一次位置
				bl.rotate();                 //开始旋转
				if(!tab.set_block(bl)) {     //将旋转后的方块写在棋盘上
					bl.back();				//如果写失败(例如到边线了，或卡住了)则还原旋转前位置
					continue;
					tab.set_block(bl);       
				}
			}
			//下（加速下落）
			//dir=GetAsyncKeyState(VK_DOWN);   //获取向下
			if(buf[0]==66) {
				tab.clr_block(bl);			//清空方块上一次位置
				bl.move(bl.DOWN);			//向下移动一步
				if(!tab.set_block(bl)) {	//将移动后的方块写在棋盘上
					bl.move(bl.UP);         //如果失败，则还原到移动前的位置（即上移一步）
					tab.set_block(bl);
				}
			}
			//左（左移）
			//dir=GetAsyncKeyState(VK_LEFT);
			if(buf[0]==68) {
				tab.clr_block(bl);
				bl.move(bl.LEFT);
				if(!tab.set_block(bl)) {
					bl.move(bl.RIGHT);
					tab.set_block(bl);
				}
			}
			//右（右移）
			//dir=GetAsyncKeyState(VK_RIGHT);
			if(buf[0]==67) {
				tab.clr_block(bl);
				bl.move(bl.RIGHT);
				if(!tab.set_block(bl)) {
					bl.move(bl.LEFT);
					tab.set_block(bl);
				}
			}
			flag=1;
		}
	}
	tcsetattr(0,TCSANOW,&saveterm);
}

主函数部分///

int main()
{
	//Table tab(15, 20);  //构造一个15,20的棋盘
	//Block bl;           //构造一个落下方块
	Mythread thread;
	thread.init();
	int dir,i,c;
	while(true) {
		//生成方块
		srand(time(0));
		bl.creat_block(tab.get_w(), tab.get_h());
		//判断游戏是否结束
		if( !tab.set_block(bl) ) {
			system("clear");
			cout<<"GAME OVER!"<<endl;
			flag=2;
			cout<<"PRESS ANY KEY TO CONTINUE!"<<endl;
			while(1);
		}
		///行动按键判定
		while(true){
			usleep(500000);       //暂停500 MS
			/向下移动一格
			tab.clr_block(bl);       //清空上一次方块位置
			bl.move(bl.DOWN);		 //向下移动一步
			if(!tab.set_block(bl)) {     //是否触底
				bl.move(bl.UP);       //如果触底，还原触底前位置
				tab.set_block(bl);
				break;
			}
		}
		//如果满行则消行
		for(i=0; i<tab.get_h(); i++) {
			if(tab.if_full(i)) {  //是否满行
				tab.clr_line(i);  //如果是，消行
				tab.move_line(i); //将所消行的上面的棋盘信息下移
				i--;           //下移后，重新检查这一行是否满（可能出现几行同时消去）
				tab.set_count(100); //记录得分
			}
		}
		
	}
	return 0;
}

 

 

 

 

 

simonjay2007
关注
专栏目录
Linux环境中的俄罗斯方块
09-01
Linux环境中的俄罗斯方块，可以更加深入的理解C的基本知识
Linux下俄罗斯方块程序设计（c++）
weixin_33946605的博客
01-01 296
github地址：https://github.com/fanux/tetris 很多在windows下做的，用的图形图像的库，监听键盘的线程也是封装好的，大家在看我的程序时就会发现，所有东西都是最原始的，相比较而言更原始更原汁原味一点。 接下来我把正个程序一点一点拆开与大家分享。1:cur.h文件（我们打印图像，自然要移动光标，大家是不是对移动光标很有兴趣？马上教你...
探索编译时的奇迹：超级模板俄罗斯方块
最新发布
gitblog_00865的博客
08-26 390
探索编译时的奇迹：超级模板俄罗斯方块 Super-Template-TetrisTetris as a C++ Template Metaprogram 项目地址:https://gitcode.com/gh_mirrors/su/Super-Template-Tetris 在编程的世界里，总有一些创意超出常规，挑战我们对代码极限的认识。今天，让我们一起揭开一款独特开源项目的神秘面纱——超级模板...
俄罗斯方块（c++）
a196603011718的博客
09-19 536
这个俄罗斯方块是用c++基于windows控制台制作的。 源码地址：https://github.com/Guozhi-explore 话不多说，先上图感受一下：（控制台丑陋的界面不是我的锅emmm） 我们知道俄罗斯方块有俄罗斯方块的规则： 1.生成五种不同形状的方块 ：L、Z、T、I和方形。 2.通过键盘控制左移、右移、旋转与直接下落。 3.遇到边界或者静止方块停止运动...
linux下的俄罗斯方块（测试版）
weixin_34004750的博客
06-08 239
俄罗斯方块一、设置控制台 1、更改屏幕的背景色，字体颜色 printf("\33[%dm", i); 30 30黑，31红，32绿，33黄，34蓝，35紫，36深绿，37白 40 40黑，41红，42绿，43黄，44蓝，45紫，46深绿，47白 2、任意指定屏幕的输出坐标 printf("\33...
linux俄罗斯方块程序,Linux下俄罗斯方块程序设计（c++）
weixin_35000379的博客
05-04 597
github地址：https://github.com/fanux/tetris很多在windows下做的，用的图形图像的库，监听键盘的线程也是封装好的，大家在看我的程序时就会发现，所有东西都是最原始的，相比较而言更原始更原汁原味一点。接下来我把正个程序一点一点拆开与大家分享。1:cur.h文件(我们打印图像，自然要移动光标，大家是不是对移动光标很有兴趣？马上教你怎么实现！)#ifndefCUR...
linux环境下C++实现俄罗斯方块
08-27
"Linux环境下C++实现俄罗斯方块" 本资源主要介绍了在Linux环境下使用C++语言实现俄罗斯方块游戏的详细过程，具有一定的参考价值。下面是相关的知识点： 1.C++语言基础 在实现俄罗斯方块游戏时，需要使用C++语言的...
C++实现俄罗斯方块（linux版本）
08-18
主要为大家详细介绍了linux版本C++实现俄罗斯方块，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
用linux写俄罗斯方块代码,Linux下用C++实现俄罗斯方块
weixin_39684967的博客
05-12 280
本文实例为大家分享了C++实现俄罗斯方块游戏代码，供大家参考，具体内容如下1.block.c#include #include #include #include #include #include #include #include "block.h"//init for globlevoidinit_for_globle(void){x = X / 2 - 2; // the first ...
c++（俄罗斯方块）
一个不懂编程的编程大佬，当一个人面对疾风，走上前去当一个逆行者，才是卫国黑客（AI终将代替人类）
06-30 249
切记要用Visual Studio c++,要下载easy-X图形库。
C++俄罗斯方块
04-15
非常适合c/c++学习的小游戏Demo。初学者可以按照该Demo写个自己的小应用
俄罗斯方块(C++版)
01-27
以前给大家推荐的一个小型绘图库,还答应给大伙写一个示例程序,由于前段时间太忙了,所以这件事一直拖到现在.前两天又承诺一个朋友,帮他写这个绘图库的示例程序,这事不能再拖下去了,而且今天正好事情不多,于是抽空完成了这个示例程序.其中可能还有一些BUG,没有仔细检查出来. 本程序主要是来说明写一个游戏大体的框架,以及如何使用第三方库来完成程序中的功能. 资源中包括了绘图库的引用文件,以及游戏源代码. 编译器:VC6 你也可以在其它编译器中编译.
C++ 实现俄罗斯方块
12-12
1、安装 ncurses 库 sudo apt-get update sudo apt-get install libncurses5-dev 2、编译程序 编译命令要加上 -l 选项引入 ncurses 库： g++ main.cpp -l ncurses
c++ 实现的俄罗斯方块
07-19
用c++ 实现的简单俄罗斯方块代码，适合初学者使用学习的。
c++俄罗斯方块（简单版本）
06-22
通过递归实现了最简单的俄罗斯方块，请各位高手批评指正。我将虚心接受。
俄罗斯方块c++
m0_51592169的博客
01-04 805
5步创建俄罗斯方块小游戏，vs2019。
俄罗斯方块（C++）
CatchMoon
08-15 5407
俄罗斯方块简易版（C++）
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值