[C++] printf画的俄罗斯方块(linux异步I/O,C++)

翻看1年前的帖子，感慨呀。。。这个代码。。还是稚嫩了一点。
现在编程风格也改了很多。而且逐渐的抛弃了LINUX,转为WIN程序员。
谢谢大家的支持，补上个图把
复制下面地址，在浏览器访问：
 





学C++和linux有1.5年了，但是来论坛才没几天。昨天发个帖子，大家回复都很热情

，谢谢各位帮助！(昨天帖子地址是  )

这个方块游戏是用linux终端的光标控制、颜色设置做的
用 A S D W 控制移动、转向，空格键下坠到底；

最初是2个线程，1个用来显示画面，1个用来接收用户输入；
后来改用单线程，linux的异步aio函数解决了很多麻烦；

用了个简单的模板单例模式，继承它就可以；
对POSIX线程简单封装成java线程接口；

bug不少，大家不吝指教和建议。

///////////main.cpp

1. #include
   
2. #include "Tetris.h"
   
3. #include "TtyAuto.h"
   
4. 
   
5. int main(int ac, char *av[])
   
6. {
   
7.         std::auto_ptr autoAdjustTty(TtyAuto::getInstance());
   
8. 
   
9.         Tetris game;
   
10.         game.start();
    
11.         game.join();
    
12. 
    
13.         printf("\t\t\t\t\t\t\t\t\r");
    
14.         printf("GAME OVER!\n");
    
15. 
    
16.         return 0;
    
17. }

复制代码

/////////   Thread.h

1. #ifndef BERT_THREAD_H
   
2. #define BERT_THREAD_H
   
3. 
   
4. #include
   
5. 
   
6. /**
   
7. * 线程封装，接口模仿JAVA
   
8. */
   
9. class Runnable
   
10. {
    
11. public:
    
12.         virtual ~Runnable() { }
    
13. 
    
14.         /**
    
15.          * 线程逻辑在此实现
    
16.          */
    
17.         virtual void run() = 0;
    
18. };
    
19. 
    
20. class Thread: public Runnable
    
21. {
    
22.         /**
    
23.          * 本线程ID
    
24.          */
    
25.         pthread_t m_tid;
    
26. 
    
27.         /**
    
28.          * 是否在运行的标志
    
29.          */
    
30.         bool running;
    
31. 
    
32.         /**
    
33.          * 线程函数，内部调用run
    
34.          */
    
35.         static void * threadFunc(void * arg);
    
36. 
    
37. public:
    
38.         Thread();
    
39.         ~Thread();
    
40. 
    
41.         /**
    
42.          * 睡眠 秒
    
43.          */
    
44.         static unsigned int sleep( unsigned int seconds);
    
45. 
    
46.         /**
    
47.          * 睡眠毫秒
    
48.          */
    
49.         static unsigned int msleep( unsigned int mSeconds);
    
50. 
    
51.         /**
    
52.          * 启动线程
    
53.          */
    
54.         bool start() ;
    
55. 
    
56.         /**
    
57.          * 等待本线程运行完
    
58.          */
    
59.         void join() const;
    
60. 
    
61.         /**
    
62.          * 是否在运行
    
63.          */
    
64.         bool isAlive() const
    
65.         {
    
66.                 return running;
    
67.         }
    
68. 
    
69.         /**
    
70.          * 终止线程运行
    
71.          */
    
72.         void stop()
    
73.         {
    
74.                 running = false;
    
75.         }
    
76. };
    
77. 
    
78. #endif

复制代码

////////    Thread.cc

1. #include
   
2. #include
   
3. #include
   
4. #include "Thread.h"
   
5. 
   
6. Thread::Thread( ) : running(false)
   
7. {
   
8. }
   
9. 
   
10. Thread::~Thread()
    
11. {
    
12. }
    
13. 
    
14. void * Thread::threadFunc(void * arg)
    
15. {
    
16.         Thread * r = (Thread *) arg;
    
17.         r->running = true;
    
18.         srand(time(NULL));
    
19.         r->run();
    
20.         ::pthread_exit(NULL);
    
21.         return NULL;
    
22. }
    
23. 
    
24. unsigned int Thread::sleep( unsigned int seconds)
    
25. {
    
26.         return ::sleep(seconds);
    
27. }
    
28. 
    
29. unsigned int Thread::msleep( unsigned int mSeconds)
    
30. {
    
31.         return ::usleep(mSeconds * 1000U);
    
32. }
    
33. 
    
34. bool Thread::start()
    
35. {
    
36.         if ( !running )
    
37.         {
    
38.                 if ( ::pthread_create(&m_tid, NULL, threadFunc, this ) )
    
39.                         return false;
    
40.         }
    
41.         return true;
    
42. }
    
43. 
    
44. void Thread::join() const
    
45. {
    
46.         ::pthread_join(m_tid, NULL);
    
47. }

复制代码

///  俄罗斯方块头文件

1. #ifndef BERT_TETRIS_H
   
2. #define BERT_TETRIS_H
   
3. 
   
4. #include
   
5. #include
   
6. 
   
7. #include "Thread.h"
   
8. 
   
9. /**
   
10. * 一个用printf做的linux俄罗斯方块
    
11. */
    
12. 
    
13. class Tetris : public Thread
    
14. {
    
15. public:
    
16.         Tetris();
    
17.         ~Tetris();
    
18. private:
    
19.         enum BOARD_T
    
20.         {
    
21.                 TYPE_BLANK = 0, //空白
    
22.                 TYPE_BLOCK,        //阻挡
    
23.                 TYPE_BORDER,        //边界
    
24. 
    
25.                 TYPE_MAX = 3,
    
26.         };
    
27.         
    
28.         /**
    
29.          * 游戏背景,尺寸
    
30.          */
    
31.         static const int HEIGHT = 22;
    
32.         static const int WIDTH  = 14;
    
33.         BOARD_T board[HEIGHT][WIDTH] ;
    
34.         
    
35.         /**??是否用volatile
    
36.          * 当前活动方块的坐标
    
37.          */
    
38.         int curx, cury;
    
39.         
    
40.         /**
    
41.          * 当前活动方块的样式及翻转形状
    
42.          */
    
43.         int curstyle;
    
44.         int curpos;
    
45.         
    
46.         /**
    
47.          * 当前活动方块的颜色
    
48.          */
    
49.         int curcolor ;
    
50. 
    
51.         /**
    
52.          * 玩家当前得分和等级
    
53.          */
    
54.         unsigned int score;
    
55.         unsigned short level;
    
56.         static const unsigned short MAXLEVEL = 9;
    
57. 
    
58.         /**
    
59.          * 一个方块的定义
    
60.          */
    
61.         typedef std::bitset<16> Block;
    
62.         
    
63.         /**
    
64.          * 方块的样式种类
    
65.          */
    
66.         static const unsigned short STYLE_MAX = 7;
    
67.         
    
68.         /**
    
69.          * 当前活动方块与下一个方块
    
70.          */
    
71.         Block activeBlock, nextBlock;
    
72. 
    
73.         /**
    
74.          * 现在是否有活动方块?
    
75.          */
    
76.         bool active;
    
77. 
    
78.         /**
    
79.          * 方块样式预定义
    
80.          */
    
81.         static const unsigned short _styles_[STYLE_MAX][4] ;
    
82.         Block styles[STYLE_MAX][4];
    
83. 
    
84.         /**
    
85.          *  初始化方块样式
    
86.          */
    
87.         void initStyles();
    
88.         
    
89.         /**
    
90.          *  显示分数
    
91.          */
    
92.         void drawScore();
    
93.         
    
94.         /**
    
95.          *  显示等级
    
96.          */
    
97.         void drawLevel();
    
98. 
    
99.         /**
    
100.          *  显示下一个方块
     
101.          */
     
102.         void drawNext();
     
103. 
     
104.         /**
     
105.          * 异步IO,使得单线程能完成显示和响应键盘的功能
     
106.          */
     
107.         struct aiocb cb;
     
108.         static const int SIZE = 16;
     
109.         unsigned char inputBuf[SIZE];
     
110.         friend void handler(int sig, siginfo_t *info, void * context);
     
111. 
     
112.         /**
     
113.          * 初始化背景数据
     
114.          */
     
115.         void initBackground();
     
116. 
     
117.         /**
     
118.          * 绘制游戏画面
     
119.          */
     
120.         void paint(int srcx = 0, int dstx = HEIGHT);
     
121. 
     
122.         /**
     
123.          * 判断方块是否与阻挡或边界冲突
     
124.          */
     
125.         bool isCollide();
     
126. 
     
127.         /**
     
128.          * 消行，并返回削去的行数(0-4)
     
129.          */
     
130.         int removeLines();
     
131. 
     
132.         /**
     
133.          * 判断line行是否为空
     
134.          */
     
135.         bool isEmptyLine(int line);
     
136. 
     
137.         /**
     
138.          * 根据消行，返回应得分数
     
139.          */
     
140.         static const unsigned short bonus[5];
     
141. 
     
142.         /**
     
143.          * 达到相应等级所需要的分数;10-levels
     
144.          */
     
145.         static const unsigned int levels[10];
     
146. 
     
147.         /**
     
148.          *  根据得分，计算等级
     
149.          */
     
150.         static unsigned short getLevel(unsigned int score);
     
151. 
     
152.         /**
     
153.          * 线程函数，游戏逻辑
     
154.          */
     
155.         virtual void run();
     
156. };
     
157. 
     
158. #endif

复制代码

//////////// 俄罗斯方块 实现

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. #include
   
9. 
   
10. #include "Tetris.h"
    
11. 
    
12. // 清除屏幕
    
13. #define CLEAR()  printf("\033[2J")
    
14. 
    
15. // 上移光标
    
16. #define MOVEUP(x) printf("\033[%dA", (x))
    
17. // 下移光标
    
18. #define MOVEDOWN(x) printf("\033[%dB", (x))
    
19. // 左移光标
    
20. #define MOVELEFT(y) printf("\033[%dD", (y))
    
21. // 右移光标
    
22. #define MOVERIGHT(y) printf("\033[%dC",(y))
    
23. 
    
24. // 定位光标
    
25. #define MOVETO(x,y) printf("\033[%d;%dH", (x), (y))
    
26. // 光标复位
    
27. #define RESET_CURSOR() printf("\033[H")
    
28. 
    
29. // 隐藏光标
    
30. #define        HIDE_CURSOR() printf("\033[?25l")
    
31. // 显示光标
    
32. #define        SHOW_CURSOR() printf("\033[?25h")
    
33. 
    
34. // 画背景
    
35. #define DRAW_BLANK()  printf("\033[1;31;40m%s\033[0m",". " )
    
36. // 画阻挡
    
37. #define DRAW_BLOCK() printf("\033[7m\033[1;37;40m%s\033[0m", "[]" )
    
38. // 画活动方块
    
39. #define DRAW_ACTIVE_BLOCK() printf("\033[7m\033[1;%d;40m%s\033[0m",curcolor, "[]" )
    
40. // 画边界
    
41. #define DRAW_BORDER()  printf("\033[1;33;43m%s\033[0m", "||" )
    
42. // 随机获得一种颜色
    
43. #define GET_COLOR() (rand()%6 + 31)
    
44. 
    
45. const int Tetris::HEIGHT;
    
46. const int Tetris::WIDTH;
    
47. const int Tetris::SIZE;
    
48. const unsigned short Tetris::STYLE_MAX;
    
49. const unsigned short Tetris::MAXLEVEL;
    
50. const unsigned short Tetris::bonus[5] = {0, 100, 300, 600, 1000};
    
51. const unsigned int Tetris::levels[MAXLEVEL+1] = {0, 10000, 30000, 60000, 100000, 150000, 210000, 280000, 360000, 450000};
    
52. 
    
53. const unsigned short Tetris::_styles_[STYLE_MAX][4] = {
    
54.                 {0x000f, 0x4444, 0x000f, 0x4444},
    
55.                 {0x004e, 0x0464, 0x00e4, 0x04c4},
    
56.                 {0x0462, 0x006c, 0x0462, 0x006c},
    
57.                 {0x0264, 0x00c6, 0x0264, 0x00c6},
    
58.                 {0x0622, 0x0017, 0x0223, 0x0074},
    
59.                 {0x0644, 0x00e2, 0x044c, 0x008e},
    
60.                 {0x0066, 0x0066, 0x0066, 0x0066},
    
61. };
    
62. 
    
63. unsigned short Tetris::getLevel(unsigned int score )
    
64. {
    
65.         int low = 0, high = MAXLEVEL;
    
66.         int mid;
    
67. 
    
68.         while ( true )
    
69.         {
    
70.                 mid = (low + high ) / 2;
    
71. 
    
72.                 if ( score >= levels[mid])
    
73.                                 {
    
74.                                         if ( mid==MAXLEVEL || score < levels[mid+1])
    
75.                                                 return mid;
    
76.                                         else
    
77.                                                 low = mid + 1;
    
78.                                 }
    
79.                                 else//不可能是mid等级 
    
80.                                 {
    
81.                                         assert(mid>0);
    
82.                                         high = mid - 1;
    
83.                                 }
    
84.         }
    
85. }
    
86. 
    
87. Tetris::Tetris() : score(0), level(0), active(false)
    
88. {
    
89.         bzero(&cb, sizeof(cb));
    
90.         initStyles();
    
91.         initBackground();
    
92.         HIDE_CURSOR();
    
93. }
    
94. 
    
95. Tetris::~Tetris()
    
96. {
    
97.         SHOW_CURSOR();
    
98. }
    
99. 
    
100. void Tetris::initStyles()
     
101. {
     
102.         for ( int i=0; i
103.         {
     
104.                 for ( int j=0; j<4; ++j)
     
105.                 {
     
106.                         styles[i][j] = _styles_[i][j];
     
107.                 }
     
108.         }
     
109. }
     
110. 
     
111. void Tetris::initBackground()
     
112. {
     
113.         for ( int i=0; i
114.                 for( int j=0; j
115.                 {
     
116.                         if ( i==0 || j==0 || i==HEIGHT-1 || j==WIDTH-1)
     
117.                                 board[i][j] = TYPE_BORDER;
     
118.                         else
     
119.                                 board[i][j] = TYPE_BLANK;
     
120.                 }
     
121. }
     
122. 
     
123. void Tetris::paint(int srcx, int dstx)
     
124. {
     
125.         if ( dstx > HEIGHT )
     
126.                 dstx = HEIGHT-1;
     
127. 
     
128.         for ( int i=srcx; i
129.         {
     
130.                 for ( int j=0; j
131.                 {
     
132.                         if ( board[i][j] == TYPE_BORDER )
     
133.                         {
     
134.                                 DRAW_BORDER();
     
135.                                 continue;
     
136.                         }
     
137.                         
     
138.                         if ( i>=curx && i=cury && j
139.                         {
     
140.                                 if ( board[i][j] == TYPE_BLANK && activeBlock[(i-curx)*4 + j-cury] == TYPE_BLANK )
     
141.                                         DRAW_BLANK();
     
142.                                 else
     
143.                                         DRAW_ACTIVE_BLOCK();
     
144.                         }
     
145.                         else
     
146.                         {
     
147.                                 if ( board[i][j] == TYPE_BLOCK )
     
148.                                         DRAW_BLOCK();
     
149.                                 else
     
150.                                         DRAW_BLANK();
     
151.                         }
     
152.                 }
     
153.                 printf("\n");
     
154.         }
     
155. }
     
156. 
     
157. void Tetris::drawScore()
     
158. {
     
159.         MOVETO(2, 2*WIDTH+2);
     
160. 
     
161.         printf("\033[7m\033[1;33;46m");
     
162.         printf("    SCORE: ");
     
163.         printf("\033[1;37;40m %-8u", score);
     
164.         printf("\033[0m");
     
165. }
     
166. 
     
167. void Tetris::drawLevel()
     
168. {
     
169.         MOVETO(6, 2*WIDTH+2);
     
170. 
     
171.         printf("\033[7m\033[1;34;43m");
     
172.         printf("    LEVEL: ");
     
173.         printf("\033[1;31;42m %-8u", level+1);//不显等级0
     
174.         printf("\033[0m");
     
175. }
     
176. 
     
177. void Tetris::drawNext()
     
178. {
     
179.         MOVETO(11, 2*WIDTH+2);
     
180.         printf("\033[1;34;43m\tNEXT:\033[0m");
     
181.         MOVELEFT(5);
     
182.         MOVEDOWN(2);
     
183. 
     
184.         for ( int i=0; i<16; ++i)
     
185.         {
     
186.                 if ( nextBlock[i] )
     
187.                         DRAW_BLOCK();
     
188.                 else
     
189.                         //printf("  ");
     
190.                         DRAW_BLANK();
     
191. 
     
192.                 if ( (i+1)%4 == 0 )
     
193.                 {
     
194.                         MOVELEFT(8);
     
195.                         MOVEDOWN(1);
     
196.                 }
     
197.         }
     
198. }
     
199. 
     
200. bool Tetris::isCollide()
     
201. {
     
202.         for ( int i=curx; i
203.                 for ( int j=cury; j
204.                         if ( board[i][j] && activeBlock[(i-curx) * 4 + j-cury]) 
     
205.                                 return true;
     
206. 
     
207.         return false;
     
208. }
     
209. 
     
210. bool Tetris::isEmptyLine(int line)
     
211. {
     
212.         for ( int j=1; j
213.                 if ( board[line][j] != TYPE_BLANK )
     
214.                         return false;
     
215.         return true;
     
216. }
     
217. 
     
218. int Tetris::removeLines()
     
219. {
     
220.         int nLines = 0 ;
     
221.         bool full;
     
222.         
     
223.         for ( int i=HEIGHT-2; i>0; --i)
     
224.         {
     
225.                 full = true;
     
226.                 for ( int j=1; j
227.                         if ( board[i][j] == TYPE_BLANK )
     
228.                         {
     
229.                                 full = false;
     
230.                                 break;
     
231.                         }
     
232. 
     
233.                 if ( full )
     
234.                 {
     
235.                         ++nLines;
     
236.                         int k, m;
     
237.                         for ( k=i-1; k>0 && !isEmptyLine(k); --k)
     
238.                                 for ( m=1; m
239.                                         board[k+1][m] = board[k][m];
     
240.                         // 消行了，k行一定为空
     
241.                         assert ( k>=0 && isEmptyLine(k) );
     
242.                         for ( m=1; m
243.                                 board[k+1][m] = TYPE_BLANK;
     
244. 
     
245.                         ++i;
     
246.                 }
     
247.         }
     
248. 
     
249.         return nLines;
     
250. }
     
251. 
     
252. void handler(int sig, siginfo_t *info, void * context)
     
253. {
     
254.         Tetris * game = (Tetris *)info->si_value.sival_ptr;
     
255.         struct aiocb *pcb = &(game->cb);
     
256. 
     
257.         assert( !aio_error(pcb) && "aio_handler error" );
     
258. 
     
259.         int nbytes = aio_return(pcb);
     
260.         if ( nbytes == 0  )
     
261.                 return;
     
262. 
     
263.         int nread = -1;
     
264.         if ( !game->active)
     
265.                 goto end;
     
266. 
     
267.         while ( ++nread < nbytes  )
     
268.         {
     
269.                 switch(game->inputBuf[nread])
     
270.                 {
     
271.                         case 'a':
     
272.                         case 'A':
     
273.                                 --game->cury;
     
274.                                 if ( game->isCollide() )
     
275.                                         ++game->cury;
     
276.                                 else
     
277.                                 {
     
278.                                         MOVETO(game->curx+1, 0);
     
279.                                         game->paint(game->curx, game->curx+4);
     
280.                                 }
     
281.                                 break;
     
282.                         case 's':
     
283.                         case 'S':
     
284.                                 ++game->curx;
     
285.                                 if ( game->isCollide( ) )
     
286.                                         --game->curx;
     
287.                                 else
     
288.                                 {
     
289.                                         MOVETO(game->curx, 0 );
     
290.                                         game->paint(game->curx-1, game->curx+4 );
     
291.                                 }
     
292.                                 break;
     
293.                         case 'd':
     
294.                         case 'D':
     
295.                                 ++game->cury;
     
296.                                 if ( game->isCollide( ) )
     
297.                                         --game->cury;
     
298.                                 else
     
299.                                 {
     
300.                                         MOVETO(game->curx+1, 0);
     
301.                                         game->paint(game->curx, game->curx+4);
     
302.                                 }
     
303.                                 break;
     
304.                         case 'w':
     
305.                         case 'W':
     
306.                                 {
     
307.                                         Tetris::Block saveblock = game->activeBlock;
     
308.                                         int savedpos = game->curpos;
     
309. 
     
310.                                         game->curpos = (game->curpos + 1) % 4;
     
311.                                         game->activeBlock = game->styles[game->curstyle][game->curpos];
     
312.                                         if ( game->isCollide( ) )
     
313.                                         {
     
314.                                                 game->curpos = savedpos;
     
315.                                                 game->activeBlock = saveblock;
     
316.                                         }
     
317.                                         else
     
318.                                         {
     
319.                                                 MOVETO(game->curx+1, 0);
     
320.                                                 game->paint(game->curx, game->curx+4);
     
321.                                         }
     
322.                                 }
     
323.                                 break;
     
324.                         case ' ':
     
325.                                 {
     
326.                                         int oldx = game->curx;
     
327.                                         // 提高效率，一次移两行
     
328.                                         while ( !game->isCollide() )
     
329.                                                 game->curx += 2;
     
330.                                         
     
331.                                         if ( game->isCollide() )
     
332.                                         {
     
333.                                                 --game->curx;
     
334.                                                 if ( game->isCollide() )
     
335.                                                         --game->curx;
     
336.                                         }
     
337.                                         
     
338.                                         if ( oldx == game->curx )
     
339.                                                 break;
     
340.                                                 
     
341.                                         if ( game->curx - oldx < 4)
     
342.                                         {
     
343.                                                 MOVETO(oldx+1, 0);
     
344.                                                 game->paint(oldx, game->curx+4);
     
345.                                         }
     
346.                                         else
     
347.                                         {
     
348.                                                 MOVETO(oldx+1, 0);
     
349.                                                 game->paint(oldx, oldx+4);
     
350.                                                 MOVETO(game->curx+1, 0);
     
351.                                                 game->paint(game->curx, game->curx+4);
     
352.                                         }
     
353. 
     
354.                                         goto end;
     
355.                                 }
     
356.                                 break;
     
357.                         default:
     
358.                                 break;
     
359.                 }
     
360.         }
     
361. 
     
362. end:
     
363.         int ret = aio_read(pcb);
     
364.         assert ( ret==0 && "aio_read error!!!");
     
365. 
     
366.         return;
     
367. }
     
368. 
     
369. void Tetris::run()
     
370. {
     
371.         struct sigaction st;
     
372.         sigemptyset(&st.sa_mask);
     
373.         st.sa_flags = SA_SIGINFO;
     
374.         st.sa_handler = reinterpret_cast(handler);
     
375.         sigaction(SIGRTMAX, &st, NULL);
     
376. 
     
377.         cb.aio_fildes = STDIN_FILENO;
     
378.         cb.aio_offset = 0;
     
379.         cb.aio_buf = inputBuf;
     
380.         cb.aio_nbytes = 16;
     
381.         cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
     
382.         cb.aio_sigevent.sigev_signo = SIGRTMAX;
     
383.         cb.aio_sigevent.sigev_value.sival_ptr = (void *)this;
     
384. 
     
385.         sleep(1);
     
386.         
     
387.         int ret = aio_read(&cb);
     
388.         assert ( ret==0 && "aio_read error!!!");
     
389. 
     
390.         CLEAR();
     
391.         RESET_CURSOR();
     
392.         paint();
     
393.         drawScore();
     
394.         drawLevel();
     
395. 
     
396.         /*预先产生一个方块*/
     
397.         int next = rand()%7;
     
398.         nextBlock = styles[next][0];
     
399. 
     
400.         
     
401.         while ( true )
     
402.         {
     
403.                 if ( !active ) 
     
404.                 {
     
405.                         activeBlock = nextBlock;
     
406.                         curstyle = next;
     
407.                         curcolor = GET_COLOR();
     
408.                         active = true;
     
409.                         curpos = 0;
     
410. 
     
411.                         next = rand()%7;
     
412.                         nextBlock = styles[next][0];
     
413.                         //画下一个方块
     
414.                         drawNext();
     
415.                         curx = 1;
     
416.                         cury = WIDTH/2 - 2;
     
417.                         if ( isCollide( ) )
     
418.                         {
     
419.                                 return; //GAME OVER
     
420.                         }
     
421.                         MOVETO(curx+1, 0);
     
422.                         paint(curx, curx+4);
     
423.                 }
     
424.                 else
     
425.                 {
     
426.                         ++curx;
     
427.                         if ( !isCollide() )
     
428.                         {
     
429.                                 MOVETO(curx, 0);
     
430.                                 paint(curx-1, curx+4 );
     
431.                         }
     
432.                         else
     
433.                         {
     
434.                                 --curx;
     
435.                                 for ( int i=curx; i
436.                                         for( int j=cury; j
437.                                         {
     
438.                                                 if ( activeBlock[(i-curx)*4 + j-cury] )
     
439.                                                         board[i][j] = TYPE_BLOCK;
     
440.                                         }
     
441.                                 active = false;
     
442.                                 activeBlock = 0;
     
443.                                 //判断是否得分
     
444.                                 int n = removeLines();
     
445.                                 if ( n != 0 )
     
446.                                 {
     
447.                                         score += bonus[n];
     
448.                                         drawScore();
     
449. 
     
450.                                         int newlevel = getLevel(score);
     
451.                                         if ( newlevel > this->level)
     
452.                                         {
     
453.                                                 this->level = newlevel;
     
454.                                                 drawLevel();
     
455.                                         }
     
456.                                         //RESET_CURSOR(); //暂时全部重画，以后优化
     
457.                                         //paint();
     
458.                                         MOVETO(2,0);
     
459.                                         paint(1, curx+4);
     
460.                                 }
     
461.                                 else
     
462.                                 {
     
463.                                         MOVETO(curx+1, 0);
     
464.                                         paint(curx, curx+4 );
     
465.                                 }
     
466.                         }
     
467.                 }
     
468.                 msleep(700 - level * 60);
     
469.         }
     
470.         return ;
     
471. }

复制代码

///////////////   模板单例模式

1. #ifndef BERT_SINGLETON_H
   
2. #define BERT_SINGLETON_H
   
3. 
   
4. /**
   
5. * 模板单例模式
   
6. */
   
7. template
   
8. class Singleton
   
9. {
   
10. protected:
    
11.         Singleton() {}
    
12.         ~Singleton() {}
    
13.         
    
14.         static T * instance;
    
15.         
    
16. public:
    
17.         static T * getInstance()
    
18.         {
    
19.                 if ( instance == NULL )
    
20.                         instance = new T();
    
21.                 return instance;
    
22.         }
    
23. 
    
24.         static void delInstance()
    
25.         {
    
26.                 if ( instance )
    
27.                 {
    
28.                         delete instance;
    
29.                         instance = NULL;
    
30.                 }
    
31.         }
    
32. };
    
33. 
    
34. template
    
35. T * Singleton::instance = NULL;
    
36. 
    
37. #endif

复制代码

/////////   自动设置终端属性

1. #ifndef BERT_TTYAUTO_H
   
2. #define BERT_TTYAUTO_H
   
3. 
   
4. #include
   
5. #include
   
6. #include
   
7. #include "Singleton.h"
   
8. 
   
9. /**
   
10. * 前向声明
    
11. */
    
12. namespace std
    
13. {
    
14. 
    
15. template
    
16. class auto_ptr;
    
17. 
    
18. }
    
19. 
    
20. class TtyAuto : public Singleton
    
21. {
    
22.         friend class Singleton;
    
23.         friend class std::auto_ptr;
    
24. 
    
25.         struct termios state;
    
26. protected:
    
27.         /**
    
28.          *  构造函数,自动设置非缓冲，非回显模式
    
29.          */
    
30.         TtyAuto()
    
31.         {
    
32.                 tcgetattr(STDIN_FILENO, &state);
    
33.                 state.c_lflag &= ~ICANON;
    
34.                 state.c_lflag &= ~ECHO;
    
35.                 tcsetattr(STDIN_FILENO, TCSANOW, &state);
    
36.         }
    
37.         /**
    
38.          *  析构函数,自动恢复缓冲，回显模式
    
39.          */
    
40.         ~TtyAuto()
    
41.         {
    
42.                 state.c_lflag |= ICANON;
    
43.                 state.c_lflag |= ECHO;
    
44.                 tcsetattr(STDIN_FILENO, TCSANOW, &state);
    
45.         }
    
46. };
    
47. 
    
48. #endif

复制代码