├── pic
    ├── 1.png
    ├── 2.png
    └── game.gif
├── QtTetris
    ├── main.cpp
    ├── QtTetris.pro
    ├── widget.ui
    ├── widget.h
    └── widget.cpp
└── README.md


/pic/1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tashaxing/QtTetris/HEAD/pic/1.png


--------------------------------------------------------------------------------
/pic/2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tashaxing/QtTetris/HEAD/pic/2.png


--------------------------------------------------------------------------------
/pic/game.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tashaxing/QtTetris/HEAD/pic/game.gif


--------------------------------------------------------------------------------
/QtTetris/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "widget.h"
 2 | #include <QApplication>
 3 | 
 4 | int main(int argc, char *argv[])
 5 | {
 6 |     QApplication a(argc, argv);
 7 |     Widget w;
 8 |     w.show();
 9 | 
10 |     return a.exec();
11 | }
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # QtTetris
2 | A tetris game written in Qt<br/>
3 | blog address:http://blog.csdn.net/u012234115/article/details/45966479<br/>
4 | # ScreentShots
5 | ![](https://github.com/tashaxing/QtTetris/raw/master/pic/game.gif)<br/>
6 | ![](https://github.com/tashaxing/QtTetris/raw/master/pic/1.png)<br/>
7 | ![](https://github.com/tashaxing/QtTetris/raw/master/pic/2.png)<br/>


--------------------------------------------------------------------------------
/QtTetris/QtTetris.pro:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------
 2 | #
 3 | # Project created by QtCreator 2015-05-23T16:45:48
 4 | #
 5 | #-------------------------------------------------
 6 | 
 7 | QT       += core gui
 8 | 
 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
10 | 
11 | TARGET = QtTetris
12 | TEMPLATE = app
13 | 
14 | 
15 | SOURCES += main.cpp\
16 |         widget.cpp
17 | 
18 | HEADERS  += widget.h
19 | 
20 | FORMS    += widget.ui
21 | 


--------------------------------------------------------------------------------
/QtTetris/widget.ui:
--------------------------------------------------------------------------------
 1 | <ui version="4.0">
 2 |  <class>Widget</class>
 3 |  <widget class="QWidget" name="Widget" >
 4 |   <property name="geometry" >
 5 |    <rect>
 6 |     <x>0</x>
 7 |     <y>0</y>
 8 |     <width>400</width>
 9 |     <height>300</height>
10 |    </rect>
11 |   </property>
12 |   <property name="windowTitle" >
13 |    <string>Widget</string>
14 |   </property>
15 |  </widget>
16 |  <layoutDefault spacing="6" margin="11" />
17 |  <pixmapfunction></pixmapfunction>
18 |  <resources/>
19 |  <connections/>
20 | </ui>
21 | 


--------------------------------------------------------------------------------
/QtTetris/widget.h:
--------------------------------------------------------------------------------
 1 | #ifndef WIDGET_H
 2 | #define WIDGET_H
 3 | 
 4 | #include <QWidget>
 5 | 
 6 | const int BLOCK_SIZE=25; //单个方块单元的边长
 7 | const int MARGIN=5; //场景边距
 8 | const int AREA_ROW=20; //场景行数
 9 | const int AREA_COL=12; //场景列数
10 | 
11 | //方向
12 | enum Direction
13 | {
14 |     UP,
15 |     DOWN,
16 |     LEFT,
17 |     RIGHT,
18 |     SPACE
19 | };
20 | 
21 | //定义边界信息
22 | struct Border
23 | {
24 |     int ubound;
25 |     int dbound;
26 |     int lbound;
27 |     int rbound;
28 | };
29 | 
30 | //坐标
31 | struct block_point
32 | {
33 |     int pos_x;
34 |     int pos_y;
35 |     //    block_point(int x,int y):pos_x(x),pos_y(y){}
36 | };
37 | 
38 | namespace Ui {
39 | class Widget;
40 | }
41 | 
42 | class Widget : public QWidget
43 | {
44 |     Q_OBJECT
45 | 
46 | public:
47 |     void InitGame(); //初始化
48 |     void StartGame(); //开始游戏
49 |     void GameOver(); //游戏结束
50 | 
51 |     void ResetBlock(); //重置方块
52 |     void BlockMove(Direction dir); //方块变动
53 |     void BlockRotate(int block[4][4]); //方块旋转
54 |     void CreateBlock(int block[4][4],int block_id); //产生方块
55 |     void GetBorder(int block[4][4],Border &border); //计算边界
56 |     void ConvertStable(int x,int y); //转换为稳定方块
57 |     bool IsCollide(int x,int y,Direction dir); //判断是否会碰撞
58 | 
59 | public:
60 |     explicit Widget(QWidget *parent = 0);
61 |     ~Widget();
62 | 
63 |     virtual void paintEvent(QPaintEvent *event); //场景刷新
64 |     virtual void timerEvent(QTimerEvent *event); //定时器事件
65 |     virtual void keyPressEvent(QKeyEvent *event); //键盘响应
66 | 
67 | private:
68 |     Ui::Widget *ui;
69 | 
70 | private:
71 |     int game_area[AREA_ROW][AREA_COL]; //场景区域，1表示活动的方块，2表示稳定的方块，0表示空
72 |     block_point block_pos; //当前方块坐标
73 |     int cur_block[4][4]; //当前方块形状
74 |     Border cur_border; //当前方块边界
75 |     int next_block[4][4]; //下一个方块形状
76 |     bool isStable; //当前方块是否稳定了
77 |     int score;  //游戏分数
78 |     int game_timer; //方块下落计时器
79 |     int paint_timer; //渲染刷新计时器
80 |     int speed_ms; //下落时间间隔
81 |     int refresh_ms; //刷新时间间隔
82 | 
83 | };
84 | 
85 | #endif // WIDGET_H
86 | 


--------------------------------------------------------------------------------
/QtTetris/widget.cpp:
--------------------------------------------------------------------------------
  1 | #include <time.h>
  2 | #include <QMessageBox>
  3 | #include <QDebug>
  4 | #include <QPainter>
  5 | #include <QKeyEvent>
  6 | #include "widget.h"
  7 | #include "ui_widget.h"
  8 | 
  9 | 
 10 | //定义图案代码和边界
 11 | //田字
 12 | int item1[4][4]=
 13 | {
 14 |     {0,0,0,0},
 15 |     {0,1,1,0},
 16 |     {0,1,1,0},
 17 |     {0,0,0,0}
 18 | };
 19 | //右L
 20 | int item2[4][4]=
 21 | {
 22 |     {0,1,0,0},
 23 |     {0,1,0,0},
 24 |     {0,1,1,0},
 25 |     {0,0,0,0}
 26 | };
 27 | //左L
 28 | int item3[4][4]=
 29 | {
 30 |     {0,0,1,0},
 31 |     {0,0,1,0},
 32 |     {0,1,1,0},
 33 |     {0,0,0,0}
 34 | };
 35 | //右S
 36 | int item4[4][4]=
 37 | {
 38 |     {0,1,0,0},
 39 |     {0,1,1,0},
 40 |     {0,0,1,0},
 41 |     {0,0,0,0}
 42 | };
 43 | //左S
 44 | int item5[4][4]=
 45 | {
 46 |     {0,0,1,0},
 47 |     {0,1,1,0},
 48 |     {0,1,0,0},
 49 |     {0,0,0,0}
 50 | };
 51 | //山形
 52 | int item6[4][4]=
 53 | {
 54 |     {0,0,0,0},
 55 |     {0,0,1,0},
 56 |     {0,1,1,1},
 57 |     {0,0,0,0}
 58 | };
 59 | //长条
 60 | int item7[4][4]=
 61 | {
 62 |     {0,0,1,0},
 63 |     {0,0,1,0},
 64 |     {0,0,1,0},
 65 |     {0,0,1,0}
 66 | };
 67 | 
 68 | //拷贝方块图案
 69 | inline void block_cpy(int dblock[4][4],int sblock[4][4])
 70 | {
 71 |     for(int i=0;i<4;i++)
 72 |         for(int j=0;j<4;j++)
 73 |             dblock[i][j]=sblock[i][j];
 74 | }
 75 | 
 76 | Widget::Widget(QWidget *parent) :
 77 |     QWidget(parent),
 78 |     ui(new Ui::Widget)
 79 | {
 80 |     ui->setupUi(this);
 81 |     //调整窗口尺寸布局
 82 |     resize(AREA_COL*BLOCK_SIZE+MARGIN*4+4*BLOCK_SIZE,AREA_ROW*BLOCK_SIZE+MARGIN*2);
 83 |     //初始化游戏
 84 |     InitGame();
 85 | }
 86 | 
 87 | Widget::~Widget()
 88 | {
 89 |     delete ui;
 90 | }
 91 | 
 92 | void Widget::paintEvent(QPaintEvent *event)
 93 | {
 94 |     QPainter painter(this);
 95 |     //画游戏场景边框
 96 |     painter.setBrush(QBrush(Qt::white,Qt::SolidPattern));
 97 |     painter.drawRect(MARGIN,MARGIN,AREA_COL*BLOCK_SIZE,AREA_ROW*BLOCK_SIZE);
 98 |     //画方块预告
 99 |     painter.setBrush(QBrush(Qt::blue,Qt::SolidPattern));
100 |     for(int i=0;i<4;i++)
101 |         for(int j=0;j<4;j++)
102 |             if(next_block[i][j]==1)
103 |                 painter.drawRect(MARGIN*3+AREA_COL*BLOCK_SIZE+j*BLOCK_SIZE,MARGIN+i*BLOCK_SIZE,BLOCK_SIZE,BLOCK_SIZE);
104 |     //绘制得分
105 |     painter.setPen(Qt::black);
106 |     painter.setFont(QFont("Arial",14));
107 |     painter.drawText(QRect(MARGIN*3+AREA_COL*BLOCK_SIZE,MARGIN*2+4*BLOCK_SIZE,BLOCK_SIZE*4,BLOCK_SIZE*4),Qt::AlignCenter,"score: "+QString::number(score));
108 | 
109 | 
110 |     //绘制下落方块和稳定方块,注意方块边线的颜色是根据setPen来的，默认黑色
111 |     for(int i=0;i<AREA_ROW;i++)
112 |         for(int j=0;j<AREA_COL;j++)
113 |         {
114 |             //绘制活动方块
115 |             if(game_area[i][j]==1)
116 |             {
117 |                 painter.setBrush(QBrush(Qt::red,Qt::SolidPattern));
118 |                 painter.drawRect(j*BLOCK_SIZE+MARGIN,i*BLOCK_SIZE+MARGIN,BLOCK_SIZE,BLOCK_SIZE);
119 |             }
120 |             //绘制稳定方块
121 |             else if(game_area[i][j]==2)
122 |             {
123 |                 painter.setBrush(QBrush(Qt::green,Qt::SolidPattern));
124 |                 painter.drawRect(j*BLOCK_SIZE+MARGIN,i*BLOCK_SIZE+MARGIN,BLOCK_SIZE,BLOCK_SIZE);
125 |             }
126 |         }
127 | }
128 | 
129 | void Widget::timerEvent(QTimerEvent *event)
130 | {
131 |     //方块下落
132 |     if(event->timerId()==game_timer)
133 |         BlockMove(DOWN);
134 |     //刷新画面
135 |     if(event->timerId()==paint_timer)
136 |         update();
137 | }
138 | 
139 | void Widget::keyPressEvent(QKeyEvent *event)
140 | {
141 |     switch(event->key())
142 |     {
143 |     case Qt::Key_Up:
144 |         BlockMove(UP);
145 |         break;
146 |     case Qt::Key_Down:
147 |         BlockMove(DOWN);
148 |         break;
149 |     case Qt::Key_Left:
150 |         BlockMove(LEFT);
151 |         break;
152 |     case Qt::Key_Right:
153 |         BlockMove(RIGHT);
154 |         break;
155 |     case Qt::Key_Space:
156 |         BlockMove(SPACE);
157 |         break;
158 |     default:
159 |         break;
160 |     }
161 | }
162 | 
163 | void Widget::CreateBlock(int block[4][4],int block_id)
164 | {
165 |     switch (block_id)
166 |     {
167 |     case 0:
168 |         block_cpy(block,item1);
169 |         break;
170 |     case 1:
171 |         block_cpy(block,item2);
172 |         break;
173 |     case 2:
174 |         block_cpy(block,item3);
175 |         break;
176 |     case 3:
177 |         block_cpy(block,item4);
178 |         break;
179 |     case 4:
180 |         block_cpy(block,item5);
181 |         break;
182 |     case 5:
183 |         block_cpy(block,item6);
184 |         break;
185 |     case 6:
186 |         block_cpy(block,item7);
187 |         break;
188 |     default:
189 |         break;
190 |     }
191 | }
192 | 
193 | void Widget::GetBorder(int block[4][4],Border &border)
194 | {
195 |     //计算上下左右边界
196 |     for(int i=0;i<4;i++)
197 |         for(int j=0;j<4;j++)
198 |             if(block[i][j]==1)
199 |             {
200 |                 border.dbound=i;
201 |                 break; //直到计算到最后一行有1
202 |             }
203 |     for(int i=3;i>=0;i--)
204 |         for(int j=0;j<4;j++)
205 |             if(block[i][j]==1)
206 |             {
207 |                 border.ubound=i;
208 |                 break;
209 |             }
210 |     for(int j=0;j<4;j++)
211 |         for(int i=0;i<4;i++)
212 |             if(block[i][j]==1)
213 |             {
214 |                 border.rbound=j;
215 |                 break;
216 |             }
217 |     for(int j=3;j>=0;j--)
218 |         for(int i=0;i<4;i++)
219 |             if(block[i][j]==1)
220 |             {
221 |                 border.lbound=j;
222 |                 break;
223 |             }
224 | //    qDebug()<<cur_border.ubound<<cur_border.dbound<<cur_border.lbound<<cur_border.rbound;
225 | }
226 | 
227 | void Widget::InitGame()
228 | {
229 |     for(int i=0;i<AREA_ROW;i++)
230 |         for(int j=0;j<AREA_COL;j++)
231 |             game_area[i][j]=0;
232 | 
233 |     speed_ms=800;
234 |     refresh_ms=30;
235 | 
236 |     //初始化随机数种子
237 |     srand(time(0));
238 | 
239 |     //分数清0
240 |     score=0;
241 | 
242 |     //开始游戏
243 |     StartGame();
244 | }
245 | 
246 | void Widget::ResetBlock()
247 | {
248 |     //产生当前方块
249 |     block_cpy(cur_block,next_block);
250 |     GetBorder(cur_block,cur_border);
251 | 
252 |     //产生下一个方块
253 |     int block_id=rand()%7;
254 |     CreateBlock(next_block,block_id);
255 | 
256 |     //设置初始方块坐标,以方块左上角为锚点
257 |     block_point start_point;
258 |     start_point.pos_x=AREA_COL/2-2;
259 |     start_point.pos_y=0;
260 |     block_pos=start_point;
261 | }
262 | 
263 | void Widget::StartGame()
264 | {
265 |     game_timer=startTimer(speed_ms); //开启游戏timer
266 |     paint_timer=startTimer(refresh_ms); //开启界面刷新timer
267 |     //产生初始下一个方块
268 |     int block_id=rand()%7;
269 |     CreateBlock(next_block,block_id);
270 |     ResetBlock(); //产生方块
271 | }
272 | 
273 | void Widget::GameOver()
274 | {
275 |     //游戏结束停止计时器
276 |     killTimer(game_timer);
277 |     killTimer(paint_timer);
278 |     QMessageBox::information(this,"failed","game over");
279 | 
280 | }
281 | 
282 | void Widget::BlockRotate(int block[4][4])
283 | {
284 |     int temp_block[4][4];
285 |     for(int i=0;i<4;i++)
286 |         for(int j=0;j<4;j++)
287 |             temp_block[3-j][i]=block[i][j];
288 |     for(int i=0;i<4;i++)
289 |         for(int j=0;j<4;j++)
290 |             block[i][j]=temp_block[i][j];
291 | }
292 | 
293 | void Widget::ConvertStable(int x,int y)
294 | {
295 |     for(int i=cur_border.ubound;i<=cur_border.dbound;i++)
296 |         for(int j=cur_border.lbound;j<=cur_border.rbound;j++)
297 |             if(cur_block[i][j]==1)
298 |                 game_area[y+i][x+j]=2; //x和y别搞反
299 | }
300 | 
301 | bool Widget::IsCollide(int x,int y,Direction dir)
302 | {
303 |     //用拷贝的临时方块做判断
304 |     int temp_block[4][4];
305 |     block_cpy(temp_block,cur_block);
306 |     Border temp_border;
307 |     GetBorder(temp_block,temp_border);
308 |     //先尝试按照某方向走一格
309 |     switch(dir)
310 |     {
311 |     case UP:
312 |         BlockRotate(temp_block);
313 |         GetBorder(temp_block,temp_border); //旋转后要重新计算边界
314 |         break;
315 |     case DOWN:
316 |         y+=1;
317 |         break;
318 |     case LEFT:
319 |         x-=1;
320 |         break;
321 |     case RIGHT:
322 |         x+=1;
323 |         break;
324 |     default:
325 |         break;
326 |     }
327 |     for(int i=temp_border.ubound;i<=temp_border.dbound;i++)
328 |         for(int j=temp_border.lbound;j<=temp_border.rbound;j++)
329 |             if(game_area[y+i][x+j]==2&&temp_block[i][j]==1||x+temp_border.lbound<0||x+temp_border.rbound>AREA_COL-1)
330 |                 return true;
331 |     return false;
332 | }
333 | 
334 | void Widget::BlockMove(Direction dir)
335 | {
336 |     switch (dir) {
337 |     case UP:
338 |         if(IsCollide(block_pos.pos_x,block_pos.pos_y,UP))
339 |             break;
340 |         //逆时针旋转90度
341 |         BlockRotate(cur_block);
342 |         //防止旋转后bug,i和j从0到4重新设置方块
343 |         for(int i=0;i<4;i++)
344 |             for(int j=0;j<4;j++)
345 |                 game_area[block_pos.pos_y+i][block_pos.pos_x+j]=cur_block[i][j];
346 |         //重新计算边界
347 |         GetBorder(cur_block,cur_border);
348 |         break;
349 |     case DOWN:
350 |         //方块到达边界则不再移动
351 |         if(block_pos.pos_y+cur_border.dbound==AREA_ROW-1)
352 |         {
353 |             ConvertStable(block_pos.pos_x,block_pos.pos_y);
354 |             ResetBlock();
355 |             break;
356 |         }
357 |         //碰撞检测，只计算上下左右边界，先尝试走一格，如果碰撞则稳定方块后跳出
358 |         if(IsCollide(block_pos.pos_x,block_pos.pos_y,DOWN))
359 |         {
360 |             //只有最终不能下落才转成稳定方块
361 |             ConvertStable(block_pos.pos_x,block_pos.pos_y);
362 |             ResetBlock();
363 |             break;
364 |         }
365 |         //恢复方块上场景,为了清除移动过程中的方块残留
366 |         for(int j=cur_border.lbound;j<=cur_border.rbound;j++)
367 |             game_area[block_pos.pos_y][block_pos.pos_x+j]=0;
368 |         //没有碰撞则下落一格
369 |         block_pos.pos_y+=1;
370 |         //方块下降一格，拷贝到场景,注意左右边界
371 |         for(int i=0;i<4;i++) //必须是0到4而不是边界索引，考虑到旋转后边界重新计算
372 |             for(int j=cur_border.lbound;j<=cur_border.rbound;j++)
373 |                 if(block_pos.pos_y+i<=AREA_ROW-1&&game_area[block_pos.pos_y+i][block_pos.pos_x+j]!=2) //注意场景数组不越界,而且不会擦出稳定的方块
374 |                     game_area[block_pos.pos_y+i][block_pos.pos_x+j]=cur_block[i][j];
375 |         break;
376 |     case LEFT:
377 |         //到左边界或者碰撞不再往左
378 |         if(block_pos.pos_x+cur_border.lbound==0||IsCollide(block_pos.pos_x,block_pos.pos_y,LEFT))
379 |             break;
380 |         //恢复方块右场景,为了清除移动过程中的方块残留
381 |         for(int i=cur_border.ubound;i<=cur_border.dbound;i++)
382 |             game_area[block_pos.pos_y+i][block_pos.pos_x+3]=0;
383 |         block_pos.pos_x-=1;
384 |         //方块左移一格，拷贝到场景
385 |         for(int i=cur_border.ubound;i<=cur_border.dbound;i++)
386 |             for(int j=0;j<4;j++)
387 |                 if(block_pos.pos_x+j>=0&&game_area[block_pos.pos_y+i][block_pos.pos_x+j]!=2) //注意场景数组不越界
388 |                     game_area[block_pos.pos_y+i][block_pos.pos_x+j]=cur_block[i][j];
389 |         break;
390 |     case RIGHT:
391 |         if(block_pos.pos_x+cur_border.rbound==AREA_COL-1||IsCollide(block_pos.pos_x,block_pos.pos_y,RIGHT))
392 |             break;
393 |         //恢复方块左场景,为了清除移动过程中的方块残留
394 |         for(int i=cur_border.ubound;i<=cur_border.dbound;i++)
395 |             game_area[block_pos.pos_y+i][block_pos.pos_x]=0;
396 |         block_pos.pos_x+=1;
397 |         //方块右移一格，拷贝到场景
398 |         for(int i=cur_border.ubound;i<=cur_border.dbound;i++)
399 |             for(int j=0;j<4;j++)
400 |                 if(block_pos.pos_x+j<=AREA_COL-1&&game_area[block_pos.pos_y+i][block_pos.pos_x+j]!=2) //注意场景数组不越界
401 |                     game_area[block_pos.pos_y+i][block_pos.pos_x+j]=cur_block[i][j];
402 |         break;
403 |     case SPACE: //一次到底
404 |         //一格一格下移，直到不能下移
405 |         while(block_pos.pos_y+cur_border.dbound<AREA_ROW-1&&!IsCollide(block_pos.pos_x,block_pos.pos_y,DOWN))
406 |         {
407 |             //恢复方块上场景,为了清除移动过程中的方块残留
408 |             for(int j=cur_border.lbound;j<=cur_border.rbound;j++)
409 |                 game_area[block_pos.pos_y][block_pos.pos_x+j]=0;
410 |             //没有碰撞则下落一格
411 |             block_pos.pos_y+=1;
412 |             //方块下降一格，拷贝到场景,注意左右边界
413 |             for(int i=0;i<4;i++) //必须是0到4
414 |                 for(int j=cur_border.lbound;j<=cur_border.rbound;j++)
415 |                     if(block_pos.pos_y+i<=AREA_ROW-1&&game_area[block_pos.pos_y+i][block_pos.pos_x+j]!=2) //注意场景数组不越界,而且不会擦出稳定的方块
416 |                         game_area[block_pos.pos_y+i][block_pos.pos_x+j]=cur_block[i][j];
417 |         }
418 |         ConvertStable(block_pos.pos_x,block_pos.pos_y);
419 |         ResetBlock();
420 |         break;
421 |     default:
422 |         break;
423 |     }
424 |     //处理消行，整个场景上面的行依次下移
425 |     int i=AREA_ROW-1;
426 |     int line_count=0; //记消行数
427 |     while(i>=1)
428 |     {
429 |         bool is_line_full=true;
430 |         for(int j=0;j<AREA_COL;j++)
431 |             if(game_area[i][j]==0)
432 |             {
433 |                 is_line_full=false;
434 |                 i--;
435 |                 break;
436 |             }
437 |         if(is_line_full)
438 |         {
439 |             for(int k=i;k>=1;k--)
440 |                 for(int j=0;j<AREA_COL;j++)
441 |                     game_area[k][j]=game_area[k-1][j];
442 |             line_count++;//每次增加消行的行数
443 |         }
444 |     }
445 |     score+=line_count*10; //得分
446 |     //判断游戏是否结束
447 |     for(int j=0;j<AREA_COL;j++)
448 |         if(game_area[0][j]==2) //最顶端也有稳定方块
449 |             GameOver();
450 | }
451 | 


--------------------------------------------------------------------------------