俄罗斯方块开发日志
说明
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 群问老师,看公开小游戏代码,看视频教程。本来感觉是有思路的,按照这么来应该是可以实现的,但是,就是报错,跑不通,反反复复开发了几遍,顺过去顺过来都感觉没问题,看别人的实现方案感觉也差不多的,能看懂,有一个方案当时没看懂,就是用二进制,但是对二进制还不熟悉,没理解怎么用一个数就能映射方块的形状的。

结果,最终折腾了好久,终于通过 debug ,一点一点的看代码,追踪堆栈,终于发现了问题。在函数之间传值的之后,传递的数据丢了,最终才终于搞懂了,什么是 “动态分配内存” ,什么是 “指针传值” 。最终才好不容易跑通了最基础的一个版本。这一刻,感觉编程一下就变简单了,所有的问题瞬间都通透了。
但是在用图形渲染库的时候还遇到了问题,当时开源的库主流的好像有两种,一个是 EasyX,另一个记不住了,最终选择的 EasyX,因为另外一个没看懂,EasyX 有些内容也没看明白,当时官网好像是全英文的,可读性太低了,我也懒得一句一句读,怎么配 EasyX 的环境,导入依赖使用,但是是没搞明白的, 但还是跟着教程说明跑通了。尤其是用 EasyX 处理文本渲染的时候,感觉老麻烦了,什么字体之类的,什么数据变量之类的。还有按键监听,帧率控制也是难点。
整体上,全靠自己设计思路,自己实现,自己 debug ,实在是不容易啊。最终只是跑通整个流程之后,就没在继续开发了,当时感觉没继续开发的必要了,因为已经发完朋友圈了😄。再继续开发,也只是完善细节,花时间打磨而已,浪费精力,然后就放弃了,知道有 bug 也没改。
最后的收获总结就是:“动态分配内存”、“debug”、“数据结构”、“代码画图”、“按键监听”、“帧率控制”、“二进制”、“面向对象”、“画布”、“流程控制”。
有老师带的话,可以少踩很多坑,但是我自己踩的坑折腾这些,经验更加深刻,感悟更深。
唉,现在都用 AI 直接开发了,后来再学计算机,再学编程,如果没这种经验,还真能看得懂代码吗?未来还真的需要看代码吗?作为一个程序员怎能不看代码呢?
补充:
当时开发完了俄罗斯方块,我在 “游戏开发” 上面起了一些兴趣,当时本打算继续开发其他小游戏的,当时正巧在玩一个小游戏,叫作 “猛鬼宿舍” ,当时正好感觉这个小游戏挺有意思的,还做了一些攻略,就是玩多了之后,玩法太单调了,就打算自己复刻这个游戏然后自己开发新功能的。

可惜的是,在刚开始新建文件夹之后,发现,最难得不是代码,而是没有图片素材,找不到游戏资源,那个时候 AI 还不怎么厉害,从来没想过有朝一日还能结合 AI 生图开发游戏。
因此,在当时,一想到没有游戏资源,一想到一款游戏开发需要用到那么多资源,我就开始劝退了。当时的唯一进度,就是,在 B 站上刷到了一个教从 0 开始一点一点源代码级别的教 C++ 游戏开发的,还有博主教游戏开发经验的,还知道了什么叫 “精灵图” 、“地图绘制”、“摄像头” 等概念,才知道,原来游戏开发有这么多概念,是这么回事。当我在用一张 MC 石头的贴图画出来这个游戏地图之后就放弃了,在当时根本是我自己一个人难以完成的项目,更不用说,这个游戏还有人机,离线下也能玩。
我的游戏开发之路,就此结束。
补充:我的原始项目已经消失了,原因就是当时电脑硬盘坏了,所有数据全部丢了,我几乎把所有数据都放到了那个坏掉的 1 T 硬盘上,所有的工作目录,所有的项目,所有的应用程序,所有搜集的资料,所有的相册。😭😭😭😭😭😭😭😭😭😭😭😭😭😭😭
演示效果预览
这应该是第一个版本的效果,因为第一次跑通,很激动,发了朋友圈视频的,后面对其进行了优化的,但是没再发朋友圈了,只有这一个预览截图了。优化之后的,还有一些 UI ,更加完善些。

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

估计最终的版本,源代码已经丢了,再也找不会了,只存在记忆中了。
原始日志记录
2024-11-27
准备工作
在电子书《深入体验 C 语言项目开发》中看到俄罗斯方块的开发,受到启发,想要挑战自己开发俄罗斯方块小游戏。
了解到一个图形库“easyx.h”,计划借助此库完成开发。
下载并安装好库之后,简单了解了一下 easyx 这个库的功能。
尝试了基础的简单画图.
2024-11-28
获取按键操作
在我使用_getch()函数模拟获取按键的过程中,发现一个巨大的问题:
绘图的界面和控制台不是同一个窗口,我只能在控制台获取按键,因此,我在获取按键之前,必须先让鼠标聚焦在控制台上,不能隐藏掉控制台界面,只显示绘画的图形界面,相当的不优雅。
在 B 站上观摩他人实现俄罗斯方块的过程,发现,可以使用 easyx 库中自带的 ExMessage 完成获取按键的过程。
根据示例代码,初次尝试,无法正常获取键盘输入,但是鼠标操作正常,不知道原因,重新观看 B 站视频教程的实现过程。
发现问题,问题原因:消息类型判错错误。
CExMessage 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
再再战俄罗斯方块
计划:
- 更改底层代码,C 语言转 C++.因此浏览一遍 C++文档.面向对象内容加上一些常用的库.顺便复习编程语言
- 重新学习 easyx 绘图库.
- 一个一个小环节的写,调试.先让一部分跑起来,再丰富内容.
第一步:让单方块动起来
#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;
}第二步:让完整方块动起来
#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
第三步:让多个方块堆叠起来
#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