01-俄罗斯方块开发日志

返回

俄罗斯方块开发日志 ​

说明 ​

2024-11-27 — 2025-02-27

当时是我的大一上寒假期间,大一上的时候,学了《编程概述》这门课,其实就是教 C 语言入门的,语言入门后,还简单了解了一下数据结构的内容。

当时大一还很迷茫,完全没有任何的规划,没有任何的目标,也只是走一步看一步,做到不掉队的程度。感觉大一上完课之后,也没学到些啥特别的,除了自己刷了很多计算机相关的视频外,也没什么特别的学习上的任务,然后就开始尝试用 C++ 开发一些小项目。

当时用 C++ 开发这种简单的小游戏是受到直接刺激的,大一的时候,学校安排了 “学业导师”,自己也没做调研,随便选了一个老师。当时在群里面好像发了什么通知交流之类的,那个老师说:“见过有好几个大一就可以用 C++ 开发什么 “贪吃蛇”、“五子棋” 小游戏了,大一学到这种程度也算可以了”,因为我本来就对 “开发” 非常感兴趣,这不服输的劲一下就上来了,加上原本我就自己写过程序,自学过 Python ,有过一点开发程序的经验,我也要自己开发一个,于是就选了俄罗斯方块。

开发的时候,也是碰到了很多问题。也没什么教程,就只是学了语法、面向对象之类的,当时对 C 语言的指针还不是很理解,没有悟透,最大的问题是,之前用 Python 写程序跟用 C 写程序,语法层面、内存管理根本就不一致,导致我思维半天没转变过来,开发的时候一致报错,半天不理解。

当时跟着 B 站上,一个老师学的 C 语言入门,那个老师讲得很好,不只讲语法入门,还带着一起教你 debug ,这个 debug 的过程真的非常非常重要,也是在那个时候对 debug 有了一定的经验,也正是有了 debug 的经验,我才能够在开发俄罗斯方块的时候,定位到问题。

当时学的是 “鹏哥 C 语言”。用 Microsoft Visual Studio 开发的,比较重,有专门的 debug 环境。

当时,开发的时候,一直报错,找不到问题,实在是没招了,上 QQ 群问老师,看公开小游戏代码,看视频教程。本来感觉是有思路的,按照这么来应该是可以实现的,但是,就是报错,跑不通,反反复复开发了几遍,顺过去顺过来都感觉没问题,看别人的实现方案感觉也差不多的,能看懂,有一个方案当时没看懂,就是用二进制,但是对二进制还不熟悉,没理解怎么用一个数就能映射方块的形状的。

Screenshot_20261013_103759

结果,最终折腾了好久,终于通过 debug ,一点一点的看代码,追踪堆栈,终于发现了问题。在函数之间传值的之后,传递的数据丢了,最终才终于搞懂了,什么是 “动态分配内存” ,什么是 “指针传值” 。最终才好不容易跑通了最基础的一个版本。这一刻,感觉编程一下就变简单了,所有的问题瞬间都通透了。

但是在用图形渲染库的时候还遇到了问题,当时开源的库主流的好像有两种,一个是 EasyX,另一个记不住了,最终选择的 EasyX,因为另外一个没看懂,EasyX 有些内容也没看明白,当时官网好像是全英文的,可读性太低了,我也懒得一句一句读,怎么配 EasyX 的环境,导入依赖使用,但是是没搞明白的, 但还是跟着教程说明跑通了。尤其是用 EasyX 处理文本渲染的时候,感觉老麻烦了,什么字体之类的,什么数据变量之类的。还有按键监听,帧率控制也是难点。

整体上,全靠自己设计思路,自己实现,自己 debug ,实在是不容易啊。最终只是跑通整个流程之后,就没在继续开发了,当时感觉没继续开发的必要了,因为已经发完朋友圈了😄。再继续开发,也只是完善细节,花时间打磨而已,浪费精力,然后就放弃了,知道有 bug 也没改。

最后的收获总结就是:“动态分配内存”、“debug”、“数据结构”、“代码画图”、“按键监听”、“帧率控制”、“二进制”、“面向对象”、“画布”、“流程控制”。

有老师带的话,可以少踩很多坑,但是我自己踩的坑折腾这些,经验更加深刻,感悟更深。

唉,现在都用 AI 直接开发了,后来再学计算机,再学编程,如果没这种经验,还真能看得懂代码吗?未来还真的需要看代码吗?作为一个程序员怎能不看代码呢?


补充:

当时开发完了俄罗斯方块,我在 “游戏开发” 上面起了一些兴趣,当时本打算继续开发其他小游戏的,当时正巧在玩一个小游戏,叫作 “猛鬼宿舍” ,当时正好感觉这个小游戏挺有意思的,还做了一些攻略,就是玩多了之后,玩法太单调了,就打算自己复刻这个游戏然后自己开发新功能的。

mgss

可惜的是,在刚开始新建文件夹之后,发现,最难得不是代码,而是没有图片素材,找不到游戏资源,那个时候 AI 还不怎么厉害,从来没想过有朝一日还能结合 AI 生图开发游戏。

因此,在当时,一想到没有游戏资源,一想到一款游戏开发需要用到那么多资源,我就开始劝退了。当时的唯一进度,就是,在 B 站上刷到了一个教从 0 开始一点一点源代码级别的教 C++ 游戏开发的,还有博主教游戏开发经验的,还知道了什么叫 “精灵图” 、“地图绘制”、“摄像头” 等概念,才知道,原来游戏开发有这么多概念,是这么回事。当我在用一张 MC 石头的贴图画出来这个游戏地图之后就放弃了,在当时根本是我自己一个人难以完成的项目,更不用说,这个游戏还有人机,离线下也能玩。

我的游戏开发之路,就此结束。

补充:我的原始项目已经消失了,原因就是当时电脑硬盘坏了,所有数据全部丢了,我几乎把所有数据都放到了那个坏掉的 1 T 硬盘上,所有的工作目录,所有的项目,所有的应用程序,所有搜集的资料,所有的相册。😭😭😭😭😭😭😭😭😭😭😭😭😭😭😭

演示效果预览 ​

俄罗斯方块演示视频

这应该是第一个版本的效果,因为第一次跑通,很激动,发了朋友圈视频的,后面对其进行了优化的,但是没再发朋友圈了,只有这一个预览截图了。优化之后的,还有一些 UI ,更加完善些。

image-20261013115008520

在我印象中,最终的版本,我的开发原型对照的是如下这款,因为这个界面的 barrier 素材我记得很清楚,就是从这个网站来的,还有方块的素材是扣图扣来的,然后右边有文本 UI 渲染,得分展示:

image-20261013143338573

​

估计最终的版本,源代码已经丢了,再也找不会了,只存在记忆中了。

原始日志记录 ​

2024-11-27 ​

准备工作 ​

在电子书《深入体验 C 语言项目开发》中看到俄罗斯方块的开发,受到启发,想要挑战自己开发俄罗斯方块小游戏。

了解到一个图形库“easyx.h”,计划借助此库完成开发。

下载并安装好库之后,简单了解了一下 easyx 这个库的功能。

尝试了基础的简单画图.

2024-11-28 ​

获取按键操作 ​

在我使用_getch()函数模拟获取按键的过程中,发现一个巨大的问题:

绘图的界面和控制台不是同一个窗口,我只能在控制台获取按键,因此,我在获取按键之前,必须先让鼠标聚焦在控制台上,不能隐藏掉控制台界面,只显示绘画的图形界面,相当的不优雅。

在 B 站上观摩他人实现俄罗斯方块的过程,发现,可以使用 easyx 库中自带的 ExMessage 完成获取按键的过程。

根据示例代码,初次尝试,无法正常获取键盘输入,但是鼠标操作正常,不知道原因,重新观看 B 站视频教程的实现过程。

发现问题,问题原因:消息类型判错错误。

C
ExMessage key;
while (1)
{
       key = getmessage(EX_KEY);
       switch(key.vkcode)	// 消息类型应为 vkcode(virtual keyboard),示例为 message误认为是全局消息,
       {
           ...
       }
}
已折叠代码,点击展开

重新学习 easyx 库相关内容

解决了按键点一次运行执行多次的问题,自认为前期工作准备完成,能够绘图,能够获取按键信息,接下来就是游戏思路的设计以及代码的实现。

完成了绘画游戏界面

11.29 ​

遇到问题 ​

怎么旋转方块

不同的文件之中怎么共享变量

二维数组的相关操作不熟悉

12.13 ​

从头开始。

流程分析 ​

绘制流程图

图片未找到image-20241213015509454

相关代码分析:

数据结构:

int x=10,int y=18 游戏格数

int map[x][y] 二维坐标地图

int curBlock[4][4] 当前方块数据

int nextBlock[4][4] 下一个方块数据

int blocks[7][4][4] 所有方块初始数据

int blockID 方块种类判断[0-6]

int curPos[x][y] 当前方块的坐标

int speed 游戏刷新间隔|方块下落速度

函数分析:

void draw_gui(void) 绘画 gui

​ void draw_game_area(void) 绘画游戏区域

​ void draw_next_area(void) 绘画下一个方块区域

​ void draw_info_area(void) 绘画游戏信息区域

void draw_block(int** curBlock, int** curPos) 绘画新坐标下的方块

void clean_block(int** preBlock, int** prePos) 清除旧坐标下的方块

void game_ing(void) 游戏算法实现

​ int** block_generate(void) 生成一个新方块(给一个随机数,改变方块的初始方向),返回方块数据 curBlock

​ int** block_falling(void) 方块下落,返回坐标 curPos

​ int** block_change_shape(int** curBlock) 改变方块样式,返回方块数据 curBlock

​ bool block_check_barrier(int** curPos) 检查是否碰壁,返回 bool

​ void block_clean_line(void) 清除满行

2025.2.4 ​

再再战俄罗斯方块

计划:

  1. 更改底层代码,C 语言转 C++.因此浏览一遍 C++文档.面向对象内容加上一些常用的库.顺便复习编程语言
  2. 重新学习 easyx 绘图库.
  3. 一个一个小环节的写,调试.先让一部分跑起来,再丰富内容.
第一步:让单方块动起来 ​
C++
#include <iostream>
#include <easyx.h>
#include <graphics.h>
using namespace std;

int main()
{
	initgraph(400, 700);

	for (int i = 1; i <= 10; i++)
	{
		clearrectangle(10, (i - 1) * 20, 30, i * 20);
		fillrectangle(10, i * 20, 30, (i + 1) * 20);
		Sleep(1000);
	}

	system("pause");
	return 0;
}
已折叠代码,点击展开
第二步:让完整方块动起来 ​
C++
#include <iostream>
#include <easyx.h>
#include <graphics.h>
using namespace std;

const int BLOCK_SIZE = 30;   // 一个方块的边长大小
const int X = 10;			 // 横向方块数量
const int Y = 18;			 // 纵向方块数量
const int BLOCK_TYPES = 20;  // 不同方块类型的个数 

class Tetris
{
	public:
		int block_id = 2;
		int block_total_type = 20;
		int block_data[BLOCK_TYPES][16] = {
			// 仅仅给出三个作为示例,后面再补充方块
			{
				0, 0, 0, 0,
				0, 1, 1, 0,
				0, 1, 1, 0,
				0, 0, 0, 0
			}, 
			{
				0, 0, 0, 0,
				1, 1, 1, 1,
				0, 0, 0, 0,
				0, 0, 0, 0
			},
			{
				0, 1, 0, 0,
				0, 1, 0, 0,
				0, 1, 0, 0,
				0, 1, 0, 0
			}
		};
		int map[X][Y] = { 0 };  // 地图方块数据,0: 未被占用, 1: 被占用
		int block_pos[2] = { 0 };  // 4*4方块在地图中的坐标 [0]: x  ... [1]: y 
		
		void init(void);
		void set_block_pos_to_start(int block_id, int* block_pos);
		void block_down(int block_id, int* block_pos);
};

int main()
{
	Tetris game;
	game.init();
	game.set_block_pos_to_start(game.block_id, game.block_pos);


	while (true)
	{
		game.block_down(game.block_id, game.block_pos);
		Sleep(1000);
	}
	
	Sleep(4000);
	return 0;
}

// 初始化游戏界面
void Tetris::init(void)
{
	// 初始化桌布大小
	initgraph((X + 2) * BLOCK_SIZE, (Y + 1) * BLOCK_SIZE);

	// 画边界障碍
	setfillcolor(RGB(56, 56, 56));  // 设置边界为灰色
	POINT pts_barrier[] = { {0.5 * BLOCK_SIZE,0}, {BLOCK_SIZE, 0},
							{BLOCK_SIZE, Y * BLOCK_SIZE}, {(X + 1) * BLOCK_SIZE,Y * BLOCK_SIZE},
							{(X + 1) * BLOCK_SIZE,0}, {(X + 1.5) * BLOCK_SIZE,0},
							{(X + 1.5) * BLOCK_SIZE,(Y + 0.5) * BLOCK_SIZE}, {0.5 * BLOCK_SIZE,(Y + 0.5) * BLOCK_SIZE} };
	fillpolygon(pts_barrier, 8);  // 起点开始8个顺时针顶点坐标 (x, y) 
}

// 刷新方块的时候,获取方块的起始位置,使下一刻就能显示出方块
void Tetris::set_block_pos_to_start(int block_id, int* block_pos)
{
	block_pos[0] = 3;
	block_pos[1] = -4;
	bool is_block = false;
	for (int row = 3; row >= 0; row--)
	{
		if (is_block)
		{
			break;
		}
		for (int col = 0; col <= 3; col++)
		{
			if (block_data[block_id][row * 4 + col] == 1)
			{
				if (is_block)
				{
					break;
				}
				block_pos[1] += (3 - row);
				is_block = true;
			}
		}
	}
}

void Tetris::block_down(int block_id, int* block_pos)
{
	setorigin(BLOCK_SIZE, 0);
	for (int row = 0; row < 4; row++)
	{
		for (int col = 0; col < 4; col++)
		{
			if (block_data[block_id][row * 4 + col] == 1)
			{
				clearrectangle((block_pos[0] + col) * BLOCK_SIZE,
					(block_pos[1] + row) * BLOCK_SIZE,
					(block_pos[0] + col + 1) * BLOCK_SIZE,
					(block_pos[1] + row + 1) * BLOCK_SIZE);
			}
		}
	}

	block_pos[1]++;

	for (int row = 0; row < 4; row++)
	{
		for (int col = 0; col < 4; col++)
		{
			if (block_data[block_id][row * 4 + col] == 1)
			{
				fillrectangle((block_pos[0] + col) * BLOCK_SIZE,
					(block_pos[1] + row) * BLOCK_SIZE,
					(block_pos[0] + col + 1) * BLOCK_SIZE,
					(block_pos[1] + row + 1) * BLOCK_SIZE);
			}
		}
	}
}
已折叠代码,点击展开

2.5 ​

第三步:让多个方块堆叠起来 ​
C++
#include <iostream>
#include <easyx.h>
#include <graphics.h>
using namespace std;

const int BLOCK_SIZE = 30;   // 一个方块的边长大小
const int X = 10;			 // 横向方块数量
const int Y = 18;			 // 纵向方块数量
const int BLOCK_TYPES = 20;  // 不同方块类型的个数 共19种

int speed = 100;


class Tetris
{
	public:
		int block_id = rand() % 19;
		int block_total_type = 20;
		int block_data[BLOCK_TYPES][16] = {
			// 仅仅给出三个作为示例,后面再补充方块
			{  // 1
				0, 0, 0, 0,
				0, 1, 1, 0,
				0, 1, 1, 0,
				0, 0, 0, 0
			}, 
			{  // 2
				0, 0, 0, 0,
				1, 1, 1, 1,
				0, 0, 0, 0,
				0, 0, 0, 0
			},
			{  // 3
				0, 1, 0, 0,
				0, 1, 0, 0,
				0, 1, 0, 0,
				0, 1, 0, 0
			},
			{  // 4
				0, 0, 0, 0,
				0, 1, 0, 0,
				1, 1, 1, 0,
				0, 0, 0, 0
			},
			{  // 5
				0, 0, 0, 0,
				0, 1, 0, 0,
				0, 1, 1, 0,
				0, 1, 0, 0
			},
			{  // 6
				0, 0, 0, 0,
				0, 0, 0, 0,
				1, 1, 1, 0,
				0, 1, 0, 0
			},
			{  // 7
				0, 0, 0, 0,
				0, 1, 0, 0,
				1, 1, 0, 0,
				0, 1, 0, 0
			},
			{  // 8
				0, 0, 0, 0,
				0, 0, 0, 0,
				0, 1, 1, 0,
				1, 1, 0, 0
			},
			{  // 9
				0, 0, 0, 0,
				1, 0, 0, 0,
				1, 1, 0, 0,
				0, 1, 0, 0
			},
			{  // 10
				0, 0, 0, 0,
				0, 0, 0, 0,
				1, 1, 0, 0,
				0, 1, 1, 0
			},
			{  // 11
				0, 0, 0, 0,
				0, 1, 0, 0,
				1, 1, 0, 0,
				1, 0, 0, 0
			},
			{  // 12
				0, 0, 0, 0,
				0, 1, 0, 0,
				0, 1, 1, 1,
				0, 0, 0, 0
			},
			{  // 13
				0, 0, 0, 0,
				0, 1, 1, 0,
				0, 1, 0, 0,
				0, 1, 0, 0
			},
			{  // 14
				0, 0, 0, 0,
				0, 1, 1, 1,
				0, 0, 0, 1,
				0, 0, 0, 0
			},
			{  // 15
				0, 0, 0, 0,
				0, 0, 1, 0,
				0, 0, 1, 0,
				0, 1, 1, 0
			},
			{  // 16
				0, 0, 0, 0,
				0, 0, 0, 1,
				0, 1, 1, 1,
				0, 0, 0, 0
			},
			{  // 17
				0, 0, 0, 0,
				0, 0, 1, 0,
				0, 0, 1, 0,
				0, 0, 1, 1
			},
			{  // 18
				0, 0, 0, 0,
				0, 1, 1, 1,
				0, 1, 0, 0,
				0, 0, 0, 0
			},
			{  // 19
				0, 0, 0, 0,
				0, 0, 1, 1,
				0, 0, 0, 1,
				0, 0, 0, 1
			}
		};
		int map[X][Y] = { 0 };  // 地图方块数据,0: 未被占用, 1: 被占用
		int block_pos[2] = { 0 };  // 4*4方块在地图中的坐标 [0]: x  ... [1]: y 
		
		void init(void);
		void set_block_pos_to_start(void);
		void block_down(void);
		void update_map(void);
		bool is_stop(void);
		bool is_end_game(void);
		int get_random_block(void);
};

int main()
{
	srand(time(0));
	Tetris game;
	game.init();

	game.block_id = game.get_random_block();
	game.set_block_pos_to_start();

	while (!game.is_end_game())
	{
		while (!game.is_stop())
		{
			game.block_down();
			Sleep(speed);
		}
		// 地图上更新方块数据
		game.update_map();
		// 新一轮
		game.block_id = game.get_random_block();
		game.set_block_pos_to_start();
		Sleep(speed);
	}

	cout << "!!!!!!!!!!!!!!!!!!!!!!!" << endl << "Game ends! 3s later auto close!" << endl;
	Sleep(3000);
	return 0;
}

// 初始化游戏界面
void Tetris::init(void)
{
	// 初始化桌布大小
	initgraph((X + 2) * BLOCK_SIZE, (Y + 1) * BLOCK_SIZE, EX_SHOWCONSOLE);

	// 画边界障碍
	setfillcolor(RGB(56, 56, 56));  // 设置边界为灰色
	POINT pts_barrier[] = { {0.5 * BLOCK_SIZE,0}, {BLOCK_SIZE, 0},
							{BLOCK_SIZE, Y * BLOCK_SIZE}, {(X + 1) * BLOCK_SIZE,Y * BLOCK_SIZE},
							{(X + 1) * BLOCK_SIZE,0}, {(X + 1.5) * BLOCK_SIZE,0},
							{(X + 1.5) * BLOCK_SIZE,(Y + 0.5) * BLOCK_SIZE}, {0.5 * BLOCK_SIZE,(Y + 0.5) * BLOCK_SIZE} };
	fillpolygon(pts_barrier, 8);  // 起点开始8个顺时针顶点坐标 (x, y) 
	cout << "Initialized game successfully!" << endl;
}

// 刷新方块的时候,获取方块的起始位置,使下一刻就能显示出方块
void Tetris::set_block_pos_to_start(void)
{
	// 初始化起点
	this->block_pos[0] = 3;
	this->block_pos[1] = -4;
	// 往下微调Y坐标
	bool is_block = false;
	for (int row = 3, col = 0; row >= 0; col++)
	{
		if (is_block)
		{
			break;
		}
		if (col >= 4)
		{
			row--;
			col = 0;
		}
		// 获取最底层实体方块的Y轴
		if (1 == this->block_data[this->block_id][row * 4 + col])
		{
			this->block_pos[1] += 3 - row;  // 往下移动的格数[0, 3]使下一刻就能显示出方块
			is_block = true;
			printf("Block_id: %d\tis setted to start spot!\tPos: [%d, %d]\n", 
				this->block_id, this->block_pos[0], this->block_pos[1]);
		}
	}
}

// 方块下落一格
void Tetris::block_down(void)
{
	setorigin(BLOCK_SIZE, 0);  // 设置 原点O 的位置
	for (int row = 3, col = 0; row >= 0; col++)  // 从下往上绘画
	{
		if (col >= 4)
		{
			row--;
			col = 0;
		}
		if (row < 0)
		{
			break;
		}
		if (1 == this->block_data[this->block_id][row * 4 + col])
		{
			// 清除当前位置的方块
			clearrectangle((this->block_pos[0] + col) * BLOCK_SIZE,
				(this->block_pos[1] + row) * BLOCK_SIZE,
				(this->block_pos[0] + col + 1) * BLOCK_SIZE,
				(this->block_pos[1] + row + 1) * BLOCK_SIZE);
			// 绘画下面位置的方块
			fillrectangle((this->block_pos[0] + col) * BLOCK_SIZE,
				(this->block_pos[1] + row + 1) * BLOCK_SIZE,
				(this->block_pos[0] + col + 1) * BLOCK_SIZE,
				(this->block_pos[1] + row + 2) * BLOCK_SIZE);
		}
	}
	this->block_pos[1]++;
	printf("Block_id: %d\tis downing!\tPos: [%d, %d]\n",
		this->block_id, this->block_pos[0], this->block_pos[1]);
}

// 更新地图方块数据,方块停止运动后占用地图
void Tetris::update_map(void)
{
	for (int row = 3, col = 0; row >= 0; col++)
	{
		if (col >= 4)
		{
			col = 0;
			row--;
		}
		if (row < 0)
		{
			break;
		}
		this->map[this->block_pos[0] + col][this->block_pos[1] + row] += this->block_data[this->block_id][row * 4 + col];
	}
}

// 方块是否停止运动(到达最底层,碰到其他方块)
bool Tetris::is_stop(void)
{
	for (int row = 3, col = 0; row >= 0; col++)
	{
		if (col >= 4)
		{
			col = 0;
			row--;
		}  
		// 最后一个循环为 row=-1, col=0 依旧会执行会出bug
		if (row < 0)
		{
			return false;
		}
		// 遍历到实体方块
		if (1 == this->block_data[this->block_id][row * 4 + col])
		{
			// 方块到达最底层
			if (Y - 1 <= this->block_pos[1] + row)
			{  // 坐标是从0开始计数,同数组,当为 Y-1
				printf("Block_id: %d\tarrived at the buttom!\tPos: [%d, %d]\n",
					this->block_id, this->block_pos[0], this->block_pos[1]);
				return true;
			}
			// 方块下面碰到其他方块
			if (1 == this->map[this->block_pos[0] + col][this->block_pos[1] + row + 1])
			{
				printf("Block_id: %d\thits another block!\tPos: [%d, %d]\n",
					this->block_id, this->block_pos[0], this->block_pos[1]);
				return true;
			}
		}
	}
}

// 是否结束游戏,方块堆满了
bool Tetris::is_end_game(void)
{
	for (int row = 3, col = 0; row >= 0; col++)
	{
		if (col >= 4)
		{
			col = 0;
			row--;
		}
		if (row < 0)
		{
			return false;
		}
		if (1 == this->map[this->block_pos[0] + col][0] && -1 == this->block_pos[1] + row)
		{  // 第0层对应的方块被占用即结束
			return true;
		}
	}
}

// 随机生成方块ID用于随机方块
int Tetris::get_random_block(void)
{
	return rand() % 19;
}
已折叠代码,点击展开
问题:一刻方块只能移动一次,不能一次移动两下,Sleep 时间太长了,无法同时处理间隔内有两次移动。每下降一格才能平移一格,最大平移距离与最大垂直距离成正比。 ​

2.27 ​

正式版 1.0

#include <iostream>
#include <easyx.h>
#include <time.h>
using namespace std;

#define X first
#define Y second

class Tetris
{
public:
	Tetris(int blocksX, int blocksY, int blockSize)
	{
		block.blocksX = blocksX;
		block.blocksY = blocksY;
		block.size = blockSize;
		UpdateBlockData();
	
		render.blockSpace = blockSize / 11;
		render.barrierPadding = blockSize * 2 / 7;
		render.barrierEllipse = 10;
		render.windowPadding = blockSize * 3 / 5;
		UpdateDrawLength();
	}

	IMAGE picBlocks[7];
	int colorId = 0;
	int map[20][20];
	int FPS = 1000 / 60;
	int cntFPS = 0;
	clock_t startTime;
	clock_t endTime;
	clock_t costTime;

	struct Render
	{
		pair<int, int> blockStart;
		int blockSpace;

		int windowPadding;
		int windowWidth;
		int windowHeight;

		int barrierPadding;
		int barrierWidth;
		int barrierHeight;
		int barrierEllipse;

		int spotBarrierLeft;
		int spotBarrierTop;
		int spotBlockLeft;
		int spotBlockTop;

	} render;

	struct Block
	{
		int blocksX = 10, blocksY = 18;
		int size = 35;
		int id = 1, nextId = 2;
		pair<int, int> pos[5];
		pair<int, int> data[20][5];
	} block;

	void SetBlockData(int blockId, int blockCnt, int posX, int posY);

	void UpdateBlockData(void);
	void UpdateDrawLength(void);
	void UpdateMap(void);

	void DrawWindow(void);
	void DrawBackgound(void);
	void DrawBarrier(void);
	void DrawMap(void);
	void DrawBlock(int posX, int posY);
	void DrawBlocks(void);
	void DrawGameEnd(void);

	void EventBlockMove(int moveX, int moveY);
	void EventBlockGenerate(void);
	void EventBlockChange(void);
	void EventKeyDown(void);
	void EventCleanFullLine(void);

	bool CheckBarrierTop(void);
	bool CheckBarrierButtom(void);
	bool CheckBarrierLeft(void);
	bool CheckBarrierRight(void);
	bool CheckGameEnd(void);

	bool CheckBlockValid(pair<int, int>* pos);
	bool CheckBlockDownBlock(void);
	bool CheckBlockLeftBlock(void);
	bool CheckBlockRightBlock(void);

};

int main()
{
	int blocksX = 10, blocksY = 18, blockSize = 35;
	Tetris game(blocksX, blocksY, blockSize);

	loadimage(&game.picBlocks[0], _T("assets/brown.png"), blockSize, blockSize);
	loadimage(&game.picBlocks[1], _T("assets/deep_blue.png"), blockSize, blockSize);
	loadimage(&game.picBlocks[2], _T("assets/green.png"), blockSize, blockSize);
	loadimage(&game.picBlocks[3], _T("assets/purple.png"), blockSize, blockSize);
	loadimage(&game.picBlocks[4], _T("assets/red.png"), blockSize, blockSize);
	loadimage(&game.picBlocks[5], _T("assets/shallow_blue.png"), blockSize, blockSize);
	loadimage(&game.picBlocks[6], _T("assets/yellow.png"), blockSize, blockSize);

	game.EventBlockGenerate();
	game.EventBlockGenerate();
	game.DrawWindow();

	while (true)
	{
		game.startTime = clock();

		BeginBatchDraw();
		cleardevice();

		game.EventCleanFullLine();
		game.EventKeyDown();

		game.DrawBackgound();
		game.DrawBarrier();

		if (game.CheckBarrierTop()) break;
		if (game.CheckBlockDownBlock() || game.CheckBarrierButtom())
		{
			game.UpdateMap();
			game.EventBlockGenerate();
		}

		if (game.cntFPS >= 15)
		{
			game.EventBlockMove(0, 1);
			game.cntFPS = 0;
		}

		game.DrawMap();
		game.DrawBlocks();

		EndBatchDraw();
		if (game.CheckGameEnd()) break;

		game.cntFPS++;
		game.endTime = clock();

		game.costTime = (game.endTime - game.startTime) % game.FPS;
		if (game.costTime < game.FPS)
		{
			Sleep(game.FPS - game.costTime);
		}
	}

	game.DrawGameEnd();
	Sleep(2000);
	return 0;
}

void Tetris::SetBlockData(int blockId, int blockCnt, int posX, int posY)
{
	block.data[blockId][blockCnt].X = posX;
	block.data[blockId][blockCnt].Y = posY;
}

void Tetris::UpdateBlockData(void)
{
	int centerPos = block.blocksX / 2;
	
	SetBlockData(1, 1, centerPos,		0);
	SetBlockData(1, 2, centerPos + 1,	0);
	SetBlockData(1, 3, centerPos,		-1);
	SetBlockData(1, 4, centerPos + 1,	-1);

	SetBlockData(2, 1, centerPos - 1,	0);
	SetBlockData(2, 2, centerPos,		0);
	SetBlockData(2, 3, centerPos + 1,	0);
	SetBlockData(2, 4, centerPos + 2,	0);

	SetBlockData(3, 1, centerPos,		0);
	SetBlockData(3, 2, centerPos,		-1);
	SetBlockData(3, 3, centerPos,		-2);
	SetBlockData(3, 4, centerPos,		-3);

	SetBlockData(4, 1, centerPos,		0);
	SetBlockData(4, 2, centerPos + 1,	0);
	SetBlockData(4, 3, centerPos + 1,	-1);
	SetBlockData(4, 4, centerPos + 2,	-1);

	SetBlockData(5, 1, centerPos + 1,	0);
	SetBlockData(5, 2, centerPos,		-1);
	SetBlockData(5, 3, centerPos + 1,	-1);
	SetBlockData(5, 4, centerPos,		-2);

	SetBlockData(6, 1, centerPos,		0);
	SetBlockData(6, 2, centerPos + 1,	0);
	SetBlockData(6, 3, centerPos - 1,	-1);
	SetBlockData(6, 4, centerPos,		-1);

	SetBlockData(7, 1, centerPos,		0);
	SetBlockData(7, 2, centerPos,		-1);
	SetBlockData(7, 3, centerPos + 1,	-1);
	SetBlockData(7, 4, centerPos + 1,	-2);

	SetBlockData(8, 1, centerPos - 1,	0);
	SetBlockData(8, 2, centerPos,		0);
	SetBlockData(8, 3, centerPos + 1,	0);
	SetBlockData(8, 4, centerPos,		-1);

	SetBlockData(9, 1, centerPos,		0);
	SetBlockData(9, 2, centerPos,		-1);
	SetBlockData(9, 3, centerPos + 1,	-1);
	SetBlockData(9, 4, centerPos,		-2);

	SetBlockData(10, 1, centerPos,		0);
	SetBlockData(10, 2, centerPos - 1,	-1);
	SetBlockData(10, 3, centerPos,		-1);
	SetBlockData(10, 4, centerPos + 1,	-1);

	SetBlockData(11, 1, centerPos,		0);
	SetBlockData(11, 2, centerPos - 1,	-1);
	SetBlockData(11, 3, centerPos,		-1);
	SetBlockData(11, 4, centerPos,		-2);

	SetBlockData(12, 1, centerPos,		0);
	SetBlockData(12, 2, centerPos + 1,	0);
	SetBlockData(12, 3, centerPos + 2,	0);
	SetBlockData(12, 4, centerPos,		-1);

	SetBlockData(13, 1, centerPos,		0);
	SetBlockData(13, 2, centerPos,		-1);
	SetBlockData(13, 3, centerPos,		-2);
	SetBlockData(13, 4, centerPos + 1,	-2);

	SetBlockData(14, 1, centerPos + 2,	0);
	SetBlockData(14, 2, centerPos,		-1);
	SetBlockData(14, 3, centerPos + 1,	-1);
	SetBlockData(14, 4, centerPos + 2,	-1);

	SetBlockData(15, 1, centerPos,		0);
	SetBlockData(15, 2, centerPos + 1,	0);
	SetBlockData(15, 3, centerPos + 1,	-1);
	SetBlockData(15, 4, centerPos + 1,	-2);

	SetBlockData(16, 1, centerPos,		0);
	SetBlockData(16, 2, centerPos + 1,	0);
	SetBlockData(16, 3, centerPos + 2,	0);
	SetBlockData(16, 4, centerPos + 2,	-1);

	SetBlockData(17, 1, centerPos,		0);
	SetBlockData(17, 2, centerPos + 1,	0);
	SetBlockData(17, 3, centerPos,		-1);
	SetBlockData(17, 4, centerPos,		-2);

	SetBlockData(18, 1, centerPos,		0);
	SetBlockData(18, 2, centerPos,		-1);
	SetBlockData(18, 3, centerPos + 1,	-1);
	SetBlockData(18, 4, centerPos + 2,	-1);

	SetBlockData(19, 1, centerPos + 1,	0);
	SetBlockData(19, 2, centerPos + 1,	-1);
	SetBlockData(19, 3, centerPos,		-2);
	SetBlockData(19, 4, centerPos + 1,	-2);
}

void Tetris::UpdateDrawLength(void)
{
	render.barrierWidth = render.barrierPadding * 2 + block.blocksX * block.size+ (block.blocksX - 1) * render.blockSpace;
	render.barrierHeight = render.barrierPadding * 2 + block.blocksY * block.size + (block.blocksY - 1) * render.blockSpace;
	
	render.windowWidth = render.windowPadding * 2 + render.barrierWidth + render.blockSpace + 0;
	render.windowHeight = render.windowPadding * 2 + render.barrierHeight;

	render.spotBarrierLeft = render.windowPadding;
	render.spotBarrierTop = render.spotBarrierLeft;
	render.spotBlockLeft = render.windowPadding + render.barrierPadding;
	render.spotBlockTop = render.spotBlockLeft;
}

void Tetris::UpdateMap(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		map[block.pos[cnt].X][block.pos[cnt].Y] = 1;
	}
}

void Tetris::DrawWindow()
{
	
	initgraph(render.windowWidth, render.windowHeight);
}

void Tetris::DrawBackgound(void)
{
	IMAGE bk;
	loadimage(&bk, _T("assets/gameBK.png"), 1239, 850);
	putimage(0, 0, &bk);
}

void Tetris::DrawBarrier(void)
{
	// draw bk
	setfillcolor(RGB(46, 48, 54));
	setlinecolor(BLACK);
	fillroundrect(render.spotBarrierLeft, render.spotBarrierTop,
		render.spotBarrierLeft + render.barrierWidth, render.spotBarrierTop + render.barrierHeight,
		render.barrierEllipse, render.barrierEllipse);
	// draw blocks
	setfillcolor(RGB(54, 57, 63));
	setlinecolor(RGB(54, 57, 63));
	for (int x = 1, y = 1; ; y++)
	{
		if (y > block.blocksY) y = 1, x++;
		if (x > block.blocksX) break;

		int right = render.spotBlockLeft + x * block.size + (x - 1) * render.blockSpace;
		int buttom = render.spotBlockTop + y * block.size + (y - 1) * render.blockSpace;
		fillroundrect(right - block.size, buttom - block.size, right, buttom,
			render.barrierEllipse / 2, render.barrierEllipse / 2);
	}
}

void Tetris::DrawMap(void)
{
	for (int x = 1, y= 1; ; y++)
	{
		if (y > block.blocksY) y = 1, x++;
		if (x > block.blocksX) break;
		if (map[x][y] == 1) DrawBlock(x, y);
	}
}

void Tetris::DrawBlock(int posX, int posY)
{
	int left = render.spotBlockLeft + (posX - 1) * (block.size + render.blockSpace);
	int top = render.spotBlockTop + (posY - 1) * (block.size + render.blockSpace);
	putimage(left, top, &picBlocks[colorId]);
}

void Tetris::DrawBlocks(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		if (block.pos[cnt].Y >= 1) DrawBlock(block.pos[cnt].X, block.pos[cnt].Y);
	}
}

void Tetris::DrawGameEnd(void)
{
	settextcolor(GREEN);
	setbkmode(TRANSPARENT);
	settextstyle(70, 0, _T("微软雅黑"));

	LOGFONT f;
	gettextstyle(&f);
	f.lfQuality = ANTIALIASED_QUALITY;
	f.lfWeight = FW_BLACK;
	//
	RECT r = { 0, 0, render.windowWidth, render.windowHeight };
	drawtext(_T("Game over!"), &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
}

void Tetris::EventBlockMove(int moveX, int moveY)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		block.pos[cnt].X += moveX;
		block.pos[cnt].Y += moveY;
	}
}

void Tetris::EventBlockGenerate(void)
{
	srand(int(time(0)));
	block.id = block.nextId;
	block.nextId = rand() % 19 + 1;
	colorId = rand() % 7;

	for (int cnt = 1; cnt <= 4; cnt++)
	{
		int x = block.data[block.id][cnt].X;
		int y = block.data[block.id][cnt].Y;
		block.pos[cnt] = { x, y };
	}
}

void Tetris::EventBlockChange(void)
{
	int newBlockId;
	int moveBlocksX;
	int moveBlocksY;
	pair<int, int> newPos[5];

	// calc down distance
	moveBlocksX = block.pos[1].X - block.data[block.id][1].X;
	moveBlocksY = block.pos[1].Y - block.data[block.id][1].Y;

	// next id
	switch (block.id)
	{
	case 2:
	case 4:  
	case 6:
	case 8:
	case 9:
	case 10:
	case 12: 
	case 13: 
	case 14:
	case 16: 
	case 17: 
	case 18:
		newBlockId = block.id + 1;
		break;
	case 3:
	case 5:
	case 7:
		newBlockId = block.id - 1;
		break;
	case 11:
	case 15:
	case 19:
		newBlockId = block.id - 3;
		break;
	default:
		newBlockId = block.id;
	}

	// calc newPos
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		newPos[cnt].X = block.data[newBlockId][cnt].X + moveBlocksX;
		newPos[cnt].Y = block.data[newBlockId][cnt].Y + moveBlocksY;
	}

	// check newPos valid
	if (CheckBlockValid(newPos))
	{// update pos

		block.id = newBlockId;
		for (int cnt = 1; cnt <= 4; cnt++)
		{
			block.pos[cnt].X = newPos[cnt].X;
			block.pos[cnt].Y = newPos[cnt].Y;
		}
	}
}

void Tetris::EventKeyDown(void)
{
	ExMessage key;
	do
	{
		if (!peekmessage(&key, EX_KEY)) break;
		if (key.message != WM_KEYDOWN) break;

		if (key.vkcode == VK_LEFT && !CheckBlockLeftBlock() && !CheckBarrierLeft())
			EventBlockMove(-1, 0);
		else if (key.vkcode == VK_RIGHT && !CheckBlockRightBlock() && !CheckBarrierRight())
			EventBlockMove(1, 0);
		else if (key.vkcode == VK_DOWN)
		{
			if (!CheckBlockDownBlock() || !CheckBarrierButtom())
				EventBlockMove(0, 1);
		}
		else if (key.vkcode == VK_UP)
			EventBlockChange();
		else cout << "Unkonwn key down" << endl;

		flushmessage(-1);

	} while (false);
}

void Tetris::EventCleanFullLine(void)
{
	for (int y = block.blocksY; y >= 1; y--)
	{
		bool isFull = true;
		for (int x = 1; x <= block.blocksX; x++)
		{
			if (map[x][y] != 1)
			{
				isFull = false;
				break;
			}
		}
		if (isFull)
		{
			for (int yy = y; yy >= 1; yy--)
			{
				for (int xx = 1; xx <= block.blocksX; xx++)
				{
					map[xx][yy] = map[xx][yy - 1];
				}
			}
			y++;
		}
	}
}

bool Tetris::CheckBarrierTop(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		if (block.pos[cnt].Y == 0 && 
			map[block.pos[cnt].X][1] == 1)
			return true;
	}
	return false;
}

bool Tetris::CheckBarrierButtom(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		if (block.pos[cnt].Y >= block.blocksY) return true;
	}
	return false;
}

bool Tetris::CheckBarrierLeft(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		if (block.pos[cnt].X <= 1) return true;
	}
	return false;
}

bool Tetris::CheckBarrierRight(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		if (block.pos[cnt].X >= block.blocksX) return true;
	}
	return false;
}

bool Tetris::CheckGameEnd(void)
{
	for (int x = 1; x <= block.blocksX; x++)
	{
		if (map[x][0] == 1) return true;
	}
	return false;
}

bool Tetris::CheckBlockValid(pair<int, int>* pos)
{
	// check block hit block
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		int x = pos[cnt].X;
		int y = pos[cnt].Y;
		if (x < 1 || x > block.blocksX) return false;
		if (y < 1 || y > block.blocksY) return false;
		if (map[x][y] == 1) return false;
	}
	return true;
}

bool Tetris::CheckBlockDownBlock(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		if (map[block.pos[cnt].X][block.pos[cnt].Y + 1] == 1) return true;
	}
	return false;
}

bool Tetris::CheckBlockLeftBlock(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		int x = block.pos[cnt].X - 1;
		int y = block.pos[cnt].Y;
		if (map[x][y] == 1) return true;
	}
	return false;
}

bool Tetris::CheckBlockRightBlock(void)
{
	for (int cnt = 1; cnt <= 4; cnt++)
	{
		int x = block.pos[cnt].X + 1;
		int y = block.pos[cnt].Y;
		if (map[x][y] == 1) return true;
	}
	return false;
}
已折叠代码,点击展开

2.0 Version ? –> 404 Not Found