devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c/c++ 实现俄罗斯方块小游戏（附全部源码）_c++代码小游戏

作者：我家自动化 | 2024-05-21 20:27:46

赞

踩

c++代码小游戏

目录

前言

使用easyX库，基于c/c++，实现俄罗斯方块小游戏。

作者使用的是VS2010版本，VS2019版本也可用。

一、游戏截图和全部代码

  • 1.游戏截图

  • 2.源代码

可直接拷贝，并运行俄罗斯方块小游戏

  • 头文件代码

  1. #pragma once
  2.  
  3. #define		GAMEMAP1		200		// 预生成方块区域
  4. #define		GAMEMAP2		10
  5. #define		GAMEMAP3		500
  6. #define		GAMEMAP4		610
  7. #define		GAMEMAP5		40		// 游戏地图区域
  8. #define		GAMEMAP6		50
  9. #define		GAMEMAP7		140
  10. #define		GAMEMAP8		130
  11. #define		GAMEGUIDE1		40		// 按键说明
  12. #define		GAMEGUIDE2		300
  13. #define		GAMEGUIDE3		150
  14. #define		GAMEGUIDE4		440
  15. #define		GAMELEVEL1		30		// 游戏等级区域
  16. #define		GAMELEVEL2		160
  17. #define		GAMERANK1		30		// 游戏rank分数
  18. #define		GAMERANK2		190
  19.  
  20. #define		TETRISWIDTH		15		// 游戏地图宽
  21. #define		TETRISHEIGHT	30		// 游戏地图高
  22. #define		BLOCKTYPE		8		// 方块种类数
  23. #define		BLOCKSTYLE		4		// 每种方块的样式数
  24. #define		BLOCKSPACE		20		// 方块占用空间 5 x 4
  25. #define		SIDELENGTH		20		// 方块边长 20 像素
  26.  
  27. #define		ESC				27
  28.  
  29. #define		CLEARKEY();		{ while(_kbhit()) { _getch(); } }	// 清除按键输入缓存
  30.  
  31. enum BLOCKCOLER 
  32. {
  33. 	BLOCKNONE,
  34. 	BLOCKBLUE,
  35. 	BLOCKGREEN,
  36. 	BLOCKCYAN,
  37. 	BLOCKRED,
  38. 	BLOCKMAGENTA,
  39. 	BLOCKBROWN,
  40. 	BLOCKYELLOW,
  41. };
  42.  
  43. typedef struct _GAME_TETRIS
  44. {
  45. 	int		ttime;			// 计时
  46. 	int		ctime;			// 计时
  47. 	int		level;			// 当前游戏等级
  48. 	int		rank;			// 当前游戏分数
  49. 	int		key;			// 玩家按键值
  50. 	int		blockType;		// 当前方块类型
  51. 	int		blockStyle;		// 当前方块朝向
  52.  
  53. 	bool	moveFlag;		// 移动标识，标识为1时，移动当前方块
  54. 	bool	newBlockFlag;	// 载入新方块标识，当标识为真时，将预生成的随机方块载入地图
  55. 	bool	gameOverFlag;	// 游戏结束标识
  56. }GAME_TETRIS;
  57.  
  58. typedef struct _GAME_PREBLOCK
  59. {
  60. 	int tetrisPreBlock[BLOCKSPACE];		// 预生成的方块数组
  61. 	int blockType,blockStyle;			// 预生成方块的类型和朝向
  62. }GAME_PREBLOCK;
  63.  
  64. typedef struct _GAME_MOVE_BLOCK
  65. {
  66. 	int blockSite[4][2];	// 4个方块格坐标
  67. 	int blockColor;			// 方块颜色
  68. }GAME_MOVE_BLOCK;
  69.  
  70.  
  71. void tetrisrun(void);
  72. void tetrisInit(void);
  73. void tetrisDraw(void);
  74. void tetrisNewBlock(void);
  75. void tetrisMoveUp(void);
  76. void tetrisMoveDown(void);
  77. void tetrisMoveLeft(void);
  78. void tetrisMoveRight(void);
  79. void tetrisLoadBlock(void);
  80. void tetrisIsOver(void);
  81. void tetrisQuit(void);
  82. void tetrisKeyHandle(void);
  83. void tetrisReset(void);
  84. void tetrisRemove(void);

  • cpp文件代码

  1. #include "stdafx.h"
  2. #include "tetrisnew.h"
  3. #include<graphics.h>
  4. #include<conio.h>	
  5. #include<stdio.h>
  6. #include<time.h>
  7.  
  8. // 所有方块数组库
  9. const int block[BLOCKTYPE][BLOCKSTYLE][BLOCKSPACE] = 
  10. {
  11. 	// 总共有8种方块，每种方块有4种样式
  12.  
  13. 	// 'I'形方块
  14. 	{
  15. 		{
  16. 			BLOCKNONE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,
  17. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  18. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  19. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  20. 		},
  21. 		{
  22. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  23. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  24. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  25. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE
  26. 		},
  27. 		{
  28. 			BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKNONE,
  29. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  30. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  31. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  32. 		},
  33. 		{
  34. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  35. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  36. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  37. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE
  38. 		}
  39. 	},
  40. 	// 'Z'形方块
  41. 	{
  42. 		{
  43. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  44. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,
  45. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  46. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  47. 		},
  48. 		{
  49. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  50. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  51. 			BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  52. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  53. 		},
  54. 		{
  55. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  56. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,
  57. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  58. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  59. 		},
  60. 		{
  61. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  62. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  63. 			BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  64. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  65. 		}
  66. 	},
  67. 	// 反'Z'形方块
  68. 	{
  69. 		{
  70. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  71. 			BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  72. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  73. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  74. 		},
  75. 		{
  76. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  77. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  78. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,
  79. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  80. 		},
  81. 		{
  82. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  83. 			BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  84. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  85. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  86. 		},
  87. 		{
  88. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  89. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  90. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,
  91. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  92. 		}
  93. 	},
  94. 	// 'T'形方块
  95. 	{
  96. 		{
  97. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  98. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  99. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  100. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  101. 		},
  102. 		{
  103. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  104. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  105. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  106. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  107. 		},
  108. 		{
  109. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  110. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  111. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  112. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  113. 		},
  114. 		{
  115. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  116. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  117. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  118. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  119. 		}
  120. 	},
  121. 	// 'T'形方块 X 2 增加T形方块出现概率
  122. 	{
  123. 		{
  124. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  125. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  126. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  127. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  128. 		},
  129. 		{
  130. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  131. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  132. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  133. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  134. 		},
  135. 		{
  136. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  137. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  138. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  139. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  140. 		},
  141. 		{
  142. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  143. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  144. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  145. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  146. 		}
  147. 	},
  148. 	// '田'形方块
  149. 	{
  150. 		{
  151. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  152. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  153. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  154. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  155. 		},
  156. 		{
  157. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  158. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  159. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  160. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  161. 		},
  162. 		{
  163. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  164. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  165. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  166. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  167. 		},
  168. 		{
  169. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  170. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  171. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  172. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  173. 		}
  174. 	},
  175. 	// 'L'形方块
  176. 	{
  177. 		{
  178. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  179. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  180. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKBROWN,	BLOCKNONE,
  181. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  182. 		},
  183. 		{
  184. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKBROWN,	BLOCKBROWN,
  185. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  186. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  187. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  188. 		},
  189. 		{
  190. 			BLOCKNONE,	BLOCKBROWN,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  191. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  192. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  193. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  194. 		},
  195. 		{
  196. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  197. 			BLOCKBROWN,	BLOCKBROWN,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  198. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  199. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  200. 		}
  201. 	},
  202. 	// 反'L'形方块
  203. 	{
  204. 		{
  205. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  206. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  207. 			BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  208. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  209. 		},
  210. 		{
  211. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  212. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKYELLOW,
  213. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  214. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  215. 		},
  216. 		{
  217. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKNONE,
  218. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  219. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  220. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  221. 		},
  222. 		{
  223. 			BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKYELLOW,BLOCKNONE,
  224. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,
  225. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  226. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  227. 		}
  228. 	}
  229.  
  230. };
  231.  
  232. // 游戏实时画面
  233. int tetrisMap[TETRISHEIGHT][TETRISWIDTH] = 
  234. {	
  235.  
  236. };
  237.  
  238. GAME_TETRIS		player;		// 玩家数据
  239. GAME_PREBLOCK	preBlock;	// 预生成方块数据
  240. GAME_MOVE_BLOCK moveBlock;	// 当前控制方块数据
  241.  
  242. int main(void)
  243. {
  244. 	tetrisrun();
  245. 	return 0;
  246. }
  247.  
  248. void tetrisrun(void)
  249. {
  250. 	tetrisInit();
  251. 	while(1)
  252. 	{
  253. 		player.ctime = GetTickCount();
  254. 		if( (player.ctime - 500 + 30*player.level) > player.ttime )
  255. 		{	
  256. 			player.moveFlag = TRUE;
  257. 			player.ttime = GetTickCount();
  258. 		}
  259. 		if(player.moveFlag)
  260. 		{
  261. 			player.moveFlag = FALSE;
  262.  
  263. 			tetrisMoveDown();
  264. 			tetrisDraw();
  265. 		}
  266. 		if(_kbhit())
  267. 		{	
  268. 			player.key = _getch();
  269. 			tetrisKeyHandle();
  270. 		}
  271. 		if(player.newBlockFlag)
  272. 		{
  273. 			player.newBlockFlag = FALSE;
  274. 			tetrisLoadBlock();
  275. 			tetrisRemove();
  276. 			tetrisNewBlock();
  277. 			tetrisIsOver();
  278. 		}
  279. 		if(player.gameOverFlag)
  280. 		{
  281. 			player.gameOverFlag = FALSE;
  282. 			break;
  283. 		}
  284.  
  285. 	}
  286.  
  287. }
  288.  
  289. void tetrisInit(void)
  290. {
  291. 	int i,j,k;
  292. 	HWND window = initgraph(510, 620);	
  293. 	SetWindowText(window, "俄罗斯方块 - by耒阳阿杰");	
  294. 	//SetWindowPos(window,HWND_TOPMOST,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE);	
  295.  
  296. 	rectangle(GAMEMAP1 - 2,GAMEMAP2 - 2,GAMEMAP3 + 2,GAMEMAP4 + 2);		
  297. 	rectangle(GAMEMAP5 - 2,GAMEMAP6 - 2,GAMEMAP7 + 2,GAMEMAP8 + 2);		
  298. 	rectangle(GAMEGUIDE1 - 5,GAMEGUIDE2 - 5,GAMEGUIDE3 + 5,GAMEGUIDE4 + 5);	
  299.  
  300. 	outtextxy(GAMEMAP5 + 10 ,GAMEMAP6 - 26,"下个方块");
  301. 	settextcolor(GREEN);
  302. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2		,"W   ：改变形状");
  303. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 25	,"A    ：方块左移");
  304. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 50	,"S    ：方块右移");
  305. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 75	,"D    ：方块下移");
  306. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 100	,"R    ：重新开始");
  307. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 125	,"ESC：退出游戏");
  308.  
  309. 	memset ( &player, 0, sizeof ( GAME_TETRIS ) );
  310. 	memset ( &preBlock, 0, sizeof ( GAME_PREBLOCK ) );
  311. 	memset(tetrisMap,0,sizeof(tetrisMap));
  312. 	player.ttime = GetTickCount();
  313.  
  314. 	srand((unsigned)time(NULL));		
  315. 	i = (rand() + 1) % BLOCKTYPE;
  316. 	j = rand() % BLOCKSTYLE;
  317. 	for(k = 0; k < BLOCKSPACE;k++)
  318. 	{
  319. 		preBlock.tetrisPreBlock[k] = block[i][j][k];
  320. 	}
  321. 	preBlock.blockType = i;
  322. 	preBlock.blockStyle = j;
  323. 	tetrisNewBlock();	
  324. }
  325.  
  326. void tetrisDraw(void)
  327. {
  328. 	int i,j;
  329. 	int x,y;
  330. 	char ch[20];
  331. 	
  332. 	settextstyle(20,12,"宋体");	
  333. 	settextcolor(CYAN);			
  334. 	if(player.level < 10)
  335. 	{
  336. 		sprintf_s(ch, "%s%d","LEVEL：", player.level);
  337. 	}
  338. 	else
  339. 	{	
  340. 		sprintf_s(ch, "%s","LEVEL：MAX");
  341. 	}
  342. 	outtextxy(GAMELEVEL1,GAMELEVEL2,ch);
  343. 	settextcolor(LIGHTBLUE);
  344. 	sprintf_s(ch, "%s%d","RANK：", player.rank);
  345. 	outtextxy(GAMERANK1,GAMERANK2,ch);
  346.  
  347. 	setfillcolor(BLACK);
  348. 	solidrectangle(GAMEMAP5,GAMEMAP6,GAMEMAP7,GAMEMAP8);
  349.  
  350. 	for(i = 0; i < BLOCKSPACE; i++)
  351. 	{
  352. 		switch(preBlock.tetrisPreBlock[i])
  353. 		{
  354. 			case BLOCKNONE:				
  355. 				continue;
  356. 				break;
  357. 			case BLOCKBLUE:				
  358. 				setfillcolor(BLUE);
  359. 				break;
  360. 			case BLOCKGREEN:			
  361. 				setfillcolor(GREEN);
  362. 				break;
  363. 			case BLOCKCYAN:				
  364. 				setfillcolor(CYAN);
  365. 				break;
  366. 			case BLOCKRED:				
  367. 				setfillcolor(RED);
  368. 				break;
  369. 			case BLOCKMAGENTA:			
  370. 				setfillcolor(MAGENTA);
  371. 				break;
  372. 			case BLOCKBROWN:			
  373. 				setfillcolor(BROWN);
  374. 				break;
  375. 			case BLOCKYELLOW:
  376. 				setfillcolor(YELLOW);
  377. 				break;
  378. 		}
  379. 		fillrectangle(GAMEMAP5 + (i%5) * SIDELENGTH ,GAMEMAP6 + (i/5) * SIDELENGTH ,GAMEMAP5 + ((i%5)+1)*SIDELENGTH ,GAMEMAP6 + ((i/5)+1) * SIDELENGTH );		
  380. 	}
  381.  
  382. 	setfillcolor(BLACK);
  383. 	solidrectangle(GAMEMAP1,GAMEMAP2,GAMEMAP3,GAMEMAP4);
  384.  
  385. 	for(i = 0; i < 4; i++)
  386. 	{
  387. 		x = moveBlock.blockSite[i][0];
  388. 		y = moveBlock.blockSite[i][1];
  389. 		switch(moveBlock.blockColor)
  390. 		{
  391. 			case BLOCKNONE:
  392. 				continue;
  393. 				break;
  394. 			case BLOCKBLUE:
  395. 				setfillcolor(BLUE);
  396. 				break;
  397. 			case BLOCKGREEN:
  398. 				setfillcolor(GREEN);
  399. 				break;
  400. 			case BLOCKCYAN:
  401. 				setfillcolor(CYAN);
  402. 				break;
  403. 			case BLOCKRED:
  404. 				setfillcolor(RED);
  405. 				break;
  406. 			case BLOCKMAGENTA:
  407. 				setfillcolor(MAGENTA);
  408. 				break;
  409. 			case BLOCKBROWN:
  410. 				setfillcolor(BROWN);
  411. 				break;
  412. 			case BLOCKYELLOW:
  413. 				setfillcolor(YELLOW);
  414. 				break;
  415. 		}
  416. 		fillrectangle(GAMEMAP1 + y * SIDELENGTH ,GAMEMAP2 + x * SIDELENGTH ,GAMEMAP1 + (y+1)*SIDELENGTH ,GAMEMAP2 + (x+1) * SIDELENGTH );		
  417. 	}
  418.  
  419. 	for(i = 0; i < TETRISHEIGHT; i++)
  420. 	{
  421. 		for(j = 0; j < TETRISWIDTH; j++)
  422. 		{	
  423. 			switch(tetrisMap[i][j])
  424. 			{
  425. 				case BLOCKNONE:
  426. 					continue;
  427. 					break;
  428. 				case BLOCKBLUE:
  429. 					setfillcolor(BLUE);
  430. 					break;
  431. 				case BLOCKGREEN:
  432. 					setfillcolor(GREEN);
  433. 					break;
  434. 				case BLOCKCYAN:
  435. 					setfillcolor(CYAN);
  436. 					break;
  437. 				case BLOCKRED:
  438. 					setfillcolor(RED);
  439. 					break;
  440. 				case BLOCKMAGENTA:
  441. 					setfillcolor(MAGENTA);
  442. 					break;
  443. 				case BLOCKBROWN:
  444. 					setfillcolor(BROWN);
  445. 					break;
  446. 				case BLOCKYELLOW:
  447. 					setfillcolor(YELLOW);
  448. 					break;
  449. 			}
  450. 			fillrectangle(GAMEMAP1 + j * SIDELENGTH ,GAMEMAP2 + i * SIDELENGTH ,GAMEMAP1 + (j+1)*SIDELENGTH ,GAMEMAP2 + (i+1) * SIDELENGTH );		
  451. 		}
  452. 	}
  453. }
  454.  
  455. void tetrisNewBlock(void)
  456. {
  457. 	int i,j,k;
  458.  
  459. 	k = 0;
  460. 	for(i = 0; i < BLOCKSPACE; i++)
  461. 	{
  462. 		if(preBlock.tetrisPreBlock[i])
  463. 		{
  464. 			moveBlock.blockColor = preBlock.tetrisPreBlock[i];	
  465. 			moveBlock.blockSite[k][0] = i/5;					
  466. 			moveBlock.blockSite[k][1] = 5 + i%5;				
  467. 			k++;
  468. 		}
  469. 	}
  470. 	player.blockType = preBlock.blockType;		
  471. 	player.blockStyle = preBlock.blockStyle;	
  472.  
  473. 	srand((unsigned)time(NULL));		
  474. 	i = rand() % BLOCKTYPE;
  475. 	j = rand() % BLOCKSTYLE;
  476. 	for(k = 0; k < BLOCKSPACE;k++)
  477. 	{
  478. 		preBlock.tetrisPreBlock[k] = block[i][j][k];
  479. 	}
  480. 	preBlock.blockType = i;
  481. 	preBlock.blockStyle = j;
  482. }
  483.  
  484. void tetrisMoveUp(void)
  485. {
  486. 	int i,k;
  487. 	int bStyle;
  488. 	int ux,uy;					// 改变方块朝向前后，方块格的位移矢量
  489. 	int blocksite2[4][2];		// 记录改变朝向前，4个方块的方块库坐标
  490. 	int blocksite3[4][2];		// 记录改变朝向后，4个方块的方块库坐标
  491. 	int blocksite4[4][2];		// 记录改变朝向后，4个方块的游戏地图坐标
  492.  
  493. 	k = 0;
  494. 	for(i = 0; i < BLOCKSPACE; i++)
  495. 	{
  496. 		if(k > 3)
  497. 		{	
  498. 			break;
  499. 		}
  500. 		if(block[player.blockType][player.blockStyle][i])
  501. 		{
  502. 			blocksite2[k][0] = i / 5;
  503. 			blocksite2[k][1] = i % 5;
  504. 			k++;
  505. 		}
  506. 	}
  507. 	k = 0;
  508. 	bStyle = (player.blockStyle + 1)%BLOCKSTYLE;	
  509. 	for(i = 0; i < BLOCKSPACE; i++)
  510. 	{
  511. 		if(k > 3)
  512. 		{	
  513. 			break;
  514. 		}
  515. 		if(block[player.blockType][bStyle][i])
  516. 		{
  517. 			blocksite3[k][0] = i / 5;
  518. 			blocksite3[k][1] = i % 5;
  519. 			k++;
  520. 		}
  521. 	}
  522. 	for(i = 0; i < 4; i++)
  523. 	{
  524. 		ux = blocksite3[i][0] - blocksite2[i][0];	
  525. 		uy = blocksite3[i][1] - blocksite2[i][1];	
  526.  
  527. 		blocksite4[i][0] = moveBlock.blockSite[i][0] + ux;	
  528. 		blocksite4[i][1] = moveBlock.blockSite[i][1] + uy;	
  529. 		
  530. 		if( (blocksite4[i][0] < 0)					
  531. 			|| (blocksite4[i][1] < 0)
  532. 			|| (blocksite4[i][0] > TETRISHEIGHT - 1)
  533. 			|| (blocksite4[i][1] > TETRISWIDTH - 1)
  534. 			|| ( tetrisMap[blocksite4[i][0]][blocksite4[i][1]] ) )	
  535. 		{
  536. 			return;
  537. 		}
  538. 	}
  539. 	for(i = 0;i < 4; i++)
  540. 	{
  541. 		moveBlock.blockSite[i][0] = blocksite4[i][0];
  542. 		moveBlock.blockSite[i][1] = blocksite4[i][1];
  543. 	}
  544. 	player.blockStyle = bStyle;	
  545.  
  546. }
  547.  
  548. void tetrisMoveDown(void)
  549. {
  550. 	int i;
  551. 	int x,y;
  552.  
  553. 	for(i = 0; i < 4; i++)
  554. 	{
  555. 		if(moveBlock.blockSite[i][0] > TETRISHEIGHT - 2)
  556. 		{
  557. 			player.newBlockFlag = TRUE;
  558. 			return;
  559. 		}
  560. 	}
  561. 	for(i = 0; i < 4; i++)
  562. 	{
  563. 		x = moveBlock.blockSite[i][0] + 1;	
  564. 		y = moveBlock.blockSite[i][1];		
  565. 		if(tetrisMap[x][y])
  566. 		{
  567. 			player.newBlockFlag = TRUE;
  568. 			return;
  569. 		}
  570. 	}
  571. 	for(i = 0; i < 4; i++)
  572. 	{
  573. 		moveBlock.blockSite[i][0]++;
  574. 	}
  575.  
  576. }
  577.  
  578. void tetrisMoveLeft(void)
  579. {
  580. 	int i;
  581. 	int x,y;
  582.  
  583. 	for(i = 0; i < 4; i++)
  584. 	{
  585. 		x = moveBlock.blockSite[i][0];
  586. 		y = moveBlock.blockSite[i][1];
  587. 		if( (y - 1) < 0				
  588. 			|| tetrisMap[x][y - 1])	
  589. 		{
  590. 			return;	
  591. 		}
  592. 	}
  593. 	for(i = 0; i < 4; i++)
  594. 	{
  595. 		moveBlock.blockSite[i][1]--;
  596. 	}
  597.  
  598. }
  599.  
  600. void tetrisMoveRight(void)
  601. {
  602. 	int i;
  603. 	int x,y;
  604. 	//k = 0;
  605. 	for(i = 0; i < 4; i++)
  606. 	{
  607. 		x = moveBlock.blockSite[i][0];
  608. 		y = moveBlock.blockSite[i][1];
  609. 		if( ((y + 1) >= TETRISWIDTH)	
  610. 			|| (tetrisMap[x][y + 1]) )	
  611. 		{
  612. 			return;	
  613. 		}
  614. 	}
  615. 	for(i = 0; i < 4; i++)
  616. 	{
  617. 		moveBlock.blockSite[i][1]++;
  618. 	}
  619.  
  620. }
  621.  
  622. void tetrisLoadBlock(void)
  623. {
  624. 	int i;
  625. 	int x,y;
  626.  
  627. 	for(i = 0; i < 4; i++)
  628. 	{
  629. 		x = moveBlock.blockSite[i][0];
  630. 		y = moveBlock.blockSite[i][1];
  631. 		if(!tetrisMap[x][y])
  632. 		{
  633. 			tetrisMap[x][y] = moveBlock.blockColor;
  634. 		}
  635. 	}
  636. }
  637.  
  638. void tetrisIsOver(void)
  639. {
  640. 	int i;
  641. 	int x,y;
  642.  
  643. 	for(i = 0; i < 4; i++)
  644. 	{
  645. 		x = moveBlock.blockSite[i][0];
  646. 		y = moveBlock.blockSite[i][1];
  647. 		if(tetrisMap[x][y])
  648. 		{
  649. 			player.gameOverFlag = TRUE;
  650. 			tetrisDraw();
  651. 			tetrisQuit();
  652. 			return;
  653. 		}
  654. 	}
  655. }
  656.  
  657. void tetrisQuit(void)
  658. {
  659. 	int key,flag;
  660. 	flag = player.gameOverFlag;
  661. 	key = MessageBox(NULL,"是否退出游戏？","提示",MB_YESNO| MB_SYSTEMMODAL);
  662. 	switch(key)
  663. 	{
  664. 		case IDYES:
  665. 			player.gameOverFlag = TRUE;
  666. 			break;
  667. 		case IDNO:
  668. 			player.gameOverFlag = FALSE;
  669. 			break;
  670. 		default:
  671. 			break;
  672. 	}
  673. 	while(flag
  674. 		&& !player.gameOverFlag)
  675. 	{
  676. 		key = MessageBox(NULL,"检测到游戏已无法继续，\n请选择\"是\": 退出游戏；\n或者选择\"否\": 重启游戏；","提示",MB_YESNO| MB_SYSTEMMODAL);
  677. 		switch(key)
  678. 		{
  679. 			case IDYES:
  680. 				player.gameOverFlag = TRUE;
  681. 				break;
  682. 			case IDNO:
  683. 				tetrisInit();
  684. 				player.gameOverFlag = FALSE;
  685. 				return;
  686. 			default:
  687. 				break;
  688. 		}
  689. 	}
  690. 	CLEARKEY();	
  691. }
  692.  
  693. void tetrisKeyHandle(void)
  694. {
  695. 	switch(player.key)
  696. 	{
  697. 		case 'w':
  698. 		case 'W':
  699. 			tetrisMoveUp();	
  700. 			break;
  701. 		case 'a':
  702. 		case 'A':
  703. 			tetrisMoveLeft();
  704. 			break;
  705. 		case 's':
  706. 		case 'S':
  707. 			player.moveFlag = TRUE;
  708. 			player.ttime = GetTickCount();
  709. 			return;
  710. 		case 'd':
  711. 		case 'D':
  712. 			tetrisMoveRight();
  713. 			break;
  714. 		case ESC:
  715. 			tetrisQuit();
  716. 			break;
  717. 		case 'r':
  718. 		case 'R':
  719. 			tetrisReset();
  720. 			break;
  721. 		default:
  722. 			break;
  723. 	}
  724. 	tetrisDraw();
  725. }
  726.  
  727. void tetrisReset(void)
  728. {
  729. 	int key;
  730. 	key = MessageBox(NULL,"是否重新开始游戏？","提示",MB_YESNO| MB_SYSTEMMODAL);
  731. 	CLEARKEY();	
  732. 	switch(key)
  733. 	{
  734. 		case IDYES:
  735. 			tetrisInit();
  736. 			break;
  737. 		case IDNO:
  738. 			break;
  739. 		default:
  740. 			break;
  741. 	}
  742. }
  743.  
  744. void tetrisRemove(void)
  745. {
  746. 	int i,j,m,n;
  747. 	int flag,bnum;
  748. 	bnum = 0;
  749.  
  750. 	for(i = TETRISHEIGHT - 1; i >= 0; i-- )
  751. 	{
  752. 		flag = 0;
  753. 		for(j = 0; j < TETRISWIDTH; j++)
  754. 		{
  755. 			if(!tetrisMap[i][j])
  756. 			{
  757. 				flag = 1;
  758. 				break;
  759. 			}
  760. 		}
  761. 		if(flag)
  762. 		{
  763. 			continue;
  764. 		}
  765. 		bnum++;		
  766. 		for(j = 0; j < TETRISWIDTH; j++)
  767. 		{
  768. 			tetrisMap[i][j] = BLOCKNONE;
  769. 		}
  770. 		for(m = i; m > 0; m--)
  771. 		{
  772. 			for(n = 0; n < TETRISWIDTH; n++)
  773. 			{
  774. 				tetrisMap[m][n] = tetrisMap[m - 1][n];
  775. 			}
  776. 		}
  777. 		i++;		
  778. 	}
  779.  
  780. 	if(!bnum)
  781. 	{
  782. 		return;
  783. 	}
  784. 	switch(bnum)
  785. 	{
  786. 		case 0:
  787. 			break;
  788. 		case 1:
  789. 			player.rank += 10;
  790. 			break;
  791. 		case 2:
  792. 			player.rank += 20;
  793. 			break;
  794. 		case 3:
  795. 			player.rank += 40;
  796. 			break;
  797. 		case 4:
  798. 			player.rank += 80;
  799. 			break;
  800. 		default:
  801. 			break;
  802. 	}
  803. 	player.level = player.rank/100;
  804. 	if(player.level > 10)
  805. 	{
  806. 		player.level = 10;
  807. 	}
  808.  
  809. }

二、easyX库安装

EasyX Graphics Library for C++

进入以上链接，下载并安装easyX库

三、宏定义、变量的说明

  • 1.方块像素

方块为正方形，大小为20X20像素

#define		SIDELENGTH		20

  • 2.游戏地图区域

游戏地图为矩形，大小为600X300像素，四个角坐标为下面的宏定义。

  1. #define		GAMEMAP1		200		
  2. #define		GAMEMAP2		10
  3. #define		GAMEMAP3		500
  4. #define		GAMEMAP4		610

 使用rectangle函数，填入四个角坐标，画出游戏地图边界

rectangle(GAMEMAP1 - 2,GAMEMAP2 - 2,GAMEMAP3 + 2,GAMEMAP4 + 2);

 

把地图按20X20像素分割，就是30X15个方块，这样就把地图转换为坐标的形式了，选中一个方块格，再进行涂色，就是一个相应的方块了。

  • 3.预生成方块区域

预生成方块区域为100X80像素的矩形，四个角坐标如下宏定义

  1. #define		GAMEMAP5		40		// 预生成方块区域
  2. #define		GAMEMAP6		50
  3. #define		GAMEMAP7		140
  4. #define		GAMEMAP8		130

使用rectangle函数，填入四个角坐标，画出游戏地图边界

rectangle(GAMEMAP5 - 2,GAMEMAP6 - 2,GAMEMAP7 + 2,GAMEMAP8 + 2);

把区域按照20X20像素分割，就是4X5个方块，这样就可以转换为坐标的形式；

根据随机得到的方块种类，换算成四个坐标，再选择颜色进行填充，就可以得到预生成的方块了。

  • 4.玩家数据结构

  1. typedef struct _GAME_TETRIS
  2. {
  3. 	int		ttime;			// 计时
  4. 	int		ctime;			// 计时
  5. 	int		level;			// 当前游戏等级
  6. 	int		rank;			// 当前游戏分数
  7. 	int		key;			// 玩家按键值
  8. 	int		blockType;		// 当前方块类型
  9. 	int		blockStyle;		// 当前方块朝向
  10.  
  11. 	bool	moveFlag;		// 移动标识，标识为1时，移动当前方块
  12. 	bool	newBlockFlag;	// 载入新方块标识，当标识为真时，将预生成的随机方块载入地图
  13. 	bool	gameOverFlag;	// 游戏结束标识
  14. }GAME_TETRIS;

GAME_TETRIS        player;        // 玩家数据

player会保存玩家在游戏中的数据，ttime和ctime是用来定时的，每隔（500ms - 等级*30毫秒），会将moveflag置1，方块下降一行；

level和rank是玩家当前获得分数，已经根据分数得到的level；

key是玩家按下的键盘输入值；

blockType和blockStyle是玩家当前控制方块的方块类型和方块朝向，用来判定方块是否可以左、右、下移、变换形态；

moveflag，移动标识，标识为1时，当前方块会下移一行；

bewBlockFlag，新方块标识，标识为1时，会执行以下函数：当前方块载入游戏地图、消除满行的方块、生成新的方块、判断游戏是否结束；

gameOverFlag，游戏结束标识，标识为1时，会让玩家选择结束游戏，或重新开始游戏

  • 5.所有方块数据库

数据库是一个三维数组

总共有8种类型的方块，每个类型的方块颜色都不一样；每个方块有4个样式（朝向）；每种方块的每种朝向都是一个5X4的方块矩形。

生成新方块时，就会从方块数据库中获取方块数据。

  1. #define		BLOCKTYPE		8		// 方块种类数
  2. #define		BLOCKSTYLE		4		// 每种方块的样式数
  3. #define		BLOCKSPACE		20		// 方块占用空间 5 x 4
  1. const int block[BLOCKTYPE][BLOCKSTYLE][BLOCKSPACE] = 
  2. {
  3. 	// 总共有8种方块，每种方块有4种样式
  4.  
  5. 	// 'I'形方块
  6. 	{
  7. 		{
  8. 			BLOCKNONE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,
  9. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  10. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  11. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  12. 		},
  13. 		{
  14. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  15. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  16. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  17. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE
  18. 		},
  19. 		{
  20. 			BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKBLUE,	BLOCKNONE,
  21. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  22. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  23. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  24. 		},
  25. 		{
  26. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  27. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  28. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE,
  29. 			BLOCKNONE,	BLOCKNONE,	BLOCKBLUE,	BLOCKNONE,	BLOCKNONE
  30. 		}
  31. 	},
  32. 	// 'Z'形方块
  33. 	{
  34. 		{
  35. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  36. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,
  37. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  38. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  39. 		},
  40. 		{
  41. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  42. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  43. 			BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  44. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  45. 		},
  46. 		{
  47. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  48. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,
  49. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  50. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  51. 		},
  52. 		{
  53. 			BLOCKNONE,	BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  54. 			BLOCKNONE,	BLOCKGREEN,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,
  55. 			BLOCKNONE,	BLOCKGREEN,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  56. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  57. 		}
  58. 	},
  59. 	// 反'Z'形方块
  60. 	{
  61. 		{
  62. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  63. 			BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  64. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  65. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  66. 		},
  67. 		{
  68. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  69. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  70. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,
  71. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  72. 		},
  73. 		{
  74. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  75. 			BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  76. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  77. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  78. 		},
  79. 		{
  80. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,	BLOCKNONE,
  81. 			BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKCYAN,	BLOCKNONE,
  82. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKCYAN,	BLOCKNONE,
  83. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  84. 		}
  85. 	},
  86. 	// 'T'形方块
  87. 	{
  88. 		{
  89. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  90. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  91. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  92. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  93. 		},
  94. 		{
  95. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  96. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  97. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  98. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  99. 		},
  100. 		{
  101. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  102. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  103. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  104. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  105. 		},
  106. 		{
  107. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  108. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  109. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  110. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  111. 		}
  112. 	},
  113. 	// 'T'形方块 X 2 增加T形方块出现概率
  114. 	{
  115. 		{
  116. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  117. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  118. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  119. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  120. 		},
  121. 		{
  122. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  123. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  124. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  125. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  126. 		},
  127. 		{
  128. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKRED,	BLOCKNONE,
  129. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  130. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  131. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  132. 		},
  133. 		{
  134. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  135. 			BLOCKNONE,	BLOCKRED,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  136. 			BLOCKNONE,	BLOCKNONE,	BLOCKRED,	BLOCKNONE,	BLOCKNONE,
  137. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  138. 		}
  139. 	},
  140. 	// '田'形方块
  141. 	{
  142. 		{
  143. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  144. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  145. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  146. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  147. 		},
  148. 		{
  149. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  150. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  151. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  152. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  153. 		},
  154. 		{
  155. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  156. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  157. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  158. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  159. 		},
  160. 		{
  161. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  162. 			BLOCKNONE,	BLOCKNONE,	BLOCKMAGENTA,BLOCKMAGENTA,BLOCKNONE,
  163. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  164. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  165. 		}
  166. 	},
  167. 	// 'L'形方块
  168. 	{
  169. 		{
  170. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  171. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  172. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKBROWN,	BLOCKNONE,
  173. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  174. 		},
  175. 		{
  176. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKBROWN,	BLOCKBROWN,
  177. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  178. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  179. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  180. 		},
  181. 		{
  182. 			BLOCKNONE,	BLOCKBROWN,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  183. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  184. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  185. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  186. 		},
  187. 		{
  188. 			BLOCKNONE,	BLOCKNONE,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  189. 			BLOCKBROWN,	BLOCKBROWN,	BLOCKBROWN,	BLOCKNONE,	BLOCKNONE,
  190. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  191. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  192. 		}
  193. 	},
  194. 	// 反'L'形方块
  195. 	{
  196. 		{
  197. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  198. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  199. 			BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  200. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  201. 		},
  202. 		{
  203. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  204. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKYELLOW,
  205. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  206. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  207. 		},
  208. 		{
  209. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKNONE,
  210. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  211. 			BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,	BLOCKNONE,
  212. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  213. 		},
  214. 		{
  215. 			BLOCKNONE,	BLOCKYELLOW,BLOCKYELLOW,BLOCKYELLOW,BLOCKNONE,
  216. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKYELLOW,BLOCKNONE,
  217. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,
  218. 			BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE,	BLOCKNONE
  219. 		}
  220. 	}
  221.  
  222. };

  • 6.当前控制方块数据结构

  1. typedef struct _GAME_MOVE_BLOCK
  2. {
  3. 	int blockSite[4][2];	// 4个方块格坐标
  4. 	int blockColor;			// 方块颜色
  5. }GAME_MOVE_BLOCK;

GAME_MOVE_BLOCK moveBlock;    // 当前控制方块数据

数据结构由两部分组成，一个是保存了四个方块坐标的二维数组；一个是当前控制方块的颜色；

有了坐标和颜色，就可以在游戏地图中，准确的画出当前控制方块。

四、主函数tetrisrun()

  • 1.函数说明

主函数由一个初始化函数，和一个死循环组成；初始化游戏数据后，会在死循环while(1)中不停的执行游戏数据处理，直到玩家选择退出游戏。

通过主函数，也能看出来整个代码的运行逻辑，了解编程思路。

  1. void tetrisrun(void)
  2. {
  3. 	tetrisInit();
  4. 	while(1)
  5. 	{
  6. 		// (每500毫秒 - 游戏等级*30毫秒)运行一次，方块下移
  7. 		player.ctime = GetTickCount();
  8. 		if( (player.ctime - 500 + 30*player.level) > player.ttime )
  9. 		{	
  10. 			player.moveFlag = TRUE;
  11. 			player.ttime = GetTickCount();
  12. 		}
  13. 		// 如果移动标识为1，则当前方块下移
  14. 		if(player.moveFlag)
  15. 		{
  16. 			player.moveFlag = FALSE;
  17.  
  18. 			tetrisMoveDown();
  19. 			tetrisDraw();
  20. 		}
  21. 		// 用户按键处理
  22. 		if(_kbhit())
  23. 		{	
  24. 			player.key = _getch();
  25. 			tetrisKeyHandle();
  26. 		}
  27. 		// 将预生成的随机方块载入游戏地图
  28. 		if(player.newBlockFlag)
  29. 		{
  30. 			player.newBlockFlag = FALSE;
  31. 			// 将当前方块载入游戏地图
  32. 			tetrisLoadBlock();
  33. 			// 消除满行的方块
  34. 			tetrisRemove();
  35. 			// 生成新的方块
  36. 			tetrisNewBlock();
  37. 			// 判断游戏是否结束
  38. 			tetrisIsOver();
  39. 		}
  40. 		// 游戏结束处理
  41. 		if(player.gameOverFlag)
  42. 		{
  43. 			player.gameOverFlag = FALSE;
  44. 			break;
  45. 		}
  46.  
  47. 	}
  48.  
  49. }
  •  2.计时部分

// (每500毫秒 - 游戏等级*30毫秒)运行一次，方块下移
        player.ctime = GetTickCount();
        if( (player.ctime - 500 + 30*player.level) > player.ttime )
        {    
            player.moveFlag = TRUE;
            player.ttime = GetTickCount();
        }

第一部分，计时部分：通过记录两个时间变量的时间差，来得到一个周期执行的标识

1.初始化时，先给变量player.ttime赋值，获得当时的时间数据；

2.每次主程序循环时，都会给另一个变量player.ctime赋值，获得最新的时间数据；

3.以默认的500ms周期为例，如果最新的时间player.ctime减去500ms，还是大于当时的时间player.ttime，说明离第一次给player.ttime赋值，已经过去了500ms，满足一个周期；

4.此时，给周期执行标识 player.moveFlag置1；表示当前方块需要下移了，将会在后面的函数处理，并将标识置0，等待下一次周期来临；

5.再给player.ttime赋值，获得当时的时间数据，开始执行下一次500ms的周期计算。

  • 3.方块移动

// 如果移动标识为1，则当前方块下移
        if(player.moveFlag)
        {
            player.moveFlag = FALSE;

            tetrisMoveDown();
            tetrisDraw();
        }

第二部分，方块移动：每过一个周期，方块移动标识player.moveFlag置1，执行这部分函数

1.先将移动标识player.moveFlag置0，方便下一次周期的执行；

2.执行方块下移函数tetrisMoveDown()，对方块进行下移处理；如果方块到达游戏底部，或者下方已经存在方块，就会将生成新方块标识player.newBlockFlag置1，进行后面的处理；

3.执行绘制地图函数tetrisDraw()，画出方块下移后的画面。

  • 4.按键处理

// 用户按键处理
        if(_kbhit())
        {    
            player.key = _getch();
            tetrisKeyHandle();
        }

第三部分，按键处理：对用户的按键进行处理，控制方块的移动、游戏的进程

1._kbhit()函数，每当检测到用户按下按键时，会返回TRUE，此时if条件为真，执行if里面的代码；

2.通过_getch()函数，将用户按键值赋给变量player.key；

3.执行按键处理函数tetrisKeyHandle()，对不同的按键进行不同的处理

  • 5.新方块处理

// 将预生成的随机方块载入游戏地图
        if(player.newBlockFlag)
        {
            player.newBlockFlag = FALSE;
            // 将当前方块载入游戏地图
            tetrisLoadBlock();
            // 消除满行的方块
            tetrisRemove();
            // 生成新的方块
            tetrisNewBlock();
            // 判断游戏是否结束
            tetrisIsOver();
        }

第四部分，新方块处理：每当当前方块到达游戏底部，或者当前方块下一行已存在方块时，会将新方块标识player.newBlockFlag置1，执行if里面的代码。

1.先把新方块标识player.newBlockFlag清0，防止重复执行；

2.当前方块已不能下移，执行tetrisLoadBlock()函数，把当前方块固定到游戏地图，不再移动；

3.固定方块后，执行tetrisRemove()函数，检测并消除满行的方块，并通过消除的行数，增加RANK分，改变level等级；

4.消除满行后，执行tetrisNewBlock()函数，将预生成的方块载入游戏，成为当前控制方块，并生成新的随机方块，载入到预生成方块地图；

5.生成新方块后，执行 tetrisIsOver()函数，判断当前控制方块是否和游戏地图有重叠，如果重叠，则游戏结束，将结束标识player.gameOverFlag置1，并让用户选择是结束游戏还是重新开始。

  • 6.游戏结束

// 游戏结束处理
        if(player.gameOverFlag)
        {
            player.gameOverFlag = FALSE;
            break;
        }

第五部分，游戏结束处理：如果用户决定结束游戏， 则退出while（1）死循环，退出程序。

五、代码和所有函数说明

上面已经解释过主函数tetrisrun()，接下来会详细解释每一个函数

  • 1. tetrisInit()

初始化函数，程序会先运行初始化函数，然后再进入while（1）死循环，运行俄罗斯方块游戏；

  1. void tetrisInit(void)
  2. {
  3. 	int i,j,k;
  4. 	HWND window = initgraph(510, 620);	// 初始化窗口大小
  5. 	SetWindowText(window, "俄罗斯方块 - by耒阳阿杰");	// 设置当前窗口的标题
  6. 	//SetWindowPos(window,HWND_TOPMOST,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE);	// 置顶
  7.  
  8. 	rectangle(GAMEMAP1 - 2,GAMEMAP2 - 2,GAMEMAP3 + 2,GAMEMAP4 + 2);		// 绘制游戏地图范围
  9. 	rectangle(GAMEMAP5 - 2,GAMEMAP6 - 2,GAMEMAP7 + 2,GAMEMAP8 + 2);		// 绘制预生成方块方位
  10. 	rectangle(GAMEGUIDE1 - 5,GAMEGUIDE2 - 5,GAMEGUIDE3 + 5,GAMEGUIDE4 + 5);		// 绘制按键说明
  11.  
  12. 	outtextxy(GAMEMAP5 + 10 ,GAMEMAP6 - 26,"下个方块");
  13. 	settextcolor(GREEN);
  14. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2		,"W   ：改变形状");
  15. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 25	,"A    ：方块左移");
  16. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 50	,"S    ：方块右移");
  17. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 75	,"D    ：方块下移");
  18. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 100	,"R    ：重新开始");
  19. 	outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 125	,"ESC：退出游戏");
  20.  
  21. 	// 初始化游戏数据
  22. 	memset ( &player, 0, sizeof ( GAME_TETRIS ) );
  23. 	memset ( &preBlock, 0, sizeof ( GAME_PREBLOCK ) );
  24. 	memset(tetrisMap,0,sizeof(tetrisMap));
  25. 	player.ttime = GetTickCount();
  26.  
  27. 	// 获取随机数，生成第一个随机方块
  28. 	srand((unsigned)time(NULL));		// 获取随机数，生成新的随机方块
  29. 	i = (rand() + 1) % BLOCKTYPE;
  30. 	j = rand() % BLOCKSTYLE;
  31. 	for(k = 0; k < BLOCKSPACE;k++)
  32. 	{
  33. 		preBlock.tetrisPreBlock[k] = block[i][j][k];
  34. 	}
  35. 	preBlock.blockType = i;
  36. 	preBlock.blockStyle = j;
  37. 	// 把第一个随机方块加载进游戏，并生成下一个随机方块
  38. 	tetrisNewBlock();	
  39. }

HWND window = initgraph(510, 620);    // 初始化窗口大小
SetWindowText(window, "俄罗斯方块 - by耒阳阿杰");    // 设置当前窗口的标题
//SetWindowPos(window,HWND_TOPMOST,0,0,0,0,SWP_NOSIZE|SWP_NOMOVE);    // 置顶

1.初始化窗口，定义窗口大小，设置窗口标题，屏蔽的SetWindowPos()函数是用于给游戏置顶的，置顶之后，总是会显示在WINDOWS的最顶层，类似于微信的置顶；

rectangle(GAMEMAP1 - 2,GAMEMAP2 - 2,GAMEMAP3 + 2,GAMEMAP4 + 2);        // 绘制游戏地图范围
    rectangle(GAMEMAP5 - 2,GAMEMAP6 - 2,GAMEMAP7 + 2,GAMEMAP8 + 2);        // 绘制预生成方块方位
    rectangle(GAMEGUIDE1 - 5,GAMEGUIDE2 - 5,GAMEGUIDE3 + 5,GAMEGUIDE4 + 5);        // 绘制按键说明

    outtextxy(GAMEMAP5 + 10 ,GAMEMAP6 - 26,"下个方块");
    settextcolor(GREEN);
    outtextxy(GAMEGUIDE1 ,GAMEGUIDE2        ,"W   ：改变形状");
    outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 25    ,"A    ：方块左移");
    outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 50    ,"S    ：方块右移");
    outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 75    ,"D    ：方块下移");
    outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 100    ,"R    ：重新开始");
    outtextxy(GAMEGUIDE1 ,GAMEGUIDE2 + 125    ,"ESC：退出游戏");

2.rectangle()函数是根据你输入的四个坐标，绘制一个矩形，这里绘制了游戏地图、预生成方块地图、按键说明框；

outtextxy(x,y,string)函数是根据你输入的起点坐标，还有后面的字符串，在相应位置打印字符串内容；

settextcolor(GREEN)函数是设置打印字符串的颜色；

// 初始化游戏数据
    memset ( &player, 0, sizeof ( GAME_TETRIS ) );
    memset ( &preBlock, 0, sizeof ( GAME_PREBLOCK ) );
    memset(tetrisMap,0,sizeof(tetrisMap));
    player.ttime = GetTickCount();

3. memset()函数是重置结构或者数据的数据，将他们置0；

然后给player.ttime赋值当时的时间，方便后面用来判定500ms周期。

// 获取随机数，生成第一个随机方块
    srand((unsigned)time(NULL));        // 获取随机数，生成新的随机方块
    i = (rand() + 1) % BLOCKTYPE;
    j = rand() % BLOCKSTYLE;
    for(k = 0; k < BLOCKSPACE;k++)
    {
        preBlock.tetrisPreBlock[k] = block[i][j][k];
    }
    preBlock.blockType = i;
    preBlock.blockStyle = j;
    // 把第一个随机方块加载进游戏，并生成下一个随机方块
    tetrisNewBlock();    

4.关于随机数生成，分为伪随机和真随机，这个建议读者们自己去查阅相关资料；

通过生成的随机数，再分别取方块类型和形状（朝向）的余数，就能得到一个随机方块的数据了；

得到第一个随机方块后，再执行 tetrisNewBlock()函数，把第一个随机方块载入游戏地图，再生成新的随机方块，载入预生成方块地图。

  • 2.tetrisDraw()

绘制函数，根据当前游戏数据，绘制整个游戏画面。

  1. void tetrisDraw(void)
  2. {
  3. 	int i,j;
  4. 	int x,y;
  5. 	char ch[20];
  6. 	
  7. 	// 更新RANK分数和LEVEL等级
  8. 	settextstyle(20,12,"宋体");	// 设置字体和大小
  9. 	settextcolor(CYAN);			// 设置字体颜色
  10. 	if(player.level < 10)
  11. 	{
  12. 		sprintf_s(ch, "%s%d","LEVEL：", player.level);
  13. 	}
  14. 	else
  15. 	{	// 等级为10时，显示最大max
  16. 		sprintf_s(ch, "%s","LEVEL：MAX");
  17. 	}
  18. 	outtextxy(GAMELEVEL1,GAMELEVEL2,ch);
  19. 	settextcolor(LIGHTBLUE);
  20. 	sprintf_s(ch, "%s%d","RANK：", player.rank);
  21. 	outtextxy(GAMERANK1,GAMERANK2,ch);
  22.  
  23. 	// 绘制预生成方块的背景板
  24. 	setfillcolor(BLACK);
  25. 	solidrectangle(GAMEMAP5,GAMEMAP6,GAMEMAP7,GAMEMAP8);
  26.  
  27. 	// 绘制预生成的方块
  28. 	for(i = 0; i < BLOCKSPACE; i++)
  29. 	{
  30. 		switch(preBlock.tetrisPreBlock[i])
  31. 		{
  32. 			case BLOCKNONE:				// 空
  33. 				continue;
  34. 				break;
  35. 			case BLOCKBLUE:				// 蓝色
  36. 				setfillcolor(BLUE);
  37. 				break;
  38. 			case BLOCKGREEN:			// 绿色
  39. 				setfillcolor(GREEN);
  40. 				break;
  41. 			case BLOCKCYAN:				// 青色
  42. 				setfillcolor(CYAN);
  43. 				break;
  44. 			case BLOCKRED:				// 红色
  45. 				setfillcolor(RED);
  46. 				break;
  47. 			case BLOCKMAGENTA:			// 深红色
  48. 				setfillcolor(MAGENTA);
  49. 				break;
  50. 			case BLOCKBROWN:			// 灰色
  51. 				setfillcolor(BROWN);
  52. 				break;
  53. 			case BLOCKYELLOW:
  54. 				setfillcolor(YELLOW);
  55. 				break;
  56. 		}
  57. 		// 填充相应区域
  58. 		fillrectangle(GAMEMAP5 + (i%5) * SIDELENGTH ,GAMEMAP6 + (i/5) * SIDELENGTH ,GAMEMAP5 + ((i%5)+1)*SIDELENGTH ,GAMEMAP6 + ((i/5)+1) * SIDELENGTH );		
  59. 	}
  60.  
  61. 	// 绘制游戏地图背景板
  62. 	setfillcolor(BLACK);
  63. 	solidrectangle(GAMEMAP1,GAMEMAP2,GAMEMAP3,GAMEMAP4);
  64.  
  65. 	// 绘制当前控制方块的4个方块格
  66. 	for(i = 0; i < 4; i++)
  67. 	{
  68. 		x = moveBlock.blockSite[i][0];
  69. 		y = moveBlock.blockSite[i][1];
  70. 		switch(moveBlock.blockColor)
  71. 		{
  72. 			case BLOCKNONE:
  73. 				continue;
  74. 				break;
  75. 			case BLOCKBLUE:
  76. 				setfillcolor(BLUE);
  77. 				break;
  78. 			case BLOCKGREEN:
  79. 				setfillcolor(GREEN);
  80. 				break;
  81. 			case BLOCKCYAN:
  82. 				setfillcolor(CYAN);
  83. 				break;
  84. 			case BLOCKRED:
  85. 				setfillcolor(RED);
  86. 				break;
  87. 			case BLOCKMAGENTA:
  88. 				setfillcolor(MAGENTA);
  89. 				break;
  90. 			case BLOCKBROWN:
  91. 				setfillcolor(BROWN);
  92. 				break;
  93. 			case BLOCKYELLOW:
  94. 				setfillcolor(YELLOW);
  95. 				break;
  96. 		}
  97. 		// 填充相应区域
  98. 		fillrectangle(GAMEMAP1 + y * SIDELENGTH ,GAMEMAP2 + x * SIDELENGTH ,GAMEMAP1 + (y+1)*SIDELENGTH ,GAMEMAP2 + (x+1) * SIDELENGTH );		
  99. 	}
  100.  
  101. 	// 绘制游戏实时画面
  102. 	for(i = 0; i < TETRISHEIGHT; i++)
  103. 	{
  104. 		for(j = 0; j < TETRISWIDTH; j++)
  105. 		{	
  106. 			switch(tetrisMap[i][j])
  107. 			{
  108. 				case BLOCKNONE:
  109. 					continue;
  110. 					break;
  111. 				case BLOCKBLUE:
  112. 					setfillcolor(BLUE);
  113. 					break;
  114. 				case BLOCKGREEN:
  115. 					setfillcolor(GREEN);
  116. 					break;
  117. 				case BLOCKCYAN:
  118. 					setfillcolor(CYAN);
  119. 					break;
  120. 				case BLOCKRED:
  121. 					setfillcolor(RED);
  122. 					break;
  123. 				case BLOCKMAGENTA:
  124. 					setfillcolor(MAGENTA);
  125. 					break;
  126. 				case BLOCKBROWN:
  127. 					setfillcolor(BROWN);
  128. 					break;
  129. 				case BLOCKYELLOW:
  130. 					setfillcolor(YELLOW);
  131. 					break;
  132. 			}
  133. 			// 填充相应区域
  134. 			fillrectangle(GAMEMAP1 + j * SIDELENGTH ,GAMEMAP2 + i * SIDELENGTH ,GAMEMAP1 + (j+1)*SIDELENGTH ,GAMEMAP2 + (i+1) * SIDELENGTH );		
  135. 		}
  136. 	}
  137. }

// 更新RANK分数和LEVEL等级
    settextstyle(20,12,"宋体");    // 设置字体和大小
    settextcolor(CYAN);            // 设置字体颜色
    if(player.level < 10)
    {
        sprintf_s(ch, "%s%d","LEVEL：", player.level);
    }
    else
    {    // 等级为10时，显示最大max
        sprintf_s(ch, "%s","LEVEL：MAX");
    }
    outtextxy(GAMELEVEL1,GAMELEVEL2,ch);
    settextcolor(LIGHTBLUE);
    sprintf_s(ch, "%s%d","RANK：", player.rank);
    outtextxy(GAMERANK1,GAMERANK2,ch);

1.设置输出字符的大小和字体，再设置颜色；

等级在10级以下时，照常显示；10级及以上时，显示MAX；

// 绘制预生成方块的背景板
    setfillcolor(BLACK);
    solidrectangle(GAMEMAP5,GAMEMAP6,GAMEMAP7,GAMEMAP8);

2.  setfillcolor(BLACK)设置填充颜色；solidrectangle(GAMEMAP5,GAMEMAP6,GAMEMAP7,GAMEMAP8) 根据四个坐标，使用设置好的填充颜色填充矩形区域，实际就是绘制一个带白色边框的黑色矩形。

// 绘制预生成的方块
    for(i = 0; i < BLOCKSPACE; i++)
    {
        switch(preBlock.tetrisPreBlock[i])
        {
            case BLOCKNONE:                // 空
                continue;
                break;
            case BLOCKBLUE:                // 蓝色
                setfillcolor(BLUE);
                break;
            case BLOCKGREEN:            // 绿色
                setfillcolor(GREEN);
                break;
            case BLOCKCYAN:                // 青色
                setfillcolor(CYAN);
                break;
            case BLOCKRED:                // 红色
                setfillcolor(RED);
                break;
            case BLOCKMAGENTA:            // 深红色
                setfillcolor(MAGENTA);
                break;
            case BLOCKBROWN:            // 灰色
                setfillcolor(BROWN);
                break;
            case BLOCKYELLOW:
                setfillcolor(YELLOW);
                break;
        }
        // 填充相应区域
        fillrectangle(GAMEMAP5 + (i%5) * SIDELENGTH ,GAMEMAP6 + (i/5) * SIDELENGTH ,GAMEMAP5 + ((i%5)+1)*SIDELENGTH ,GAMEMAP6 + ((i/5)+1) * SIDELENGTH );        
    }

3.绘制好预生成方块区域后，preBlock.tetrisPreBlock[i]是一个包含20个成员的数组，里面有16个空成员，不用管；还有4个成员就是要绘制的方块。用switch选择相应的填充颜色setfillcolor()，然后再执行 fillrectangle()函数，在相应坐标填充方块；

最后的填充函数，可能会有点复杂，这里解释一下：

预生成方块区域是一个100X80像素大小的矩形，每个方块都是20X20像素大小，所以矩形按20X20像素切割，得到一个5X4的坐标轴，包含20个方块，刚好和所有方块数据库里的方块对应。

如下图所示，只需要把数据库里20个数据中，包含方块的四个数据选出来填入，就能得到一个完整的方块了。

现在，我想要绘制一个 '----' 型方块，只需要填充2,3,4,5这4个坐标，就能得到方块；

那么它在preBlock.tetrisPreBlock[]数组中对应的数据就是

{0,1,1,1,1, 0,0,0,0,0, 0,0,0,0,0, 0,0,0,0,0};得到的最终图像就是如下所示

当preBlock.tetrisPreBlock[i]为1时，就会执行fillrectangle()函数，根据i的值，获得四个坐标值，填充这个方块；

第一个方块：i = 1,  fillrectangle(GAMEMAP5 + 1 * 20,GAMEMAP6,GAMEMAP5 + 2*20,GAMEMAP6 + 1 * 20); 

GAMEMAP5和GAMEMAP6就是预生成方块区域的坐上角坐标，将它视为起点坐标，忽略掉，

上面的fillrectangle() 就相当于fillrectangle( 20,0, 40,20)，绘制出来就是如下图

 第二个方块：i = 2，fillrectangle(GAMEMAP5 + 2 * 20,GAMEMAP6  ,GAMEMAP5 + 3*20,GAMEMAP6 + 1 * 20);  

忽略起点坐标，得到fillrectangle( 40,0,60,20),绘制出来如下图

 依次画出第三个方块，第四个方块，就能得到最终的图像了

// 绘制游戏地图背景板
    setfillcolor(BLACK);
    solidrectangle(GAMEMAP1,GAMEMAP2,GAMEMAP3,GAMEMAP4);

4.和2类似，绘制一个白色边框的纯黑矩形

// 绘制当前控制方块的4个方块格
    for(i = 0; i < 4; i++)
    {
        x = moveBlock.blockSite[i][0];
        y = moveBlock.blockSite[i][1];
        switch(moveBlock.blockColor)
        {
            case BLOCKNONE:
                continue;
                break;
            case BLOCKBLUE:
                setfillcolor(BLUE);
                break;
            case BLOCKGREEN:
                setfillcolor(GREEN);
                break;
            case BLOCKCYAN:
                setfillcolor(CYAN);
                break;
            case BLOCKRED:
                setfillcolor(RED);
                break;
            case BLOCKMAGENTA:
                setfillcolor(MAGENTA);
                break;
            case BLOCKBROWN:
                setfillcolor(BROWN);
                break;
            case BLOCKYELLOW:
                setfillcolor(YELLOW);
                break;
        }
        // 填充相应区域
        fillrectangle(GAMEMAP1 + y * SIDELENGTH ,GAMEMAP2 + x * SIDELENGTH ,GAMEMAP1 + (y+1)*SIDELENGTH ,GAMEMAP2 + (x+1) * SIDELENGTH );        
    }

5.和3类似，变量moveBlock.blockSite[]保存了当前方块的四个方块格坐标，根据方块颜色moveBlock.blockColor，通过switch选择相应的颜色，然后fillrectangle填充，得到当前方块。

// 绘制游戏实时画面
    for(i = 0; i < TETRISHEIGHT; i++)
    {
        for(j = 0; j < TETRISWIDTH; j++)
        {    
            switch(tetrisMap[i][j])
            {
                case BLOCKNONE:
                    continue;
                    break;
                case BLOCKBLUE:
                    setfillcolor(BLUE);
                    break;
                case BLOCKGREEN:
                    setfillcolor(GREEN);
                    break;
                case BLOCKCYAN:
                    setfillcolor(CYAN);
                    break;
                case BLOCKRED:
                    setfillcolor(RED);
                    break;
                case BLOCKMAGENTA:
                    setfillcolor(MAGENTA);
                    break;
                case BLOCKBROWN:
                    setfillcolor(BROWN);
                    break;
                case BLOCKYELLOW:
                    setfillcolor(YELLOW);
                    break;
            }
            // 填充相应区域
            fillrectangle(GAMEMAP1 + j * SIDELENGTH ,GAMEMAP2 + i * SIDELENGTH ,GAMEMAP1 + (j+1)*SIDELENGTH ,GAMEMAP2 + (i+1) * SIDELENGTH );        
        }
    }

6.和3、5类似，tetrisMap[]数组保存了游戏地图中已经固定下来的方块和颜色，通过switch选择颜色，然后使用fillrectangle()函数，绘制所有固定方块。

  • 3.tetrisNewBlock() 函数

当新方块标识player.newBlockFlag为1时，会执行本函数，把预生成方块加载进游戏，成为当前控制方块；之后再获取随机数，生成新的预生成方块。

  1. void tetrisNewBlock(void)
  2. {
  3. 	int i,j,k;
  4.  
  5. 	// 把上一个随机方块加载进当前方块数组
  6. 	k = 0;
  7. 	for(i = 0; i < BLOCKSPACE; i++)
  8. 	{
  9. 		if(preBlock.tetrisPreBlock[i])
  10. 		{
  11. 			moveBlock.blockColor = preBlock.tetrisPreBlock[i];	// 记录方块颜色
  12. 			moveBlock.blockSite[k][0] = i/5;					// 记录方块格的X坐标
  13. 			moveBlock.blockSite[k][1] = 5 + i%5;				// 记录方块格的Y坐标
  14. 			k++;
  15. 		}
  16. 	}
  17. 	player.blockType = preBlock.blockType;		// 记录方块的类型
  18. 	player.blockStyle = preBlock.blockStyle;	// 记录方块的形状(朝向)
  19.  
  20. 	// 获取随机数，生成新的随机方块
  21. 	srand((unsigned)time(NULL));		
  22. 	i = rand() % BLOCKTYPE;
  23. 	j = rand() % BLOCKSTYLE;
  24. 	for(k = 0; k < BLOCKSPACE;k++)
  25. 	{
  26. 		preBlock.tetrisPreBlock[k] = block[i][j][k];
  27. 	}
  28. 	preBlock.blockType = i;
  29. 	preBlock.blockStyle = j;
  30. }

// 把上一个随机方块加载进当前方块数组
    k = 0;
    for(i = 0; i < BLOCKSPACE; i++)
    {
        if(preBlock.tetrisPreBlock[i])
        {
            moveBlock.blockColor = preBlock.tetrisPreBlock[i];    // 记录方块颜色
            moveBlock.blockSite[k][0] = i/5;                    // 记录方块格的X坐标
            moveBlock.blockSite[k][1] = 5 + i%5;                // 记录方块格的Y坐标
            k++;
        }
    }
    player.blockType = preBlock.blockType;        // 记录方块的类型
    player.blockStyle = preBlock.blockStyle;    // 记录方块的形状(朝向)

1.preBlock.tetrisPreBlock[i]数组有16个成员为0，还有4个非0成员（方块格），检测到非0成员（方块格）时，就会记录方块颜色、坐标、类型、形状（朝向），保存到当前方块变量moveBlock。

// 获取随机数，生成新的随机方块
    srand((unsigned)time(NULL));        
    i = rand() % BLOCKTYPE;
    j = rand() % BLOCKSTYLE;
    for(k = 0; k < BLOCKSPACE;k++)
    {
        preBlock.tetrisPreBlock[k] = block[i][j][k];
    }
    preBlock.blockType = i;
    preBlock.blockStyle = j;

2.生成随机数，然后得到方块类型和形状（朝向），再把方块数据库中对应的20个成员值复制到preBlock.tetrisPreBlock数组中，就成为了一个新的随机方块。

4.tetrisMoveUp() 函数

当玩家按下W键后，会执行此函数，如果当前方块可改变形状（朝向），则改变形状（朝向）。

  1. void tetrisMoveUp(void)
  2. {
  3. 	int i,k;
  4. 	int bStyle;
  5. 	int ux,uy;					// 改变方块朝向前后，方块格的位移矢量
  6. 	int blocksite2[4][2];		// 记录改变朝向前，4个方块的方块库坐标
  7. 	int blocksite3[4][2];		// 记录改变朝向后，4个方块的方块库坐标
  8. 	int blocksite4[4][2];		// 记录改变朝向后，4个方块的游戏地图坐标
  9.  
  10. 	// 找到4个方块格的方块库坐标
  11. 	k = 0;
  12. 	for(i = 0; i < BLOCKSPACE; i++)
  13. 	{
  14. 		// 得到4个方块坐标后，退出循环
  15. 		if(k > 3)
  16. 		{	
  17. 			break;
  18. 		}
  19. 		if(block[player.blockType][player.blockStyle][i])
  20. 		{
  21. 			blocksite2[k][0] = i / 5;
  22. 			blocksite2[k][1] = i % 5;
  23. 			k++;
  24. 		}
  25. 	}
  26. 	// 找到改变朝向后，4个方块格的方块库坐标
  27. 	k = 0;
  28. 	bStyle = (player.blockStyle + 1)%BLOCKSTYLE;	// 获取改变朝向后的方块形状
  29. 	for(i = 0; i < BLOCKSPACE; i++)
  30. 	{
  31. 		// 得到4个方块坐标后，退出循环
  32. 		if(k > 3)
  33. 		{	
  34. 			break;
  35. 		}
  36. 		if(block[player.blockType][bStyle][i])
  37. 		{
  38. 			blocksite3[k][0] = i / 5;
  39. 			blocksite3[k][1] = i % 5;
  40. 			k++;
  41. 		}
  42. 	}
  43. 	// 根据改变前后方块坐标的位移矢量，得到改变朝向后的当前控制方块的新坐标
  44. 	for(i = 0; i < 4; i++)
  45. 	{
  46. 		ux = blocksite3[i][0] - blocksite2[i][0];	// 获取方格的X位移矢量
  47. 		uy = blocksite3[i][1] - blocksite2[i][1];	// 获取方格的Y位移矢量
  48.  
  49. 		blocksite4[i][0] = moveBlock.blockSite[i][0] + ux;	// 得到改变朝向后的，当前控制方块格，位于游戏地图的新X坐标
  50. 		blocksite4[i][1] = moveBlock.blockSite[i][1] + uy;	// 得到改变朝向后的，当前控制方块格，位于游戏地图的新Y坐标
  51. 		
  52. 		if( (blocksite4[i][0] < 0)					// 判断新坐标是否超出游戏地图，超出则终止改变方块朝向
  53. 			|| (blocksite4[i][1] < 0)
  54. 			|| (blocksite4[i][0] > TETRISHEIGHT - 1)
  55. 			|| (blocksite4[i][1] > TETRISWIDTH - 1)
  56. 			|| ( tetrisMap[blocksite4[i][0]][blocksite4[i][1]] ) )	// 如果新坐标在游戏地图中已存在方块格，则终止改变方块朝向
  57. 		{
  58. 			return;
  59. 		}
  60. 	}
  61. 	// 改变方块朝向没有问题，则更新新方块的坐标
  62. 	for(i = 0;i < 4; i++)
  63. 	{
  64. 		moveBlock.blockSite[i][0] = blocksite4[i][0];
  65. 		moveBlock.blockSite[i][1] = blocksite4[i][1];
  66. 	}
  67. 	player.blockStyle = bStyle;	// 更新方块格形状
  68.  
  69. }

// 找到4个方块格的方块库坐标
    k = 0;
    for(i = 0; i < BLOCKSPACE; i++)
    {
        // 得到4个方块坐标后，退出循环
        if(k > 3)
        {    
            break;
        }
        if(block[player.blockType][player.blockStyle][i])
        {
            blocksite2[k][0] = i / 5;
            blocksite2[k][1] = i % 5;
            k++;
        }
    }

1.根据当前控制方块的形状（朝向），在方块数据库中找到对应的坐标，并放入数组blocksite2中。

// 找到改变朝向后，4个方块格的方块库坐标
    k = 0;
    bStyle = (player.blockStyle + 1)%BLOCKSTYLE;    // 获取改变朝向后的方块形状
    for(i = 0; i < BLOCKSPACE; i++)
    {
        // 得到4个方块坐标后，退出循环
        if(k > 3)
        {    
            break;
        }
        if(block[player.blockType][bStyle][i])
        {
            blocksite3[k][0] = i / 5;
            blocksite3[k][1] = i % 5;
            k++;
        }
    }

2. player.blockStyle是当前方块的形状（朝向），只要把这个变量加1，再取余方块形状数，就可以得到新的方块形状（朝向）bStyle；根据方块类型，还有新的朝向bStyle，就可以从方块数据库中得到新方块的坐标，把新方块的坐标放入blocksite3[]数组。

// 根据改变前后方块坐标的位移矢量，得到改变朝向后的当前控制方块的新坐标
    for(i = 0; i < 4; i++)
    {
        ux = blocksite3[i][0] - blocksite2[i][0];    // 获取方格的X位移矢量
        uy = blocksite3[i][1] - blocksite2[i][1];    // 获取方格的Y位移矢量

        blocksite4[i][0] = moveBlock.blockSite[i][0] + ux;    // 得到改变朝向后的，当前控制方块格，位于游戏地图的新X坐标
        blocksite4[i][1] = moveBlock.blockSite[i][1] + uy;    // 得到改变朝向后的，当前控制方块格，位于游戏地图的新Y坐标
        
        if( (blocksite4[i][0] < 0)                    // 判断新坐标是否超出游戏地图，超出则终止改变方块朝向
            || (blocksite4[i][1] < 0)
            || (blocksite4[i][0] > TETRISHEIGHT - 1)
            || (blocksite4[i][1] > TETRISWIDTH - 1)
            || ( tetrisMap[blocksite4[i][0]][blocksite4[i][1]] ) )    // 如果新坐标在游戏地图中已存在方块格，则终止改变方块朝向
        {
            return;
        }
    }

3.既然通过1、2步骤，得到了方块改变形状前后，位于方块数据库中的坐标，那么就可以通过把新旧坐标相减，得到旧坐标的位移矢量ux，uy；

通过位移矢量ux，uy，还有当前方块的四个方块格坐标moveBlock.blockSite，就可以得到改变形状（朝向）后，当前方块的新坐标，并把新坐标放入blocksite4[][]数组中；

有了新坐标blocksite4，就可以判断当前方块是否可以改变形状（朝向），首先判断新坐标是否超过游戏地图范围，再判断新坐标位置，是否已经存在方块；只要有一个不符合，那么本次操作无效，退出函数。

// 改变方块朝向没有问题，则更新新方块的坐标
    for(i = 0;i < 4; i++)
    {
        moveBlock.blockSite[i][0] = blocksite4[i][0];
        moveBlock.blockSite[i][1] = blocksite4[i][1];
    }
    player.blockStyle = bStyle;    // 更新方块格形状

4.如果方块可以改变形状（朝向），那么就把方块的新坐标blocksite4，赋值给当前方块坐标moveBlock.blockSite；再把新的方块形状（朝向）bStyle，赋值给当前方块形状player.blockStyle

5.tetrisMoveDown() 函数

当方块下移标识player.moveFlag为1时，会执行本函数，控制当前方块下移。

player.moveFlag为1有两种条件

1：每个周期（默认500ms）会赋值为1。

2：用户按下S键，会赋值为1。

  1. void tetrisMoveDown(void)
  2. {
  3. 	int i;
  4. 	int x,y;
  5.  
  6. 	// 判断当前方块是否到达地图底部
  7. 	for(i = 0; i < 4; i++)
  8. 	{
  9. 		if(moveBlock.blockSite[i][0] > TETRISHEIGHT - 2)
  10. 		{
  11. 			// 如果到达地图底部，把生成新方块标识置1
  12. 			player.newBlockFlag = TRUE;
  13. 			return;
  14. 		}
  15. 	}
  16. 	// 判断当前方块能否下移,是否会和游戏地图已存在的方块产生冲突
  17. 	for(i = 0; i < 4; i++)
  18. 	{
  19. 		x = moveBlock.blockSite[i][0] + 1;	// 获取方块下移后的新X坐标
  20. 		y = moveBlock.blockSite[i][1];		// 获取方块下移后的新Y坐标
  21. 		// 如果新坐标在游戏地图中，已经存在方块格，则方块停止移动
  22. 		if(tetrisMap[x][y])
  23. 		{
  24. 			player.newBlockFlag = TRUE;
  25. 			return;
  26. 		}
  27. 	}
  28. 	// 当前方块下移
  29. 	for(i = 0; i < 4; i++)
  30. 	{
  31. 		moveBlock.blockSite[i][0]++;
  32. 	}
  33.  
  34. }

// 判断当前方块是否到达地图底部
    for(i = 0; i < 4; i++)
    {
        if(moveBlock.blockSite[i][0] > TETRISHEIGHT - 2)
        {
            // 如果到达地图底部，把生成新方块标识置1
            player.newBlockFlag = TRUE;
            return;
        }
    }

1.每次方块下移时，都会先判断方块是否到达游戏地图底部，如果到达底部，会给新方块标识player.newBlockFlag赋1，然后退出本函数，当前方块不再移动。

// 判断当前方块能否下移,是否会和游戏地图已存在的方块产生冲突
    for(i = 0; i < 4; i++)
    {
        x = moveBlock.blockSite[i][0] + 1;    // 获取方块下移后的新X坐标
        y = moveBlock.blockSite[i][1];        // 获取方块下移后的新Y坐标
        // 如果新坐标在游戏地图中，已经存在方块格，则方块停止移动
        if(tetrisMap[x][y])
        {
            player.newBlockFlag = TRUE;
            return;
        }
    }

2.方块下移会改变moveBlock.blockSite[][]数组的X坐标，加一；

判断游戏地图中新坐标位置是否已存在方块，如果存在方块，会给新方块标识player.newBlockFlag赋1，然后退出本函数，当前方块不再移动。

// 当前方块下移
    for(i = 0; i < 4; i++)
    {
        moveBlock.blockSite[i][0]++;
    }

3.方块可以下移，则将当前方块的4个方块格的X坐标都加一。

6.tetrisMoveLeft() 函数

每当用户按下A键，会执行本函数，控制当前方块左移。

  1. void tetrisMoveLeft(void)
  2. {
  3. 	int i;
  4. 	int x,y;
  5.  
  6. 	// 先判断是否能左移
  7. 	for(i = 0; i < 4; i++)
  8. 	{
  9. 		x = moveBlock.blockSite[i][0];
  10. 		y = moveBlock.blockSite[i][1];
  11. 		// 将Y坐标减一，再判断是否超出地图范围或引起冲突
  12. 		if( (y - 1) < 0				// 1.超出地图范围
  13. 			|| tetrisMap[x][y - 1])	// 2.方块将要移动的地方已存在方块格
  14. 		{
  15. 			return;	// 超出地图范围或冲突，无法左移
  16. 		}
  17. 	}
  18. 	// 左移
  19. 	for(i = 0; i < 4; i++)
  20. 	{
  21. 		moveBlock.blockSite[i][1]--;
  22. 	}
  23.  
  24. }

// 先判断是否能左移
    for(i = 0; i < 4; i++)
    {
        x = moveBlock.blockSite[i][0];
        y = moveBlock.blockSite[i][1];
        // 将Y坐标减一，再判断是否超出地图范围或引起冲突
        if( (y - 1) < 0                // 1.超出地图范围
            || tetrisMap[x][y - 1])    // 2.方块将要移动的地方已存在方块格
        {
            return;    // 超出地图范围或冲突，无法左移
        }
    }

1.方块左移，就是把方块的Y坐标减一，然后判断新的坐标是否超过游戏地图范围、新的坐标是否已经存在方块；只要有一个条件不满足，就会退出本函数，无法左移。

// 左移
    for(i = 0; i < 4; i++)
    {
        moveBlock.blockSite[i][1]--;
    }

 2.可以左移，则将当前方块的四个方块格的Y坐标都减一。

7.tetrisMoveRight() 函数

每当用户按下D键，会执行本函数，控制当前方块右移。

和左移函数基本相同，就是Y坐标变为加1，因此不再过多说明。

  1. void tetrisMoveRight(void)
  2. {
  3. 	int i;
  4. 	int x,y;
  5. 	//k = 0;
  6. 	// 先判断是否能右移
  7. 	for(i = 0; i < 4; i++)
  8. 	{
  9. 		x = moveBlock.blockSite[i][0];
  10. 		y = moveBlock.blockSite[i][1];
  11. 		// 将Y坐标加1，再判断是否超出地图范围或冲突
  12. 		if( ((y + 1) >= TETRISWIDTH)	// 1.超出地图范围
  13. 			|| (tetrisMap[x][y + 1]) )	// 2.方块将要移动的地方已存在方块格
  14. 		{
  15. 			return;	// 超出地图范围或冲突，无法左移
  16. 		}
  17. 	}
  18. 	// 右移
  19. 	for(i = 0; i < 4; i++)
  20. 	{
  21. 		moveBlock.blockSite[i][1]++;
  22. 	}
  23.  
  24. }

8.tetrisLoadBlock() 函数

每当新方块标识player.newBlockFlag为1时，执行本函数，将当前控制方块固定在游戏地图。

  1. void tetrisLoadBlock(void)
  2. {
  3. 	int i;
  4. 	int x,y;
  5.  
  6. 	// 将当前方块载入游戏地图
  7. 	for(i = 0; i < 4; i++)
  8. 	{
  9. 		x = moveBlock.blockSite[i][0];
  10. 		y = moveBlock.blockSite[i][1];
  11. 		// 只有游戏地图坐标不为空，才会改变游戏地图
  12. 		if(!tetrisMap[x][y])
  13. 		{
  14. 			tetrisMap[x][y] = moveBlock.blockColor;
  15. 		}
  16. 	}
  17. }

9.tetrisIsOver() 函数

每当新方块标识player.newBlockFlag为1时，执行本函数，判断游戏是否结束

  1. void tetrisIsOver(void)
  2. {
  3. 	int i;
  4. 	int x,y;
  5.  
  6. 	// 将新的移动方块与游戏地图比较，如果有冲突格，则游戏结束
  7. 	for(i = 0; i < 4; i++)
  8. 	{
  9. 		x = moveBlock.blockSite[i][0];
  10. 		y = moveBlock.blockSite[i][1];
  11. 		// 如果移动方块和游戏地图在同一坐标都存在方块，则游戏结束
  12. 		if(tetrisMap[x][y])
  13. 		{
  14. 			player.gameOverFlag = TRUE;
  15. 			tetrisDraw();
  16. 			tetrisQuit();
  17. 			return;
  18. 		}
  19. 	}
  20. }

将预生成方块载入游戏地图时，和游戏地图比较；预生成方块和游戏地图已存在的方块重叠，则预生成方块无法载入游戏地图，游戏无法继续，判断游戏结束。

将游戏结束标识player.gameOverFlag赋1，接着执行tetrisDraw()函数，绘制重叠方块；再执行tetrisQuit()函数，由用户选择是退出游戏还是重新开始游戏。

10.tetrisQuit() 函数

本函数执行有两种方式，一：游戏结束，玩家已无法再继续游戏。

二：玩家按下了ESC键，想要主动退出游戏。

  1. void tetrisQuit(void)
  2. {
  3. 	int key,flag;
  4. 	flag = player.gameOverFlag;
  5. 	// 让用户选择是否退出
  6. 	key = MessageBox(NULL,"是否退出游戏？","提示",MB_YESNO| MB_SYSTEMMODAL);
  7. 	switch(key)
  8. 	{
  9. 		case IDYES:
  10. 			player.gameOverFlag = TRUE;
  11. 			break;
  12. 		case IDNO:
  13. 			player.gameOverFlag = FALSE;
  14. 			break;
  15. 		default:
  16. 			break;
  17. 	}
  18. 	// 如果游戏已无法继续，且用户不退出游戏，则强制用户选择结束游戏，或重新开始游戏
  19. 	while(flag
  20. 		&& !player.gameOverFlag)
  21. 	{
  22. 		key = MessageBox(NULL,"检测到游戏已无法继续，\n请选择\"是\": 退出游戏；\n或者选择\"否\": 重启游戏；","提示",MB_YESNO| MB_SYSTEMMODAL);
  23. 		switch(key)
  24. 		{
  25. 			case IDYES:
  26. 				player.gameOverFlag = TRUE;
  27. 				break;
  28. 			case IDNO:
  29. 				tetrisInit();
  30. 				player.gameOverFlag = FALSE;
  31. 				return;
  32. 			default:
  33. 				break;
  34. 		}
  35. 	}
  36. 	CLEARKEY();	
  37. }

1.flag = player.gameOverFlag;
    // 让用户选择是否退出
    key = MessageBox(NULL,"是否退出游戏？","提示",MB_YESNO| MB_SYSTEMMODAL);
    switch(key)
    {
        case IDYES:
            player.gameOverFlag = TRUE;
            break;
        case IDNO:
            player.gameOverFlag = FALSE;
            break;
        default:
            break;
    }

1.flag标识用于区分是游戏结束，还是玩家主动结束游戏，不同方式有不同处理。

生成一个消息弹窗，MB_SYSTEMMODAL是强制弹窗置顶，功能类似于微信置顶功能。

key是用于得到用户选择“是”还是“否”，如果玩家选择退出游戏， 将游戏结束标识player.gameOverFlag置1；反之置0。

// 如果游戏已无法继续，且用户不退出游戏，则强制用户选择结束游戏，或重新开始游戏
    while(flag
        && !player.gameOverFlag)
    {
        key = MessageBox(NULL,"检测到游戏已无法继续，\n请选择\"是\": 退出游戏；\n或者选择\"否\": 重启游戏；","提示",MB_YESNO| MB_SYSTEMMODAL);
        switch(key)
        {
            case IDYES:
                player.gameOverFlag = TRUE;
                break;
            case IDNO:
                tetrisInit();
                player.gameOverFlag = FALSE;
                return;
            default:
                break;
        }
    }
    CLEARKEY();

2.如果是用户主动结束游戏，那么flag为0，不会进入循环；

如果是游戏已无法继续进行，那么flag为1，会进入循环。

如果进入循环，会生成一个消息弹窗，提示用户是退出游戏，还是重新开始游戏并获取用户选择结果。

通过key获取用户选择， 如果用户选择“是”，那么再次赋值player.gameOverFlag = TRUE，接着退出此函数。

如果用户选择“否”，那么会执行初始化函数tetrisInit()，并赋值player.gameOverFlag = FALSE;

重新开始游戏。

CLEARKEY();是一个宏定义，用于清除按键输入缓冲区。

11.tetrisKeyHandle() 函数

用户按键处理函数，每次用户按下相应按键后，都会执行本函数。

其中的W键改变方块形状（朝向）、A键左移、S键下移、D键右移、ESC退出键都已经在上面的函数说明了，这里就不再复述。

  1. void tetrisKeyHandle(void)
  2. {
  3. 	switch(player.key)
  4. 	{
  5. 		case 'w':
  6. 		case 'W':
  7. 			// W键，改变当前方块的朝向
  8. 			tetrisMoveUp();	
  9. 			break;
  10. 		case 'a':
  11. 		case 'A':
  12. 			// A键，当前方块想左移动
  13. 			tetrisMoveLeft();
  14. 			break;
  15. 		case 's':
  16. 		case 'S':
  17. 			// S键，当前方块向下移动
  18. 			player.moveFlag = TRUE;
  19. 			player.ttime = GetTickCount();
  20. 			return;
  21. 		case 'd':
  22. 		case 'D':
  23. 			// D键，当前方块向右移动
  24. 			tetrisMoveRight();
  25. 			break;
  26. 		case ESC:
  27. 			// 退出键，退出游戏
  28. 			tetrisQuit();
  29. 			break;
  30. 		case 'r':
  31. 		case 'R':
  32. 			// R键，重置游戏进度
  33. 			tetrisReset();
  34. 			break;
  35. 		default:
  36. 			break;
  37. 	}
  38. 	// 按键之后，刷新地图
  39. 	tetrisDraw();
  40. }

1.就剩一个R键重新开始游戏了；

按下R键后，会执行tetrisReset()函数，进行游戏重置，函数详情会在下一个函数说明。

12.tetrisReset() 函数

重置游戏函数，玩家按下R键后，可以选择是否重新开始游戏。

  1. void tetrisReset(void)
  2. {
  3. 	int key;
  4. 	key = MessageBox(NULL, "是否重新开始游戏？", "提示", MB_YESNO | MB_SYSTEMMODAL);
  5. 	CLEARKEY();
  6. 	switch (key)
  7. 	{
  8. 	case IDYES:
  9. 		tetrisInit();
  10. 		break;
  11. 	case IDNO:
  12. 		break;
  13. 	default:
  14. 		break;
  15. 	}
  16. }

生成一个置顶弹窗，用变量key获取用户点击的按钮（“是”“否”）；

如果用户点击的是“是”，则执行tetrisInit()函数，初始化所有游戏数据，重新开始游戏。

如果用户点击的是“否”，则取消重置游戏，本次按键无效。

13.tetrisRemove() 函数

最后一个函数，消除满行函数，每次生成新方块标识player.newBlockFlag置1时，会执行本函数。

  1. void tetrisRemove(void)
  2. {
  3. 	int i, j, m, n;
  4. 	int flag, bnum;
  5. 	bnum = 0;
  6.  
  7. 	// 从最下面一行开始，检测并消除满行方块
  8. 	for (i = TETRISHEIGHT - 1; i >= 0; i--)
  9. 	{
  10. 		flag = 0;
  11. 		for (j = 0; j < TETRISWIDTH; j++)
  12. 		{
  13. 			// 只要检测到空格，就不再检测本行
  14. 			if (!tetrisMap[i][j])
  15. 			{
  16. 				flag = 1;
  17. 				break;
  18. 			}
  19. 		}
  20. 		if (flag)
  21. 		{
  22. 			continue;
  23. 		}
  24. 		// 满行，消除行数加1
  25. 		bnum++;
  26. 		// 检测到满行，消除当前行
  27. 		for (j = 0; j < TETRISWIDTH; j++)
  28. 		{
  29. 			tetrisMap[i][j] = BLOCKNONE;
  30. 		}
  31. 		// 消除行上面的所有方块下移一行
  32. 		for (m = i; m > 0; m--)
  33. 		{
  34. 			for (n = 0; n < TETRISWIDTH; n++)
  35. 			{
  36. 				tetrisMap[m][n] = tetrisMap[m - 1][n];
  37. 			}
  38. 		}
  39. 		i++;		// 由于消除行上面的方块下移了，所以再从当前行检测
  40. 	}
  41.  
  42. 	// 消除行数为0，退出
  43. 	if (!bnum)
  44. 	{
  45. 		return;
  46. 	}
  47. 	// 根据消除的行数，增加RANK分数
  48. 	switch (bnum)
  49. 	{
  50. 	case 0:
  51. 		break;
  52. 	case 1:
  53. 		player.rank += 10;
  54. 		break;
  55. 	case 2:
  56. 		player.rank += 20;
  57. 		break;
  58. 	case 3:
  59. 		player.rank += 40;
  60. 		break;
  61. 	case 4:
  62. 		player.rank += 80;
  63. 		break;
  64. 	default:
  65. 		break;
  66. 	}
  67. 	// 根据rank分数换算成level
  68. 	player.level = player.rank / 100;
  69. 	if (player.level > 10)
  70. 	{
  71. 		player.level = 10;
  72. 	}
  73.  
  74. }

// 从最下面一行开始，检测并消除满行方块
    for (i = TETRISHEIGHT - 1; i >= 0; i--)
    {
        flag = 0;
        for (j = 0; j < TETRISWIDTH; j++)
        {
            // 只要检测到空格，就不再检测本行
            if (!tetrisMap[i][j])
            {
                flag = 1;
                break;
            }
        }
        if (flag)
        {
            continue;
        }
        // 满行，消除行数加1
        bnum++;
        // 检测到满行，消除当前行
        for (j = 0; j < TETRISWIDTH; j++)
        {
            tetrisMap[i][j] = BLOCKNONE;
        }
        // 消除行上面的所有方块下移一行
        for (m = i; m > 0; m--)
        {
            for (n = 0; n < TETRISWIDTH; n++)
            {
                tetrisMap[m][n] = tetrisMap[m - 1][n];
            }
        }
        i++;        // 由于消除行上面的方块下移了，所以再从当前行检测
    }

1.从游戏地图最下面一行开始检测，依次检测到最上面一行；只要检测到一个空白格，则放弃检测本行，检测上一行。

如果当前行是满行，则消除行数bnum加一；然后把当前行清零；清零后，把当前行上面的所有方块全部下移一行；i++是因为所有方块都下移一行了，需要再次从当前行开始检测。

// 消除行数为0，退出
    if (!bnum)
    {
        return;
    }
    // 根据消除的行数，增加RANK分数
    switch (bnum)
    {
    case 0:
        break;
    case 1:
        player.rank += 10;
        break;
    case 2:
        player.rank += 20;
        break;
    case 3:
        player.rank += 40;
        break;
    case 4:
        player.rank += 80;
        break;
    default:
        break;
    }
    // 根据rank分数换算成level
    player.level = player.rank / 100;
    if (player.level > 10)
    {
        player.level = 10;
    }

2.如果没有检测到可消除行（bnum为0），则退出本函数。

根据消除行数bnum，增加player.rank分数：

1行加10分；2行加20分；3行加40分；4行加80。

根据player.rank分数，换算成player.level等级：

1000分以下，等级是分数/100；1000分以上，等级固定为10（MAX）。

总结

至此，代码部分已经结束，从编写俄罗斯方块到结束，代码有经历过各种优化，bug也基本都修正了，可以说是一个比较完善的版本（基本没有BUG）。有任何疑问都可以在评论里提问，谢谢观看。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/604501
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号