C++实现俄罗斯方块（linux版本）

2023-07-20 10:22:14 69
本文实例为大家分享了C++实现俄罗斯方块的具体代码，供大家参考，具体内容如下
主程序
RussiaBlock.cpp
//
//Createdbyadlon2020/7/18.
//
#include"Block.h"
#include"Table.h"
#include
#include
#include"hierarchical_mutex.h"
#include"fstream"

usingnamespacestd;
thread_localuint64_t
hierarchical_mutex::this_thread_hierarchical_value=ULONG_MAX;

intmain(intargc,char**argv){
intlevel=1;
if(argc==2){
if((level=atoi(argv[1]))==0){
cerr<<"./a.outnumber"<table_lock(table_mtx);
//上下左右
switch(buf[0]){
case'A':{
//旋转
tab.clr_block(bl);//
if(bl.get_type()==5)continue;
bl.rotate();
if(tab.set_block(bl)==-1){
bl.rotate_back();
tab.set_block(bl);
continue;
}
break;
}
case'B':{
//向下（加速）
tab.clr_block(bl);
bl.move(Block::DOWN);
if(tab.set_block(bl)==-1){
bl.move(Block::UP);
tab.set_block(bl);
}
break;
}
case'C':{
/*向右*/
tab.clr_block(bl);
bl.move(Block::RIGHT);
if(tab.set_block(bl)==-1){
bl.move(Block::LEFT);
tab.set_block(bl);
}
break;
}
case'D':{
//左
tab.clr_block(bl);
bl.move(Block::LEFT);
if(tab.set_block(bl)==-1){
bl.move(Block::RIGHT);
tab.set_block(bl);
}
break;
}
default:
break;
}
table_lock.unlock();
std::unique_locklock(mtx);
if(flag==2||buf[0]==113){

lock.unlock();

tcsetattr(fd,TCSANOW,&saveterm);
std::cout<<"gameover"<table_lock(table_mtx);
tab.paint();
table_lock.unlock();
this_thread::sleep_for(std::chrono::milliseconds(200/tab.getLevel()));
std::unique_locklock(mtx);

if(flag==2){
cout<<"任意键退出"<table_lock(table_mtx);
//std::unique_locktable_lock(table_mtx);

bl.create_block(tab.getWidth(),tab.getHeight());
table_lock.unlock();
//判断游戏是否结束
table_lock.lock();
if(-1==tab.set_block(bl)){
std::unique_locklock(mtx);
flag=2;
lock.unlock();
table_lock.unlock();
while(1);
}else
table_lock.unlock();

///////////行动按键判定
while(true){
this_thread::sleep_for(std::chrono::milliseconds(400/tab.getLevel()));
/////////////向下移动一格
table_lock.lock();
tab.clr_block(bl);//清空上一次方块位置
bl.move(Block::DOWN);//向下移动一步
if(-1==tab.set_block(bl)){//是否触底
bl.move(Block::UP);//如果触底，还原触底前位置
tab.set_block(bl);
table_lock.unlock();
break;
}
table_lock.unlock();
}
//如果满行则消行
table_lock.lock();
for(i=0;i
grid.h
//
//Createdbyadlon2020/7/17.
//

#ifndefUNTITLED_GRID_H
#defineUNTITLED_GRID_H

structgrid{
intx;
inty;

grid();
grid(grid&&)noexcept;
grid(constgrid&);
grid(intx,inty);
grid&operator=(constgrid&);
grid&operator=(grid&&);
virtual~grid();
};//坐标



#endif//UNTITLED_GRID_H
grid.cpp
//
//Createdbyadlon2020/7/17.
//

#include"grid.h"

grid::grid(intx,inty):x(x),y(y){}

grid::grid():x(0),y(0){}

grid::grid(grid&&rhs)noexcept:x(rhs.x),y(rhs.y){

}

grid::~grid(){

}

grid::grid(constgrid&rhs):x(rhs.x),y(rhs.y){
}

grid&grid::operator=(constgrid&rhs){
if(this!=&rhs){
x=rhs.x;
y=rhs.y;
}
return*this;

}

grid&grid::operator=(grid&&rhs){
if(this!=&rhs){
x=rhs.x;
y=rhs.y;
}
return*this;
}
Block.h
//
//Createdbyadlon2020/7/17.
//

#ifndefUNTITLED_BLOCK_H
#defineUNTITLED_BLOCK_H

#include
#include
#include
#include

#include
#include
#include
#include"grid.h"

#defineBLOCK_SIZE4
#defineSLEEP_TIME500

#include
#include
#include
#include
#include
#include

classBlock{
public:
usingAction=Block&(Block::*)();
enumdirect{
UP,DOWN,LEFT,RIGHT
};
gridg[BLOCK_SIZE];

Block():center(0,0),type(0){}

voiddef_block(gridg1,gridg2,gridg3,gridg4){
g[0]=g1;
g[1]=g2;
g[2]=g3;
g[3]=g4;
}

voidrotate(){
//顺时针旋
intx,y;
for(inti=0;i<4;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;

}
}

Block&up(){
for(inti=0;i<4;++i){
g[i].y++;
}
center.y++;
return*this;
}

Block&down(){
for(inti=0;i<4;++i){
g[i].y--;
}
center.y--;
return*this;
}

Block&left(){
for(inti=0;i<4;++i){
g[i].x--;
}
center.x--;
return*this;
}

Block&right(){
for(inti=0;i<4;++i){
g[i].x++;
}
center.x++;
return*this;
}

voidmove(directdir){
(this->*Menu[dir])();
}


voidset_cen(gridg){
center=g;
}

gridget_cen()const{
returncenter;
}

voidset_type(intt){
type=t;
}

intget_type()const{
returntype;
}

voidrotate_back(){
//rotate的逆向
intx,y;
for(inti=0;i<4;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;

}
}

voidcreate_block(intx,inty){
unsignedintran;
gridg[BLOCK_SIZE];
staticstd::uniform_int_distributionu(1,7);
staticstd::default_random_enginee(time(0));
ran=u(e);
switch(ran){
case1:{
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
case2:{
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
case3:{
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
case4:{
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;
}
//田
case5:{
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
case6:{
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;
}
//山
case7:{
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:
std::cerr<<"someThingerr!"<
Block.cpp
//
//Createdbyadlon2020/7/17.
//

#include"Block.h"
Block::ActionBlock::Menu[]={
&Block::up,
&Block::down,
&Block::left,
&Block::right
};
Table.cpp
//
//Createdbyadlon2020/7/17.
//

#include"Table.h"
#include"Block.h"

intTable::set_block(constBlock&bl){
intx,y;
for(inti=0;i<4;++i){
x=bl.g[i].x;
y=bl.g[i].y;
//比如下降之后table[x][y]上有方块了
if(table[x][y]!=0||x>=width||x<0||y>=height||y<0){
return-1;
}
}
for(inti=0;i<4;++i){
x=bl.g[i].x;
y=bl.g[i].y;
table[x][y]=1;
}
return0;
}

voidTable::clr_block(constBlock&bl){
intx,y;
for(inti=0;i<4;++i){
x=bl.g[i].x;
y=bl.g[i].y;
table[x][y]=0;
}
}

intTable::clr_line(inty){
if(y<0||y>=height)return-1;
for(inti=0;i=0;i--){
std::cout<<"|"<
Table.h
//
//Createdbyadlon2020/7/17.
//

#ifndefUNTITLED_TABLE_H
#defineUNTITLED_TABLE_H

#include

#defineTABLE_SIZE20
classBlock;
classTable{
public:

Table():height(TABLE_SIZE),width(10),count(0),level(1){//构造棋盘
for(inti=0;i
hierarchical_mutex.h
//
//Createdbyadlon2020/7/18.
//

#ifndefUNTITLED_HIERARCHICAL_MUTEX_H
#defineUNTITLED_HIERARCHICAL_MUTEX_H
#include
#include
#include
#include
#include
#include
#include
#include
#include

classhierarchical_mutex{
private:
std::mutexinternal_mutex;
uint64_tconsthierarchical_value;
uint64_tprevious_value;
staticthread_localuint64_tthis_thread_hierarchical_value;

voidcheck_for_hierarchy()noexcept(false){
if(this_thread_hierarchical_value<=hierarchical_value){
throwstd::logic_error("mutexhierarchicalviolated.");
}
}

voidupdate_hierarchy_value(){
previous_value=this_thread_hierarchical_value;
this_thread_hierarchical_value=hierarchical_value;
}

public:
constexprexplicithierarchical_mutex(uint64_tvalue):
hierarchical_value(value),previous_value(0){}

voidlock()noexcept(false){
check_for_hierarchy();
internal_mutex.lock();
update_hierarchy_value();
}

voidunlock(){
this_thread_hierarchical_value=previous_value;
internal_mutex.unlock();
}

booltry_lock()noexcept(false){
check_for_hierarchy();
if(!internal_mutex.try_lock())returnfalse;
update_hierarchy_value();
returntrue;
}
};


#endif//UNTITLED_HIERARCHICAL_MUTEX_H
积累的经验：
1.生成随机数的uniform_int_distribution，defualt_random_engine(time(0))使用时必须用static,缺点是多次执行程序的第一次生成的数字是一样的
2.与c++primerp743类似，使用成员指针函数表可以使用户调用的函数更加明了。
3.给互斥锁加权值，并以权值大小顺序加锁，可以保证线程加锁顺序一致，避免死锁（出现则抛出异常）（这个纯粹活学活用，因为c++锁和线程接触不多）
4.threadxxx([&](){})是可以放在函数内部的线程
5.利用select监控标准输入
6.利用tcgetattr,tcsetaddr，termiosi结构体

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

可以在linux关闭回显，实现getch
7.this_thread::sleep_for(std::chrono::milliseconds(400/tab.getLevel()));可以咋线程中实现毫秒级别睡眠
8.类中静态对象初始化可以写在其对应.cpp文件中
反思：
未使用类的继承，各种方块理论可以写成子类，因为主线程一开始直接使用了Block对象，后期不容易修改.
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
C++实现俄罗斯方块（linux版本）

热门推荐

随机推荐
