Tetris

引言

跟着室友搞事情系列，在室友的启发下也准备自己写点什么东西，既然室友写了个华容道，那我就写一个俄罗斯方块吧。

室友的华容道，赞美室友

一、初步构思

基于这学期学习的东西，我打算用 C++ 完成这个俄罗斯方块。那么，初步的想法则是将正在下落的方块设计成一个类，再将地图（想不到其他适合的名称）也设计成一个类，暂时不考虑整行消除、游戏结束条件、计分等，先试着做一个方块能够在地图上堆叠起来的 demo 。

俄罗斯方块实际上就是一个方块在地图上进行操作（旋转、下落、移动、消除），而地图会随着方块的更新而更新（一个方块触底则置入地图中，地图其中一行填满则消除），那么我们需要考虑的就只有如何做到整个地图与一个方块的交互。

首先我们进行方块的构思，一个方块类需要的成员变量有：

形状
颜色
在地图上的坐标

介于方块有 I、J、L、O、Z、N、T 一共七种，I 型方块有四格长，那我们就用一个 4 x 4 的二维数组表示一个方块的形状（方块所在方格用 1 表示，下图绿色部分），方块的坐标用这个二维数组左上角的坐标表示（下图红色部分）。

然后是地图的构思，俄罗斯方块的地图一般是高为20、宽为10，如果加上边界则是 22 x 12 ，由于我们需要保证方块能够接触到边界（此时方块的坐标可能在边界之外，如下图），我们再在边界外侧在加上两单位的空余，最终的地图为 26 x 16 大小。

由于大部分操作都需要结合地图与方块，地图也只需要坐标信息，那我们直接设计一个游戏窗口的类，这个类的成员包含方块和地图，再完善这个类就可以了。

在敲代码的过程中，游戏窗口这个类不断完善，最终确定为以下几个成员变量（2.0版本）：

当前正在下落的方块
下一个将要下落的方块
地图（已经触底的方块直接存入地图）
游戏得分
下落速度

只要完善这两个类，我们的俄罗斯方块也就可以完成，接下来我将慢慢解析各部分的代码。

二、实现代码

通过查阅资料和初步尝试，我先完成了如下的目录与代码框架。（由于2.0版本与1.0版本有所差异，本博客依照的是2.0版本的代码）

1、代码目录

|-- include
    |-- print.h //控制打印光标、颜色等基础操作
    |-- piece.h //方块的类，完成对方块本身的操作
        #include "print.h"
    |-- tetris.h //游戏窗口的类，实现地图与方块的交互、游戏的开始与结束等
        #include "piece.h"
|-- src
    |-- main.cpp
        #include "tetris.h"     

2、print.h

void gotoxy(int x, int y); //将命令行光标移动至（x,y）
void printTimes(string str, int n); //对一个字符打印多次
void setColor(int n); //设置打印的颜色

3、piece.h

class Piece{
	public:
		int id; //方块的类型	
		int color; //方块的颜色		
		int nx; //方块的x坐标		
		int ny; //方块的y坐标		
		Piece(int,int,int); //构造函数		
		void renewPie(int,int,int); //构造一个新的方块		
		void draw(); //打印该方块		
		void erase(); //擦除该方块		
		void span(); //旋转该方块		
};

4、tetris.h

class Tetris{
		Piece pic; //当前下落的方块		
		Piece pre; //下一个下落的方块		
		int map[WIDTH+6][HEIGHT+6]={
			{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
			{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
			{0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0},
			{0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0},
			{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
			{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
		}; //游戏地图 10*20 大小		
		int score; //游戏得分		
		int count; //游戏速度		
	public:
		Tetris(); //构造函数	
		void welcome(); //开始界面 		
		void rule(); //游戏规则界面		
		void initMap(); //初始化地图		
		void pause(); //暂停游戏 		
		int runGame(); //开始游戏，键盘输入接口 		
		int update(); //自动下降、地图更新		
		int gameOver(); //游戏结束		
		bool renewPie(); //构造一个新的方块		
		void exchange(); //交换方块		
		bool judge(int x,int y,int id); //判断方块与地图是否重叠		
		void getScore(int rank); //更新得分		
};

5、宏定义与全局常量

#define X 8 
#define Y 4
#define P 9
#define Q 19 
#define R 40 
//坐标信息，用于调试游戏界面的坐标

#define WIDTH  10	
#define HEIGHT  20 
#define TEMP  3 
//地图长度信息

#define WHITE 0 
#define BLUE 1 
#define GREEN 2
#define RED 3
#define YELLOW 4
#define PURPLE 5
#define CYAN 6
#define PINK 7
//颜色信息，用于直观选择颜色

#define I1  0	
#define I2  1

#define O 2		

#define L1 3	
#define L2 4
#define L3 5
#define L4 6

#define J1 7	
#define J2 8 
#define J3 9
#define J4 10

#define T1 11
#define T2 12
#define T3 13
#define T4 14

#define Z1 15
#define Z2 16

#define N1 17
#define N2 18
//七种方块类型和各自的旋转状态

const int shape[19][4][4]={
	{
		{0,1,0,0},
		{0,1,0,0},
		{0,1,0,0},
		{0,1,0,0},
	},
	{
		{0,0,0,0},
		{0,0,0,0},
		{1,1,1,1},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,1,0},
		{0,1,1,0},
		{0,0,0,0},
	},
	{
		{0,1,0,0},
		{0,1,0,0},
		{0,1,1,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,1,1},
		{0,1,0,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,1,0},
		{0,0,1,0},
		{0,0,1,0},
	},
	{
		{0,0,0,0},
		{0,0,1,0},
		{1,1,1,0},
		{0,0,0,0},
	},
	{
		{0,0,1,0},
		{0,0,1,0},
		{0,1,1,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,0,0},
		{0,1,1,1},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,1,0},
		{0,1,0,0},
		{0,1,0,0},
	},
	{
		{0,0,0,0},
		{1,1,1,0},
		{0,0,1,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,0,0},
		{1,1,1,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,0,0},
		{0,1,1,0},
		{0,1,0,0},
	},
	{
		{0,0,0,0},
		{0,0,0,0},
		{1,1,1,0},
		{0,1,0,0},
	},
	{
		{0,0,0,0},
		{0,1,0,0},
		{1,1,0,0},
		{0,1,0,0},
	},
	{
		{0,0,1,0},
		{0,1,1,0},
		{0,1,0,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{1,1,0,0},
		{0,1,1,0},
		{0,0,0,0},
	},
	{
		{0,1,0,0},
		{0,1,1,0},
		{0,0,1,0},
		{0,0,0,0},
	},
	{
		{0,0,0,0},
		{0,1,1,0},
		{1,1,0,0},
		{0,0,0,0},
	},
};
const int col[19]={1,1,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,7,7};

//方块类型、旋转状态、颜色的具体实现

上面的宏定义和常量定义让代码看起来更直观，也更容易实现。接下来开始说明各个源文件中的函数定义。

6、print.h

print.h用于实现最基础的操作，一开始写完之后基本不需要改动，几个函数都参考了室友华容道的代码，再次赞美室友。

gotoxy()函数用于将光标移动至（x，y），调用后可以进行打印、擦除等操作，通过句柄实现。

void gotoxy(int x, int y) {
    COORD pos = {x,y};
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);// Getting the standard output device handle
    
    SetConsoleCursorPosition(hOut, pos); //Windows & Position
    
}

printTimes()函数，不用多说，看一下就知道用来干什么。

void printTimes(string str, int n){
	for(int i = 0; i < n; i++){
		cout << str;
	}
	return;
}

setColor()函数用于改变接下来输出的字符的颜色，加上我们对颜色的宏定义，调用这个函数就可以轻松改变颜色。例如用setColor(RED)；语句就可以将输出字符改为红色。

setColor()是基于SetConsoleTextAttribute()函数实现的，函数定义在头文件<windows.h>中，第一个参数默认如下，第二个参数则为我们需要调整的颜色，参数有：

FOREGROUND_BLUE //蓝色
FOREGROUND_RED //红色
FOREGROUND_GREEN //绿色
FOREGROUND_INTENSITY //高亮

各个参数可以用 | 连接，自己搭配出适合的颜色。

void setColor(int n){
	switch (n){
		case WHITE:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_GREEN | 					FOREGROUND_INTENSITY);
			break;
		}
		case BLUE:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_BLUE );
			break;
		}
		case GREEN:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_GREEN | FOREGROUND_INTENSITY);
			break;
		}
		case RED:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_RED );
			break;
		}
		case YELLOW:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
			break;
		}
		case PURPLE:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_BLUE | FOREGROUND_RED );
			break;
		}
		case CYAN:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
			break;
		}
		case PINK:{
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
				FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
			break;
		}
	}
}

7、piece.h

piece.h 用于实现方块本身的操作，与地图无关。之所以没有将判断函数写进Piece类中，就是因为判断需要结合方块与地图，所以写在了Tetris类中。

首先是构造函数，由于最后我们会手动调用renewPie()刷新方块，所以构造函数默认即可（虽然是我写出来之后才发现的）。

Piece类具有id、color、nx、ny四个成员变量，renewPie函数用于更新这四个变量，根据宏定义，我们可以用一个 0 ≤ id ＜ 19 表示一种方块。

但是函数的第一个参数 rand 并不表示 id，而且0 ≤ rand ＜ 7 ，并利用switch将 rand 转换为 id。这是因为如果直接用随机数生成小于19的数，那些只有一个旋转状态的方块（例如O）比有多个旋转状态的方块（例如Z）出现的概率小得多，由于一开始我忽视了这一点，只能用switch做一个简单的转换，让各个方块出现的概率相同。

根据全局常量const int col[19]={1,1,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,7,7};，代码color=col[id];可将每种方块都定义成一种确定的颜色。

void Piece::renewPie(int rand=0,int x=16,int y=1){
	switch(rand){
		case 0:{
			id=0;
			break;
		}
		case 1:{
			id=2;
			break;
		}
		case 2:{
			id=3;
			break;
		}
		case 3:{
			id=7;
			break;
		}
		case 4:{
			id=11;
			break;
		}
		case 5:{
			id=15;
			break;
		}
		case 6:{
			id=17;
			break;
		}
	}
	ny=y;
	nx=x;
	color=col[id];
}

draw()函数用于将当前方块打印出来，这里需要注意的是gotoxy(X+2*(nx+i),Y+ny+j);，由于一个■字符是占两个空格大小的，所以在x轴坐标进行了x2的调整。

erase()函数同理，只是改成了擦除。

void Piece::draw(){
	setColor(color);
	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			if(shape[id][i][j]==1){
				gotoxy(X+2*(nx+i),Y+ny+j);
				cout<<"■"; 
			}
		}
	}
}

void Piece::erase(){
	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			if(shape[id][i][j]==1){
				gotoxy(X+2*(nx+i),Y+ny+j);
				cout<<"  ";  
			}
		}
	}
}

span()函数用于旋转方块，实现方式也十分简单，只需改变成员变量id即可。

void Piece::span(){
	switch(id)
	{
	case I1: id = I2; break;	
	case I2: id = I1; break;

	case O: id = O; break;

	case L1: id = L2; break;
	case L2: id = L3; break;
	case L3: id = L4; break;
	case L4: id = L1; break; 

	case J1: id = J2; break;
	case J2: id = J3; break;
	case J3: id = J4; break;
	case J4: id = J1; break;
	
	case T1: id = T2; break;
	case T2: id = T3; break;
	case T3: id = T4; break;
	case T4: id = T1; break;

	case Z1: id = Z2; break;
	case Z2: id = Z1; break;	

	case N1: id = N2; break;
	case N2: id = N1; break;
	}
	return;
}

piece.h 的函数实现都挺简单的，接下来就开始实现Tetris类完成整个游戏界面。

8、tetris.h

tetris.h要实现的函数比较多，我们可以先看到main.cpp中，直接创建了一个Tetris成员，调用了两个函数用来进行游戏。

int main(){
	system("cls"); //清屏
	system("title 俄罗斯方块"); //游戏窗口标题	
	system("mode con cols=60 lines=28"); //游戏窗口大小	
	Tetris game;
	game.welcome(); //开始界面
	while(game.runGame()){ //游戏界面
	}
    return 0;
}

Tetris类的所有成员函数如下：

Tetris(); //构造函数
void welcome(); //开始界面 
void rule(); //游戏规则界面
void initMap(); //初始化地图 
void pause(); //暂停游戏 
int runGame(); //开始游戏，键盘输入接口 
int update(); //自动下降、地图更新
int gameOver(); //游戏结束
bool renewPie(); //构造一个新的方块
void exchange(); //交换方块
bool judge(int x,int y,int id); //判断方块与地图是否重叠
void getScore(int rank); //更新得分

首先是构造函数，由于在initMap()中我们对所有成员都进行了初始化，所以依旧没必要写。（我依旧是在写完之后才发现）

welcome()用于形成开始界面，首先通过setColor()gotoxy()打印游戏界面，再利用kbhit()和getch()接收键盘的输入信号，选择跳转至规则界面rule()或者开始游戏。

void Tetris::welcome(){
	system("cls");
	setColor(WHITE);
	gotoxy(X+15,Y-1);
	cout<<"俄罗斯方块";
	Piece cub1(10,2,2);
	cub1.draw();
	Piece cub2(17,6,2);
	cub2.draw();
	Piece cub3(15,10,2);
	cub3.draw();
	Piece cub4(4,14,1);
	cub4.draw();
	Piece cub5(2,4,6);
	cub5.draw();
	Piece cub6(0,8,6);
	cub6.draw();
	Piece cub7(12,12,6);
	cub7.draw();
	setColor(WHITE);
	gotoxy(Q,Y+13);
	cout<<"开始游戏\t空格";
	gotoxy(Q,Y+15);
	cout<<"规则操作\tR键";
	
	//开始界面
	while(1){
		if(kbhit()){	
			char ch;
			ch=getch();
			switch(ch){
				case ' ':{
					return;
				}
				case 'r':case 'R':{
					rule();
					gotoxy(Q,Y+13);
					cout<<"开始游戏\t空格";
					gotoxy(Q,Y+15);
					cout<<"规则操作\tR键";
					break;
				}
			}
		}
	}
} 

规则界面rule()与开始界面类似，打印出游戏规则，各坐标通过不断调整得到，接收到键盘输入信号则返回。

void Tetris::rule(){
	setColor(WHITE);
	gotoxy(P+2,Y+12);
	cout<<"W";
	gotoxy(P,Y+13);
	cout<<"A S D";
	gotoxy(P+2,Y+15);
	cout<<"J";
	gotoxy(P,Y+17);
	cout<<"空格键";
	gotoxy(Q+7,Y+12);
	cout<<"旋转";
	gotoxy(Q,Y+13);
	cout<<"  左移 下落 右移";
	gotoxy(Q,Y+15);
	cout<<"切换(下落不超过3格)";
	gotoxy(Q+5,Y+17);
	cout<<"开始/暂停";
	gotoxy(R,Y+12);
	cout<<"Line\tScore";
	gotoxy(R,Y+14);
	cout<<"1\t10";
	gotoxy(R,Y+15);
	cout<<"2\t40";
	gotoxy(R,Y+16);
	cout<<"3\t80";
	gotoxy(R,Y+17);
	cout<<"4\t160";
	gotoxy(X+12,Y+20);
	cout<<"请按R键返回主选单";
	while(1){
		if(getch()=='r' || getch()=='R'){
		for(int i=0;i<10;i++){
			gotoxy(P,Y+12+i);
			printTimes(" ",50);
		}
		break;
		} 
	}
	return;
}

initMap()函数生成一开始的游戏界面，包括地图、分数、显示下一个方块的框，并对成员变量进行了初始化。

void Tetris::initMap(){
	system("cls"); 
	gotoxy(X-2,Y-1);
	printTimes("■",12);
	for(int i=0;i<20;i++){
		gotoxy(X-2,Y+i);
		cout<<"■";
		printTimes("  ",10);
		cout<<"■";
	} 
	gotoxy(X-2,Y+20);
	printTimes("■",12); 
	for(int i=0;i<HEIGHT;i++){
		for(int j=0;j<WIDTH;j++){ 
			map[TEMP+j][TEMP+i]=0;
		}
	}
	score=0;
	count=500;
	gotoxy(X+WIDTH*2+8,Y+14);
	cout<<"Score:\t"<<score;
	gotoxy(X+28,Y-1);
	printTimes("■",8);
	for(int i=0;i<6;i++){
		gotoxy(X+28,Y+i);
		cout<<"■";
		printTimes("  ",6);
		cout<<"■";
	} 
	gotoxy(X+28,Y+6);
	printTimes("■",8);
}

由于2.0版本引入了两个方块，所以更新方块的方式比较复杂，所以直接写成了renewPie()函数。同时这一函数也用来判断游戏是否结束，所以返回值为布尔值。

函数首先将下一个方块pre的id、color赋值给当前方块pic，将pic的位置初始化，判断方块是否与上边界重合并不断下移：如果不重合且位置在最上方，则将这个方块打印出来，新的方块就紧贴上边界显示出来；如果不重合的位置不在最上方if(pic.ny>0)，则表示已经无法添加新的方块，游戏结束。逻辑如图所示。

完成对pic的操作后，就可以更新pre，利用随机数与Piece类的更新函数就好了。

bool Tetris::renewPie(){
	pic.id=pre.id;
	pic.nx=3;
	pic.ny=-2;
	pic.color=pre.color;
	while(!judge(pic.nx,pic.ny,pic.id)){
		pic.ny++;
	}
	if(pic.ny>0) return 1;//return true则游戏结束 	
	pic.draw();
	pre.erase();
	srand((int)time(NULL)); 
	pre.renewPie(rand()%7);
	pre.draw();
	return 0;
} 

judge()函数用于判断方块是否与地图重合，由于只需要坐标、ID就可以确定一个方块的具体位置，函数形参就直接选择了(int x,int y,int id)。

bool Tetris::judge(int x,int y,int id){
	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			if(shape[id][i][j]==1 && map[x+TEMP+i][y+TEMP+j]>0){
				return false; 
			}
		}
	}
	return true;
}

exchange()函数用于切换pic与pre，其中需要判断是否重合，而且加入了在低于某个高度后无法切换的限制。

void Tetris::exchange(){
	if(judge(pic.nx,pic.ny,pre.id) && pic.ny<2){
		pic.erase();
		pre.erase();
		int temp=pic.id;
		pic.id=pre.id;
		pre.id=temp;
		temp=pic.color;
		pic.color=pre.color;
		pre.color=temp;
		pic.draw();
		pre.draw();
	}
	return;
}

runGame()是界面与键盘交互的最直接的接口，与键盘的交互用了以下格式，保证了读取键盘输入的及时性，并且通过变量count控制地图的刷新速率。

while(1){
		if(i>=count){
			i=0;
			//更新地图			
		}
		if(kbhit()){	
			char ch=getch();
			switch(ch){//读取键盘信息进行操作			
			}
		}
		Sleep(1);
		i++;
	}	

函数接收键盘输入W、A、S、D、J、空格并进行相对的操作，如果游戏结束，返回1可重新执行该函数从而重新开始游戏，返回0可结束整个程序，具体实现方式通过gameOver()和update()实现。

左移、右移、旋转、切换的操作相对比较简单，先判断移动之后的方块是否与背景重合，如果不重合，擦除-更新坐标-打印即可。

暂停操作则仅需调用暂停函数进入暂停界面，与开始界面、规则界面实现方法类似。

int Tetris::runGame(){//键盘输入接口 
	initMap();
	Sleep(200);
	if(renewPie()) return gameOver();
	int i=0;
	while(1){
		if(i>=count){
			i=0;
			if(update()) return gameOver();
		}
		if(kbhit()){	
			char ch;
			ch=getch();
			switch(ch){
				case 'a':case 'A':{//左移 
					if(judge(pic.nx-1,pic.ny,pic.id)){
						pic.erase();
						pic.nx--;
						pic.draw();
					}
					break;
				}
				case 'd':case 'D':{//右移 
					if(judge(pic.nx+1,pic.ny,pic.id)){
						pic.erase();
						pic.nx++;
						pic.draw();
					}
					break;
				}
				case 'w':case 'W':{//选择 
					Piece temp=pic;
					temp.span();
					if(judge(temp.nx,temp.ny,temp.id)){
						pic.erase();
						pic.span();
						pic.draw();
					}
					break;
				}
				case 's':case 'S':{//下移 
					if(judge(pic.nx,pic.ny+1,pic.id)){
						pic.erase();
						pic.ny++;
						pic.draw();
					}
					break;
				}
				case ' ':{
					pause();
					break;
				}
				case 'j':case 'J':{
					exchange();
					break;
				}
				default:
					break;
			}
		}
		Sleep(1);
		i++;
		gotoxy(X+WIDTH*2+2,Y+HEIGHT);
	}
}

pause()与gameOver()的实现方式与上面同理，在调试中注意停止/开始的过程中什么需要被擦除、需要被打印，慢慢完善代码即可。

gameOver()同样注意返回1可重新执行runGame()函数从而重新开始游戏，返回0可结束整个程序，从而调整返回值。

void Tetris::pause(){
	setColor(WHITE);
	for(int i=0;i<HEIGHT;i++){
		gotoxy(X,Y+i);
		for(int j=0;j<WIDTH;j++){ 
			cout<<"■"; 
		}
	} 
	for(int i=0;i<6;i++){
		gotoxy(X+30,Y+i);
		for(int j=0;j<6;j++){ 
			cout<<"■"; 
		}
	} 
	gotoxy(X+WIDTH*2+2,Y+HEIGHT);
	while(1){
		if(kbhit()){	
			char ch;
			ch=getch();
			if(ch==' '){
				for(int i=0;i<HEIGHT;i++){
					gotoxy(X,Y+i);
					for(int j=0;j<WIDTH;j++){
						if(map[TEMP+j][TEMP+i]>0){
							setColor(map[TEMP+j][TEMP+i]);
							cout<<"■"; 
						}
						else cout<<"  "; 
					}
				}
				for(int i=0;i<6;i++){
					gotoxy(X+30,Y+i);
					for(int j=0;j<6;j++){ 
						cout<<"  "; 
					}
				} 
				setColor(pic.color);
				pic.draw();
				setColor(pre.color);
				pre.draw();
				return;
			}
		}
	}
}

int Tetris::gameOver(){
	setColor(WHITE);
	for(int i=0;i<HEIGHT;i++){
		gotoxy(X,Y+i);
		for(int j=0;j<WIDTH;j++){ 
			cout<<"■"; 
		}
	}
	gotoxy(X+WIDTH*2+8,Y+8);
	cout<<"Game Over";
	gotoxy(X+WIDTH*2+8,Y+10);
	cout<<"请按R键重新开始";
	gotoxy(X+WIDTH*2+8,Y+12);
	cout<<"或按空格退出游戏";
	while(1){
		if(kbhit()){	
			char ch;
			ch=getch();
			switch(ch){
				case ' ':{
					return 0;
				}
				case 'r':case 'R' :{
					return 1;
				}
			}
		}
	}
}

getScore()用于更新得分，形参rank为一次性消除的行数，根据行数更新得分，同时更新得分后判断是否修改count的值，以改变下落速度。

void Tetris::getScore(int rank){
		switch(rank){
			case 1:{
				score+=10;
				break;
			}
			case 2:{
				score+=40;
				break;
			}
			case 3:{
				score+=80;
				break;
			}
			case 4:{
				score+=160; 
				break;
			}
		}
		setColor(WHITE);
		gotoxy(X+WIDTH*2+8,Y+14);
		cout<<"Score:\t"<<score;
		if(count>300 && score>200)count=300;
		else if(count>200 && score>500)count=200;
		else if(count>100 && score>800)count=100;//更改速度 	
}

update()为比较核心的一个函数，方块每自动下落一格便调用一次这个函数，逻辑判断如下面的流程图所示。

int Tetris::update(){
	if(judge(pic.nx,pic.ny+1,pic.id)){//若下方有空位，自动下降   
		pic.erase();
		pic.ny++;
		pic.draw();
	}
	else{
		for(int i=0;i<4;i++){
			for(int j=0;j<4;j++){
				if(shape[pic.id][i][j]==1){
					map[pic.nx+TEMP+i][pic.ny+TEMP+j]=pic.color;
				}
			}
		}
		//方块触底 ，加入背景中 
		Sleep(100);
		int rank=0;
		for(int j=0;j<HEIGHT;j++){
			int flag=0;
			for(int i=0;i<WIDTH;i++){
				if(map[TEMP+i][TEMP+j]==0){
					break;
				}
				flag++;
			}
			if(flag==10){//一整行消除 
				rank++;
				for(int t=j;t>0;t--){
					for(int i=0;i<WIDTH;i++){
						map[TEMP+i][TEMP+t]=map[TEMP+i][TEMP+t-1];
					}
				} 
			}
		}
		if(rank>0) getScore(rank); 
		for(int i=0;i<HEIGHT;i++){
					gotoxy(X,Y+i);
					for(int j=0;j<WIDTH;j++){
						if(map[TEMP+j][TEMP+i]>0){
							setColor(map[TEMP+j][TEMP+i]);
							cout<<"■"; 
						}
						else cout<<"  "; 
					}
			} 	
		return renewPie();	
		//增加新方块 
	} 
	return 0; 
}

至此，我们的所有代码就完成了！

后记

事实上，相比起搭建这个博客，写俄罗斯方块的时间其实比我预想中的短。由于将方块封装成一个类，写起来感觉特别简洁，调试也没有花多少时间，基本上在打代码的过程中如果在哪里卡住了，调试个两三回就可以找出问题所在。花时间比较多的反而是一开始的构思，确定方块和地图如何表示，学习如何和命令行进行交互之类的。写这个程序也学到了不少Windows API的用法（虽然都是特别基础的），完成之后也是很有成就感的。

而且，通过这几天的写博客，markdown的语法也熟悉了不少，熟悉了之后用起来特别清爽。上面的流程图也是用markdown生成的（只不过这个博客模板好像不支持生成流程图，所以我在本地写完后保存成了截图），用markdown生成流程图真的特！别！好！用！（破音

所有代码已经存放到这里，需要的话可以戳进去看看。

俄罗斯方块

引言