我是一个C++初学者，控制台实现了一个俄罗斯方块游戏。

代码如下：

  1. //"俄罗斯方块"V1.0
  2. //李国良于2017年1月20日编写完成
  3. #include <iostream>
  4. #include <string>
  5. #include <ctime>
  6. #include <cstdlib>
  7. #include <windows.h>
  8. #include <conio.h>
  10. using namespace std;
  12. int block00[4][4] = { { 10,0,0,0 },{ 1,1,1,1 },{ 0,0,0,0 },{ 0,0,0,0 } };
  13. int block01[4][4] = { { 11,0,1,0 },{ 0,0,1,0 },{ 0,0,1,0 },{ 0,0,1,0 } };
  14. int block02[4][4] = { { 12,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 0,1,0,0 } };
  15. int block03[4][4] = { { 13,0,0,0 },{ 0,1,0,0 },{ 1,1,0,0 },{ 0,1,0,0 } };
  16. int block04[4][4] = { { 14,0,0,0 },{ 0,0,0,0 },{ 0,1,0,0 },{ 1,1,1,0 } };
  17. int block05[4][4] = { { 15,0,0,0 },{ 0,1,0,0 },{ 0,1,1,0 },{ 0,1,0,0 } };
  18. int block06[4][4] = { { 16,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 1,0,0,0 } };
  19. int block07[4][4] = { { 17,0,0,0 },{ 1,1,0,0 },{ 0,1,0,0 },{ 0,1,0,0 } };
  20. int block08[4][4] = { { 18,0,0,0 },{ 0,0,0,0 },{ 0,0,1,0 },{ 1,1,1,0 } };
  21. int block09[4][4] = { { 19,0,0,0 },{ 0,1,0,0 },{ 0,1,0,0 },{ 0,1,1,0 } };
  22. int block10[4][4] = { { 20,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 0,0,1,0 } };
  23. int block11[4][4] = { { 21,0,0,0 },{ 0,1,0,0 },{ 0,1,0,0 },{ 1,1,0,0 } };
  24. int block12[4][4] = { { 22,0,0,0 },{ 0,0,0,0 },{ 1,0,0,0 },{ 1,1,1,0 } };
  25. int block13[4][4] = { { 23,0,0,0 },{ 0,1,1,0 },{ 0,1,0,0 },{ 0,1,0,0 } };
  26. int block14[4][4] = { { 24,0,0,0 },{ 0,0,0,0 },{ 0,1,1,0 },{ 1,1,0,0 } };
  27. int block15[4][4] = { { 25,0,0,0 },{ 1,0,0,0 },{ 1,1,0,0 },{ 0,1,0,0 } };
  28. int block16[4][4] = { { 26,0,0,0 },{ 0,0,0,0 },{ 1,1,0,0 },{ 0,1,1,0 } };
  29. int block17[4][4] = { { 27,0,0,0 },{ 0,0,1,0 },{ 0,1,1,0 },{ 0,1,0,0 } };
  30. int block18[4][4] = { { 28,0,0,0 },{ 0,0,0,0 },{ 1,1,0,0 },{ 1,1,0,0 } };
  32. void initialWindow(HANDLE hOut);//初始化窗口
  33. void initialPrint(HANDLE hOut);//初始化界面
  34. void gotoXY(HANDLE hOut, int x, int y);//移动光标
  35. void roundBlock(HANDLE hOut, int block[4][4]);//随机生成方块并打印到下一个方块位置
  36. bool collisionDetection(int block[4][4], int map[21][12], int x, int y);//检测碰撞
  37. void printBlock(HANDLE hOut, int block[4][4], int x, int y);//打印方块
  38. void clearBlock(HANDLE hOut, int block[4][4], int x, int y);//消除方块
  39. void myLeft(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//左移
  40. void myRight(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//右移
  41. void myUp(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//顺时针旋转90度
  42. int myDown(HANDLE hOut, int block[4][4], int map[21][12], int &x, int y);//加速下落
  43. void myStop(HANDLE hOut, int block[4][4]);//游戏暂停
  44. void gameOver(HANDLE hOut, int block[4][4], int map[21][12]);//游戏结束
  45. void eliminateRow(HANDLE hOut, int map[21][12], int &val, int &fraction, int &checkpoint);//判断是否能消行并更新分值
  46. int main()
  47. {
  48. 	int map[21][12];
  49. 	int blockA[4][4];//候选区的方块
  50. 	int blockB[4][4];//下落中的方块
  51. 	int positionX, positionY;//方块左上角的坐标
  52. 	bool check;//检查方块还能不能下落
  53. 	char key;//用来存储按键
  54. 	int val;//用来控制下落速度
  55. 	int fraction;//用来存储得分
  56. 	int checkpoint;//用来存储关卡
  57. 	int times;
  58. 	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出设备句柄
  59. 	initialWindow(hOut);
  60. initial:
  61. 	gotoXY(hOut, 0, 0);
  62. 	initialPrint(hOut);
  63. 	check = true;
  64. 	val = 50;
  65. 	fraction = 0;
  66. 	checkpoint = 1;
  67. 	times = val;
  68. 	for (int i = 0; i < 20; ++i)
  69. 	{
  70. 		for (int j = 1; j < 11; ++j)
  71. 		{
  72. 			map[i][j] = 0;
  73. 		}
  74. 	}
  75. 	for (int i = 0; i < 20; ++i)
  76. 	{
  77. 		map[i][0] = map[i][11] = 1;
  78. 	}
  79. 	for (int i = 0; i < 12; ++i)
  80. 	{
  81. 		map[20][i] = 1;
  82. 	}
  84. 	srand((unsigned)time(NULL));
  85. 	roundBlock(hOut, blockA);
  86. 	while (true)
  87. 	{
  88. 		if (check)
  89. 		{
  90. 			eliminateRow(hOut, map, val, fraction, checkpoint);
  91. 			check = false;
  92. 			positionX = -3;
  93. 			positionY = 4;
  94. 			if (collisionDetection(blockA, map, positionX, positionY))
  95. 			{
  96. 				for (int i = 0; i < 4; ++i)
  97. 				{
  98. 					for (int j = 0; j < 4; ++j)
  99. 					{
  100. 						blockB[i][j] = blockA[i][j];
  101. 					}
  102. 				}
  103. 				roundBlock(hOut, blockA);
  104. 			}
  105. 			else
  106. 			{
  107. 				gameOver(hOut, blockA, map);
  108. 				goto initial;
  109. 			}
  110. 		}
  111. 		printBlock(hOut, blockB, positionX, positionY);
  112. 		if (_kbhit())
  113. 		{
  114. 			key = _getch();
  115. 			switch (key)
  116. 			{
  117. 			case 72:
  118. 				myUp(hOut, blockB, map, positionX, positionY);
  119. 				break;
  120. 			case 75:
  121. 				myLeft(hOut, blockB, map, positionX, positionY);
  122. 				break;
  123. 			case 77:
  124. 				myRight(hOut, blockB, map, positionX, positionY);
  125. 				break;
  126. 			case 80:
  127. 				switch (myDown(hOut, blockB, map, positionX, positionY))
  128. 				{
  129. 				case 0:
  130. 					check = false;
  131. 					break;
  132. 				case 1:
  133. 					check = true;
  134. 					break;
  135. 				case 2:
  136. 					gameOver(hOut, blockB, map);
  137. 					goto initial;
  138. 				default:
  139. 					break;
  140. 				}
  141. 				break;
  142. 			case 32:
  143. 				myStop(hOut, blockA);
  144. 				break;
  145. 			case 27:
  146. 				exit(0);
  147. 			default:
  148. 				break;
  149. 			}
  150. 		}
  151. 		Sleep(20);
  152. 		if (0 == --times)
  153. 		{
  154. 			switch (myDown(hOut, blockB, map, positionX, positionY))
  155. 			{
  156. 			case 0:
  157. 				check = false;
  158. 				break;
  159. 			case 1:
  160. 				check = true;
  161. 				break;
  162. 			case 2:
  163. 				gameOver(hOut, blockB, map);
  164. 				goto initial;
  165. 			default:
  166. 				break;
  167. 			}
  168. 			times = val;
  169. 		}
  170. 	}
  171. 	cin.get();
  172. 	return 0;
  173. }
  175. void initialWindow(HANDLE hOut)
  176. {
  177. 	SetConsoleTitle("俄罗斯方块");
  178. 	COORD size = { 80, 25 };
  179. 	SetConsoleScreenBufferSize(hOut, size);
  180. 	SMALL_RECT rc = { 0, 0, 79, 24 };
  181. 	SetConsoleWindowInfo(hOut, true, &rc);
  182. 	CONSOLE_CURSOR_INFO cursor_info = { 1, 0 };
  183. 	SetConsoleCursorInfo(hOut, &cursor_info);
  184. }
  186. void initialPrint(HANDLE hOut)
  187. {
  188. 	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  189. 	for (int i = 0; i < 20; ++i)
  190. 	{
  191. 		cout << "■                    ■☆                      ☆" << endl;
  192. 	}
  193. 	gotoXY(hOut, 26, 0);
  194. 	cout << "☆☆☆☆☆☆☆☆☆☆☆";
  195. 	gotoXY(hOut, 0, 20);
  196. 	cout << "■■■■■■■■■■■■☆☆☆☆☆☆☆☆☆☆☆☆☆";
  197. 	gotoXY(hOut, 26, 1);
  198. 	cout << "分    数：      ";
  199. 	gotoXY(hOut, 26, 2);
  200. 	cout << "关    卡：      ";
  201. 	gotoXY(hOut, 26, 4);
  202. 	cout << "下一方块：";
  203. 	gotoXY(hOut, 26, 9);
  204. 	cout << "操作方法：";
  205. 	gotoXY(hOut, 30, 11);
  206. 	cout << "↑：旋转 ↓：速降";
  207. 	gotoXY(hOut, 30, 12);
  208. 	cout << "→：右移 ←：左移";
  209. 	gotoXY(hOut, 30, 13);
  210. 	cout << "空格键：开始/暂停";
  211. 	gotoXY(hOut, 30, 14);
  212. 	cout << "Esc 键：退出";
  213. 	gotoXY(hOut, 26, 16);
  214. 	cout << "关    于：";
  215. 	gotoXY(hOut, 30, 18);
  216. 	cout << "俄罗斯方块V1.0";
  217. 	gotoXY(hOut, 35, 19);
  218. 	cout << "作者：李国良";
  219. }
  221. void gotoXY(HANDLE hOut, int x, int y)
  222. {
  223. 	COORD pos;
  224. 	pos.X = x;
  225. 	pos.Y = y;
  226. 	SetConsoleCursorPosition(hOut, pos);
  227. }
  229. void roundBlock(HANDLE hOut, int block[4][4])
  230. {
  231. 	clearBlock(hOut, block, 5, 15);
  232. 	switch (rand() % 19)
  233. 	{
  234. 	case 0:
  235. 		for (int i = 0; i < 4; ++i)
  236. 		{
  237. 			for (int j = 0; j < 4; ++j)
  238. 			{
  239. 				block[i][j] = block00[i][j];
  240. 			}
  241. 		}
  242. 		break;
  243. 	case 1:
  244. 		for (int i = 0; i < 4; ++i)
  245. 		{
  246. 			for (int j = 0; j < 4; ++j)
  247. 			{
  248. 				block[i][j] = block01[i][j];
  249. 			}
  250. 		}
  251. 		break;
  252. 	case 2:
  253. 		for (int i = 0; i < 4; ++i)
  254. 		{
  255. 			for (int j = 0; j < 4; ++j)
  256. 			{
  257. 				block[i][j] = block02[i][j];
  258. 			}
  259. 		}
  260. 		break;
  261. 	case 3:
  262. 		for (int i = 0; i < 4; ++i)
  263. 		{
  264. 			for (int j = 0; j < 4; ++j)
  265. 			{
  266. 				block[i][j] = block03[i][j];
  267. 			}
  268. 		}
  269. 		break;
  270. 	case 4:
  271. 		for (int i = 0; i < 4; ++i)
  272. 		{
  273. 			for (int j = 0; j < 4; ++j)
  274. 			{
  275. 				block[i][j] = block04[i][j];
  276. 			}
  277. 		}
  278. 		break;
  279. 	case 5:
  280. 		for (int i = 0; i < 4; ++i)
  281. 		{
  282. 			for (int j = 0; j < 4; ++j)
  283. 			{
  284. 				block[i][j] = block05[i][j];
  285. 			}
  286. 		}
  287. 		break;
  288. 	case 6:
  289. 		for (int i = 0; i < 4; ++i)
  290. 		{
  291. 			for (int j = 0; j < 4; ++j)
  292. 			{
  293. 				block[i][j] = block06[i][j];
  294. 			}
  295. 		}
  296. 		break;
  297. 	case 7:
  298. 		for (int i = 0; i < 4; ++i)
  299. 		{
  300. 			for (int j = 0; j < 4; ++j)
  301. 			{
  302. 				block[i][j] = block07[i][j];
  303. 			}
  304. 		}
  305. 		break;
  306. 	case 8:
  307. 		for (int i = 0; i < 4; ++i)
  308. 		{
  309. 			for (int j = 0; j < 4; ++j)
  310. 			{
  311. 				block[i][j] = block08[i][j];
  312. 			}
  313. 		}
  314. 		break;
  315. 	case 9:
  316. 		for (int i = 0; i < 4; ++i)
  317. 		{
  318. 			for (int j = 0; j < 4; ++j)
  319. 			{
  320. 				block[i][j] = block09[i][j];
  321. 			}
  322. 		}
  323. 		break;
  324. 	case 10:
  325. 		for (int i = 0; i < 4; ++i)
  326. 		{
  327. 			for (int j = 0; j < 4; ++j)
  328. 			{
  329. 				block[i][j] = block10[i][j];
  330. 			}
  331. 		}
  332. 		break;
  333. 	case 11:
  334. 		for (int i = 0; i < 4; ++i)
  335. 		{
  336. 			for (int j = 0; j < 4; ++j)
  337. 			{
  338. 				block[i][j] = block11[i][j];
  339. 			}
  340. 		}
  341. 		break;
  342. 	case 12:
  343. 		for (int i = 0; i < 4; ++i)
  344. 		{
  345. 			for (int j = 0; j < 4; ++j)
  346. 			{
  347. 				block[i][j] = block12[i][j];
  348. 			}
  349. 		}
  350. 		break;
  351. 	case 13:
  352. 		for (int i = 0; i < 4; ++i)
  353. 		{
  354. 			for (int j = 0; j < 4; ++j)
  355. 			{
  356. 				block[i][j] = block13[i][j];
  357. 			}
  358. 		}
  359. 		break;
  360. 	case 14:
  361. 		for (int i = 0; i < 4; ++i)
  362. 		{
  363. 			for (int j = 0; j < 4; ++j)
  364. 			{
  365. 				block[i][j] = block14[i][j];
  366. 			}
  367. 		}
  368. 		break;
  369. 	case 15:
  370. 		for (int i = 0; i < 4; ++i)
  371. 		{
  372. 			for (int j = 0; j < 4; ++j)
  373. 			{
  374. 				block[i][j] = block15[i][j];
  375. 			}
  376. 		}
  377. 		break;
  378. 	case 16:
  379. 		for (int i = 0; i < 4; ++i)
  380. 		{
  381. 			for (int j = 0; j < 4; ++j)
  382. 			{
  383. 				block[i][j] = block16[i][j];
  384. 			}
  385. 		}
  386. 		break;
  387. 	case 17:
  388. 		for (int i = 0; i < 4; ++i)
  389. 		{
  390. 			for (int j = 0; j < 4; ++j)
  391. 			{
  392. 				block[i][j] = block17[i][j];
  393. 			}
  394. 		}
  395. 		break;
  396. 	case 18:
  397. 		for (int i = 0; i < 4; ++i)
  398. 		{
  399. 			for (int j = 0; j < 4; ++j)
  400. 			{
  401. 				block[i][j] = block18[i][j];
  402. 			}
  403. 		}
  404. 		break;
  405. 	default:
  406. 		break;
  407. 	}
  408. 	printBlock(hOut, block, 5, 15);
  409. }
  411. bool collisionDetection(int block[4][4], int map[21][12], int x, int y)
  412. {
  413. 	for (int i = 0; i < 4; ++i)
  414. 	{
  415. 		for (int j = 0; j < 4; ++j)
  416. 		{
  417. 			if (x + i >= 0 && y + j >= 0 && map[x + i][y + j] == 1 && block[i][j] == 1)
  418. 			{
  419. 				return false;
  420. 			}
  421. 		}
  422. 	}
  423. 	return true;
  424. }
  426. void printBlock(HANDLE hOut, int block[4][4], int x, int y)
  427. {
  428. 	switch (block[0][0])
  429. 	{
  430. 	case 10:
  431. 	case 11:
  432. 		SetConsoleTextAttribute(hOut, FOREGROUND_GREEN);
  433. 		break;
  434. 	case 12:
  435. 	case 13:
  436. 	case 14:
  437. 	case 15:
  438. 		SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
  439. 		break;
  440. 	case 16:
  441. 	case 17:
  442. 	case 18:
  443. 	case 19:
  444. 		SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
  445. 		break;
  446. 	case 20:
  447. 	case 21:
  448. 	case 22:
  449. 	case 23:
  450. 		SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
  451. 		break;
  452. 	case 24:
  453. 	case 25:
  454. 		SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
  455. 		break;
  456. 	case 26:
  457. 	case 27:
  458. 		SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
  459. 		break;
  460. 	case 28:
  461. 		SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
  462. 		break;
  463. 	default:
  464. 		break;
  465. 	}
  466. 	for (int i = 0; i < 4; ++i)
  467. 	{
  468. 		if (i + x >= 0)
  469. 		{
  470. 			for (int j = 0; j < 4; ++j)
  471. 			{
  472. 				if (block[i][j] == 1)
  473. 				{
  475. 					gotoXY(hOut, 2 * (y + j), x + i);
  476. 					cout << "■";
  477. 				}
  478. 			}
  479. 		}
  480. 	}
  481. }
  483. void clearBlock(HANDLE hOut, int block[4][4], int x, int y)
  484. {
  485. 	for (int i = 0; i < 4; ++i)
  486. 	{
  487. 		if (i + x >= 0)
  488. 		{
  489. 			for (int j = 0; j < 4; ++j)
  490. 			{
  491. 				if (block[i][j] == 1)
  492. 				{
  493. 					gotoXY(hOut, 2 * (y + j), x + i);
  494. 					cout << "  ";
  495. 				}
  496. 			}
  497. 		}
  498. 	}
  499. }
  501. void gameOver(HANDLE hOut, int block[4][4], int map[21][12])
  502. {
  503. 	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
  504. 	gotoXY(hOut, 9, 8);
  505. 	cout << "GAME OVER";
  506. 	gotoXY(hOut, 8, 9);
  507. 	cout << "空格键：重来";
  508. 	gotoXY(hOut, 8, 10);
  509. 	cout << "ESC键：退出";
  510. 	char key;
  511. 	while (true)
  512. 	{
  513. 		key = _getch();
  514. 		if (key == 32)
  515. 		{
  516. 			return;
  517. 		}
  518. 		if (key == 27)
  519. 		{
  520. 			exit(0);
  521. 		}
  522. 	}
  523. }
  525. int myDown(HANDLE hOut, int block[4][4], int map[21][12], int &x, int y)
  526. {
  527. 	if (collisionDetection(block, map, x + 1, y))
  528. 	{
  529. 		clearBlock(hOut, block, x, y);
  530. 		++x;
  531. 		return 0;
  532. 	}
  533. 	if (x < 0)
  534. 	{
  535. 		return 2;
  536. 	}
  537. 	for (int i = 0; i < 4; ++i)
  538. 	{
  539. 		for (int j = 0; j < 4; ++j)
  540. 		{
  541. 			if (block[i][j] == 1)
  542. 			{
  543. 				map[x + i][y + j] = 1;
  544. 				SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
  545. 				gotoXY(hOut, 2 * (y + j), x + i);
  546. 				cout << "■";
  547. 			}
  548. 		}
  549. 	}
  550. 	return 1;
  551. }
  553. void myLeft(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
  554. {
  555. 	if (collisionDetection(block, map, x, y - 1))
  556. 	{
  557. 		clearBlock(hOut, block, x, y);
  558. 		--y;
  559. 	}
  560. }
  562. void myRight(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
  563. {
  564. 	if (collisionDetection(block, map, x, y + 1))
  565. 	{
  566. 		clearBlock(hOut, block, x, y);
  567. 		++y;
  568. 	}
  569. }
  571. void myUp(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
  572. {
  573. 	switch (block[0][0])
  574. 	{
  575. 	case 10:
  576. 		if (collisionDetection(block01, map, x, y))
  577. 		{
  578. 			clearBlock(hOut, block, x, y);
  579. 			for (int i = 0; i < 4; ++i)
  580. 			{
  581. 				for (int j = 0; j < 4; ++j)
  582. 				{
  583. 					block[i][j] = block01[i][j];
  584. 				}
  585. 			}
  586. 		}
  587. 		break;
  588. 	case 11:
  589. 		if (collisionDetection(block00, map, x, y))
  590. 		{
  591. 			clearBlock(hOut, block, x, y);
  592. 			for (int i = 0; i < 4; ++i)
  593. 			{
  594. 				for (int j = 0; j < 4; ++j)
  595. 				{
  596. 					block[i][j] = block00[i][j];
  597. 				}
  598. 			}
  599. 		}
  600. 		else if (collisionDetection(block00, map, x, y - 1))
  601. 		{
  602. 			clearBlock(hOut, block, x, y);
  603. 			for (int i = 0; i < 4; ++i)
  604. 			{
  605. 				for (int j = 0; j < 4; ++j)
  606. 				{
  607. 					block[i][j] = block00[i][j];
  608. 				}
  609. 			}
  610. 			--y;
  611. 		}
  612. 		else if (collisionDetection(block00, map, x, y + 1))
  613. 		{
  614. 			clearBlock(hOut, block, x, y);
  615. 			for (int i = 0; i < 4; ++i)
  616. 			{
  617. 				for (int j = 0; j < 4; ++j)
  618. 				{
  619. 					block[i][j] = block00[i][j];
  620. 				}
  621. 			}
  622. 			++y;
  623. 		}
  624. 		else if (collisionDetection(block00, map, x, y - 2))
  625. 		{
  626. 			clearBlock(hOut, block, x, y);
  627. 			for (int i = 0; i < 4; ++i)
  628. 			{
  629. 				for (int j = 0; j < 4; ++j)
  630. 				{
  631. 					block[i][j] = block00[i][j];
  632. 				}
  633. 			}
  634. 			y = y - 2;
  635. 		}
  636. 		else if (collisionDetection(block00, map, x, y + 2))
  637. 		{
  638. 			clearBlock(hOut, block, x, y);
  639. 			for (int i = 0; i < 4; ++i)
  640. 			{
  641. 				for (int j = 0; j < 4; ++j)
  642. 				{
  643. 					block[i][j] = block00[i][j];
  644. 				}
  645. 			}
  646. 			y = y + 2;
  647. 		}
  648. 		break;
  649. 	case 12:
  650. 		if (collisionDetection(block03, map, x, y))
  651. 		{
  652. 			clearBlock(hOut, block, x, y);
  653. 			for (int i = 0; i < 4; ++i)
  654. 			{
  655. 				for (int j = 0; j < 4; ++j)
  656. 				{
  657. 					block[i][j] = block03[i][j];
  658. 				}
  659. 			}
  660. 		}
  661. 		else if (collisionDetection(block03, map, x, y - 1))
  662. 		{
  663. 			clearBlock(hOut, block, x, y);
  664. 			for (int i = 0; i < 4; ++i)
  665. 			{
  666. 				for (int j = 0; j < 4; ++j)
  667. 				{
  668. 					block[i][j] = block03[i][j];
  669. 				}
  670. 			}
  671. 			--y;
  672. 		}
  673. 		else if (collisionDetection(block03, map, x, y + 1))
  674. 		{
  675. 			clearBlock(hOut, block, x, y);
  676. 			for (int i = 0; i < 4; ++i)
  677. 			{
  678. 				for (int j = 0; j < 4; ++j)
  679. 				{
  680. 					block[i][j] = block03[i][j];
  681. 				}
  682. 			}
  683. 			++y;
  684. 		}
  685. 		break;
  686. 	case 13:
  687. 		if (collisionDetection(block04, map, x, y))
  688. 		{
  689. 			clearBlock(hOut, block, x, y);
  690. 			for (int i = 0; i < 4; ++i)
  691. 			{
  692. 				for (int j = 0; j < 4; ++j)
  693. 				{
  694. 					block[i][j] = block04[i][j];
  695. 				}
  696. 			}
  697. 		}
  698. 		else if (collisionDetection(block04, map, x, y - 1))
  699. 		{
  700. 			clearBlock(hOut, block, x, y);
  701. 			for (int i = 0; i < 4; ++i)
  702. 			{
  703. 				for (int j = 0; j < 4; ++j)
  704. 				{
  705. 					block[i][j] = block04[i][j];
  706. 				}
  707. 			}
  708. 			--y;
  709. 		}
  710. 		else if (collisionDetection(block04, map, x, y + 1))
  711. 		{
  712. 			clearBlock(hOut, block, x, y);
  713. 			for (int i = 0; i < 4; ++i)
  714. 			{
  715. 				for (int j = 0; j < 4; ++j)
  716. 				{
  717. 					block[i][j] = block04[i][j];
  718. 				}
  719. 			}
  720. 			++y;
  721. 		}
  722. 		break;
  723. 	case 14:
  724. 		if (collisionDetection(block05, map, x, y))
  725. 		{
  726. 			clearBlock(hOut, block, x, y);
  727. 			for (int i = 0; i < 4; ++i)
  728. 			{
  729. 				for (int j = 0; j < 4; ++j)
  730. 				{
  731. 					block[i][j] = block05[i][j];
  732. 				}
  733. 			}
  734. 		}
  735. 		else if (collisionDetection(block05, map, x, y - 1))
  736. 		{
  737. 			clearBlock(hOut, block, x, y);
  738. 			for (int i = 0; i < 4; ++i)
  739. 			{
  740. 				for (int j = 0; j < 4; ++j)
  741. 				{
  742. 					block[i][j] = block05[i][j];
  743. 				}
  744. 			}
  745. 			--y;
  746. 		}
  747. 		else if (collisionDetection(block05, map, x, y + 1))
  748. 		{
  749. 			clearBlock(hOut, block, x, y);
  750. 			for (int i = 0; i < 4; ++i)
  751. 			{
  752. 				for (int j = 0; j < 4; ++j)
  753. 				{
  754. 					block[i][j] = block05[i][j];
  755. 				}
  756. 			}
  757. 			++y;
  758. 		}
  759. 		break;
  760. 	case 15:
  761. 		if (collisionDetection(block02, map, x, y))
  762. 		{
  763. 			clearBlock(hOut, block, x, y);
  764. 			for (int i = 0; i < 4; ++i)
  765. 			{
  766. 				for (int j = 0; j < 4; ++j)
  767. 				{
  768. 					block[i][j] = block02[i][j];
  769. 				}
  770. 			}
  771. 		}
  772. 		else if (collisionDetection(block02, map, x, y - 1))
  773. 		{
  774. 			clearBlock(hOut, block, x, y);
  775. 			for (int i = 0; i < 4; ++i)
  776. 			{
  777. 				for (int j = 0; j < 4; ++j)
  778. 				{
  779. 					block[i][j] = block02[i][j];
  780. 				}
  781. 			}
  782. 			--y;
  783. 		}
  784. 		else if (collisionDetection(block02, map, x, y + 1))
  785. 		{
  786. 			clearBlock(hOut, block, x, y);
  787. 			for (int i = 0; i < 4; ++i)
  788. 			{
  789. 				for (int j = 0; j < 4; ++j)
  790. 				{
  791. 					block[i][j] = block02[i][j];
  792. 				}
  793. 			}
  794. 			++y;
  795. 		}
  796. 		break;
  798. 	case 16:
  799. 		if (collisionDetection(block07, map, x, y))
  800. 		{
  801. 			clearBlock(hOut, block, x, y);
  802. 			for (int i = 0; i < 4; ++i)
  803. 			{
  804. 				for (int j = 0; j < 4; ++j)
  805. 				{
  806. 					block[i][j] = block07[i][j];
  807. 				}
  808. 			}
  809. 		}
  810. 		else if (collisionDetection(block07, map, x, y - 1))
  811. 		{
  812. 			clearBlock(hOut, block, x, y);
  813. 			for (int i = 0; i < 4; ++i)
  814. 			{
  815. 				for (int j = 0; j < 4; ++j)
  816. 				{
  817. 					block[i][j] = block07[i][j];
  818. 				}
  819. 			}
  820. 			--y;
  821. 		}
  822. 		else if (collisionDetection(block07, map, x, y + 1))
  823. 		{
  824. 			clearBlock(hOut, block, x, y);
  825. 			for (int i = 0; i < 4; ++i)
  826. 			{
  827. 				for (int j = 0; j < 4; ++j)
  828. 				{
  829. 					block[i][j] = block07[i][j];
  830. 				}
  831. 			}
  832. 			++y;
  833. 		}
  834. 		break;
  835. 	case 17:
  836. 		if (collisionDetection(block08, map, x, y))
  837. 		{
  838. 			clearBlock(hOut, block, x, y);
  839. 			for (int i = 0; i < 4; ++i)
  840. 			{
  841. 				for (int j = 0; j < 4; ++j)
  842. 				{
  843. 					block[i][j] = block08[i][j];
  844. 				}
  845. 			}
  846. 		}
  847. 		else if (collisionDetection(block08, map, x, y - 1))
  848. 		{
  849. 			clearBlock(hOut, block, x, y);
  850. 			for (int i = 0; i < 4; ++i)
  851. 			{
  852. 				for (int j = 0; j < 4; ++j)
  853. 				{
  854. 					block[i][j] = block08[i][j];
  855. 				}
  856. 			}
  857. 			--y;
  858. 		}
  859. 		else if (collisionDetection(block08, map, x, y + 1))
  860. 		{
  861. 			clearBlock(hOut, block, x, y);
  862. 			for (int i = 0; i < 4; ++i)
  863. 			{
  864. 				for (int j = 0; j < 4; ++j)
  865. 				{
  866. 					block[i][j] = block08[i][j];
  867. 				}
  868. 			}
  869. 			++y;
  870. 		}
  871. 		break;
  872. 	case 18:
  873. 		if (collisionDetection(block09, map, x, y))
  874. 		{
  875. 			clearBlock(hOut, block, x, y);
  876. 			for (int i = 0; i < 4; ++i)
  877. 			{
  878. 				for (int j = 0; j < 4; ++j)
  879. 				{
  880. 					block[i][j] = block09[i][j];
  881. 				}
  882. 			}
  883. 		}
  884. 		else if (collisionDetection(block09, map, x, y - 1))
  885. 		{
  886. 			clearBlock(hOut, block, x, y);
  887. 			for (int i = 0; i < 4; ++i)
  888. 			{
  889. 				for (int j = 0; j < 4; ++j)
  890. 				{
  891. 					block[i][j] = block09[i][j];
  892. 				}
  893. 			}
  894. 			--y;
  895. 		}
  896. 		else if (collisionDetection(block09, map, x, y + 1))
  897. 		{
  898. 			clearBlock(hOut, block, x, y);
  899. 			for (int i = 0; i < 4; ++i)
  900. 			{
  901. 				for (int j = 0; j < 4; ++j)
  902. 				{
  903. 					block[i][j] = block09[i][j];
  904. 				}
  905. 			}
  906. 			++y;
  907. 		}
  908. 		break;
  909. 	case 19:
  910. 		if (collisionDetection(block06, map, x, y))
  911. 		{
  912. 			clearBlock(hOut, block, x, y);
  913. 			for (int i = 0; i < 4; ++i)
  914. 			{
  915. 				for (int j = 0; j < 4; ++j)
  916. 				{
  917. 					block[i][j] = block06[i][j];
  918. 				}
  919. 			}
  920. 		}
  921. 		else if (collisionDetection(block06, map, x, y - 1))
  922. 		{
  923. 			clearBlock(hOut, block, x, y);
  924. 			for (int i = 0; i < 4; ++i)
  925. 			{
  926. 				for (int j = 0; j < 4; ++j)
  927. 				{
  928. 					block[i][j] = block06[i][j];
  929. 				}
  930. 			}
  931. 			--y;
  932. 		}
  933. 		else if (collisionDetection(block06, map, x, y + 1))
  934. 		{
  935. 			clearBlock(hOut, block, x, y);
  936. 			for (int i = 0; i < 4; ++i)
  937. 			{
  938. 				for (int j = 0; j < 4; ++j)
  939. 				{
  940. 					block[i][j] = block06[i][j];
  941. 				}
  942. 			}
  943. 			++y;
  944. 		}
  945. 		break;
  946. 	case 20:
  947. 		if (collisionDetection(block11, map, x, y))
  948. 		{
  949. 			clearBlock(hOut, block, x, y);
  950. 			for (int i = 0; i < 4; ++i)
  951. 			{
  952. 				for (int j = 0; j < 4; ++j)
  953. 				{
  954. 					block[i][j] = block11[i][j];
  955. 				}
  956. 			}
  957. 		}
  958. 		else if (collisionDetection(block11, map, x, y - 1))
  959. 		{
  960. 			clearBlock(hOut, block, x, y);
  961. 			for (int i = 0; i < 4; ++i)
  962. 			{
  963. 				for (int j = 0; j < 4; ++j)
  964. 				{
  965. 					block[i][j] = block11[i][j];
  966. 				}
  967. 			}
  968. 			--y;
  969. 		}
  970. 		else if (collisionDetection(block11, map, x, y + 1))
  971. 		{
  972. 			clearBlock(hOut, block, x, y);
  973. 			for (int i = 0; i < 4; ++i)
  974. 			{
  975. 				for (int j = 0; j < 4; ++j)
  976. 				{
  977. 					block[i][j] = block11[i][j];
  978. 				}
  979. 			}
  980. 			++y;
  981. 		}
  982. 		break;
  983. 	case 21:
  984. 		if (collisionDetection(block12, map, x, y))
  985. 		{
  986. 			clearBlock(hOut, block, x, y);
  987. 			for (int i = 0; i < 4; ++i)
  988. 			{
  989. 				for (int j = 0; j < 4; ++j)
  990. 				{
  991. 					block[i][j] = block12[i][j];
  992. 				}
  993. 			}
  994. 		}
  995. 		else if (collisionDetection(block12, map, x, y - 1))
  996. 		{
  997. 			clearBlock(hOut, block, x, y);
  998. 			for (int i = 0; i < 4; ++i)
  999. 			{
  1000. 				for (int j = 0; j < 4; ++j)
  1001. 				{
  1002. 					block[i][j] = block12[i][j];
  1003. 				}
  1004. 			}
  1005. 			--y;
  1006. 		}
  1007. 		else if (collisionDetection(block12, map, x, y + 1))
  1008. 		{
  1009. 			clearBlock(hOut, block, x, y);
  1010. 			for (int i = 0; i < 4; ++i)
  1011. 			{
  1012. 				for (int j = 0; j < 4; ++j)
  1013. 				{
  1014. 					block[i][j] = block12[i][j];
  1015. 				}
  1016. 			}
  1017. 			++y;
  1018. 		}
  1019. 		break;
  1020. 	case 22:
  1021. 		if (collisionDetection(block13, map, x, y))
  1022. 		{
  1023. 			clearBlock(hOut, block, x, y);
  1024. 			for (int i = 0; i < 4; ++i)
  1025. 			{
  1026. 				for (int j = 0; j < 4; ++j)
  1027. 				{
  1028. 					block[i][j] = block13[i][j];
  1029. 				}
  1030. 			}
  1031. 		}
  1032. 		else if (collisionDetection(block13, map, x, y - 1))
  1033. 		{
  1034. 			clearBlock(hOut, block, x, y);
  1035. 			for (int i = 0; i < 4; ++i)
  1036. 			{
  1037. 				for (int j = 0; j < 4; ++j)
  1038. 				{
  1039. 					block[i][j] = block13[i][j];
  1040. 				}
  1041. 			}
  1042. 			--y;
  1043. 		}
  1044. 		else if (collisionDetection(block13, map, x, y + 1))
  1045. 		{
  1046. 			clearBlock(hOut, block, x, y);
  1047. 			for (int i = 0; i < 4; ++i)
  1048. 			{
  1049. 				for (int j = 0; j < 4; ++j)
  1050. 				{
  1051. 					block[i][j] = block13[i][j];
  1052. 				}
  1053. 			}
  1054. 			++y;
  1055. 		}
  1056. 		break;
  1057. 	case 23:
  1058. 		if (collisionDetection(block10, map, x, y))
  1059. 		{
  1060. 			clearBlock(hOut, block, x, y);
  1061. 			for (int i = 0; i < 4; ++i)
  1062. 			{
  1063. 				for (int j = 0; j < 4; ++j)
  1064. 				{
  1065. 					block[i][j] = block10[i][j];
  1066. 				}
  1067. 			}
  1068. 		}
  1069. 		else if (collisionDetection(block10, map, x, y - 1))
  1070. 		{
  1071. 			clearBlock(hOut, block, x, y);
  1072. 			for (int i = 0; i < 4; ++i)
  1073. 			{
  1074. 				for (int j = 0; j < 4; ++j)
  1075. 				{
  1076. 					block[i][j] = block10[i][j];
  1077. 				}
  1078. 			}
  1079. 			--y;
  1080. 		}
  1081. 		else if (collisionDetection(block10, map, x, y + 1))
  1082. 		{
  1083. 			clearBlock(hOut, block, x, y);
  1084. 			for (int i = 0; i < 4; ++i)
  1085. 			{
  1086. 				for (int j = 0; j < 4; ++j)
  1087. 				{
  1088. 					block[i][j] = block10[i][j];
  1089. 				}
  1090. 			}
  1091. 			++y;
  1092. 		}
  1093. 		break;
  1094. 	case 24:
  1095. 		if (collisionDetection(block15, map, x, y))
  1096. 		{
  1097. 			clearBlock(hOut, block, x, y);
  1098. 			for (int i = 0; i < 4; ++i)
  1099. 			{
  1100. 				for (int j = 0; j < 4; ++j)
  1101. 				{
  1102. 					block[i][j] = block15[i][j];
  1103. 				}
  1104. 			}
  1105. 		}
  1106. 		else if (collisionDetection(block15, map, x, y - 1))
  1107. 		{
  1108. 			clearBlock(hOut, block, x, y);
  1109. 			for (int i = 0; i < 4; ++i)
  1110. 			{
  1111. 				for (int j = 0; j < 4; ++j)
  1112. 				{
  1113. 					block[i][j] = block15[i][j];
  1114. 				}
  1115. 			}
  1116. 			--y;
  1117. 		}
  1118. 		else if (collisionDetection(block15, map, x, y + 1))
  1119. 		{
  1120. 			clearBlock(hOut, block, x, y);
  1121. 			for (int i = 0; i < 4; ++i)
  1122. 			{
  1123. 				for (int j = 0; j < 4; ++j)
  1124. 				{
  1125. 					block[i][j] = block15[i][j];
  1126. 				}
  1127. 			}
  1128. 			++y;
  1129. 		}
  1130. 		break;
  1131. 	case 25:
  1132. 		if (collisionDetection(block14, map, x, y))
  1133. 		{
  1134. 			clearBlock(hOut, block, x, y);
  1135. 			for (int i = 0; i < 4; ++i)
  1136. 			{
  1137. 				for (int j = 0; j < 4; ++j)
  1138. 				{
  1139. 					block[i][j] = block14[i][j];
  1140. 				}
  1141. 			}
  1142. 		}
  1143. 		else if (collisionDetection(block14, map, x, y - 1))
  1144. 		{
  1145. 			clearBlock(hOut, block, x, y);
  1146. 			for (int i = 0; i < 4; ++i)
  1147. 			{
  1148. 				for (int j = 0; j < 4; ++j)
  1149. 				{
  1150. 					block[i][j] = block14[i][j];
  1151. 				}
  1152. 			}
  1153. 			--y;
  1154. 		}
  1155. 		else if (collisionDetection(block14, map, x, y + 1))
  1156. 		{
  1157. 			clearBlock(hOut, block, x, y);
  1158. 			for (int i = 0; i < 4; ++i)
  1159. 			{
  1160. 				for (int j = 0; j < 4; ++j)
  1161. 				{
  1162. 					block[i][j] = block14[i][j];
  1163. 				}
  1164. 			}
  1165. 			++y;
  1166. 		}
  1167. 		break;
  1168. 	case 26:
  1169. 		if (collisionDetection(block17, map, x, y))
  1170. 		{
  1171. 			clearBlock(hOut, block, x, y);
  1172. 			for (int i = 0; i < 4; ++i)
  1173. 			{
  1174. 				for (int j = 0; j < 4; ++j)
  1175. 				{
  1176. 					block[i][j] = block17[i][j];
  1177. 				}
  1178. 			}
  1179. 		}
  1180. 		else if (collisionDetection(block17, map, x, y - 1))
  1181. 		{
  1182. 			clearBlock(hOut, block, x, y);
  1183. 			for (int i = 0; i < 4; ++i)
  1184. 			{
  1185. 				for (int j = 0; j < 4; ++j)
  1186. 				{
  1187. 					block[i][j] = block17[i][j];
  1188. 				}
  1189. 			}
  1190. 			--y;
  1191. 		}
  1192. 		else if (collisionDetection(block17, map, x, y + 1))
  1193. 		{
  1194. 			clearBlock(hOut, block, x, y);
  1195. 			for (int i = 0; i < 4; ++i)
  1196. 			{
  1197. 				for (int j = 0; j < 4; ++j)
  1198. 				{
  1199. 					block[i][j] = block17[i][j];
  1200. 				}
  1201. 			}
  1202. 			++y;
  1203. 		}
  1204. 		break;
  1205. 	case 27:
  1206. 		if (collisionDetection(block16, map, x, y))
  1207. 		{
  1208. 			clearBlock(hOut, block, x, y);
  1209. 			for (int i = 0; i < 4; ++i)
  1210. 			{
  1211. 				for (int j = 0; j < 4; ++j)
  1212. 				{
  1213. 					block[i][j] = block16[i][j];
  1214. 				}
  1215. 			}
  1216. 		}
  1217. 		else if (collisionDetection(block16, map, x, y - 1))
  1218. 		{
  1219. 			clearBlock(hOut, block, x, y);
  1220. 			for (int i = 0; i < 4; ++i)
  1221. 			{
  1222. 				for (int j = 0; j < 4; ++j)
  1223. 				{
  1224. 					block[i][j] = block16[i][j];
  1225. 				}
  1226. 			}
  1227. 			--y;
  1228. 		}
  1229. 		else if (collisionDetection(block16, map, x, y + 1))
  1230. 		{
  1231. 			clearBlock(hOut, block, x, y);
  1232. 			for (int i = 0; i < 4; ++i)
  1233. 			{
  1234. 				for (int j = 0; j < 4; ++j)
  1235. 				{
  1236. 					block[i][j] = block16[i][j];
  1237. 				}
  1238. 			}
  1239. 			++y;
  1240. 		}
  1241. 		break;
  1242. 	default:
  1243. 		break;
  1244. 	}
  1245. }
  1247. void myStop(HANDLE hOut, int block[4][4])
  1248. {
  1249. 	clearBlock(hOut, block, 5, 15);
  1250. 	SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
  1251. 	gotoXY(hOut, 30, 7);
  1252. 	cout << "游戏暂停";
  1253. 	char key;
  1254. 	while (true)
  1255. 	{
  1256. 		key = _getch();
  1257. 		if (key == 32)
  1258. 		{
  1259. 			gotoXY(hOut, 30, 7);
  1260. 			cout << "        ";
  1261. 			printBlock(hOut, block, 5, 15);
  1262. 			return;
  1263. 		}
  1264. 		if (key == 27)
  1265. 		{
  1266. 			exit(0);
  1267. 		}
  1268. 	}
  1269. }
  1271. void eliminateRow(HANDLE hOut, int map[21][12], int &val, int &fraction, int &checkpoint)
  1272. {
  1273. 	SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
  1274. 	for (int i = 19; i >= 0; --i)
  1275. 	{
  1276. 		int x = 0;
  1277. 		for (int j = 1; j < 11; ++j)
  1278. 		{
  1279. 			x += map[i][j];
  1280. 		}
  1281. 		if (x == 10)
  1282. 		{
  1283. 			fraction += 100;
  1284. 			if (val > 1 && fraction / 1000 + 1 != checkpoint)
  1285. 			{
  1286. 				checkpoint = fraction / 1000 + 1;
  1287. 				val -= 5;
  1288. 			}
  1289. 			for (int m = i; m > 0; --m)
  1290. 			{
  1291. 				for (int n = 1; n < 11; ++n)
  1292. 				{
  1293. 					map[m][n] = map[m - 1][n];
  1294. 					gotoXY(hOut, 2 * n, m);
  1295. 					if (map[m][n] == 1)
  1296. 					{
  1297. 						cout << "■";
  1298. 					}
  1299. 					else
  1300. 					{
  1301. 						cout << "  ";
  1302. 					}
  1303. 				}
  1304. 			}
  1305. 			++i;
  1306. 		}
  1307. 	}
  1308. 	gotoXY(hOut, 36, 1);
  1309. 	cout << fraction;
  1310. 	gotoXY(hOut, 36, 2);
  1311. 	cout << checkpoint;
  1312. }

用C++实现俄罗斯方块(Tetris)游戏的更多相关文章

  1. 俄罗斯方块 Tetris

    今天,为大家带来一个用Qt C++ (Windows环境下)做的一个简易俄罗斯方块小游戏 思路和模块介绍都在注释里面,其次就是一些项目中遇到的问题以及解决方案,在后面部分说明. 一.效果 测试图样 Q ...

  2. C#俄罗斯方块小游戏程序设计与简单实现

    C#俄罗斯方块小游戏程序设计与简单实现 相信90后或者80后都玩过这款小游戏,一直想干一票,琢磨一下,但又不太懂,于是网上搜集修改就有了以下效果!bug较多,多多包涵! 1.效果展示 2.实现方法 参 ...

  3. js实现简单的俄罗斯方块小游戏

    js实现简单的俄罗斯方块小游戏 开始 1. 创建一个宽为 200px,高为 360px 的背景容器 <!DOCTYPE html> <html lang="en" ...

  4. H5版俄罗斯方块(3)---游戏的AI算法

    前言: 算是"long long ago"的事了, 某著名互联网公司在我校举行了一次"lengend code"的比赛, 其中有一题就是"智能俄罗斯方 ...

  5. H5版俄罗斯方块(2)---游戏的基本框架和实现

    前言: 上文中谈到了H5版俄罗斯方块的需求和目标, 这次要实现一个可玩的版本. 但饭要一口一口吃, 很多东西并非一蹴而就. 本文将简单实现一个可玩的俄罗斯方块版本. 下一步会引入AI, 最终采用coc ...

  6. Java课设--俄罗斯方块Tetris

    Java程序设计课程作业报告 作业:俄罗斯方块游戏 姓名 赵璐媛 学号 程序得分 90% 作业报告 得分10% 实验总分 100% 作业目的: 掌握基本的图形程序设计方法 掌握Java事件处理程序编写 ...

  7. C语言编程学习开发的俄罗斯方块小游戏

    C语言是面向过程的,而C++是面向对象的 C和C++的区别: C是一个结构化语言,它的重点在于算法和数据结构.C程序的设计首要考虑的是如何通过一个过程,对输入(或环境条件)进行运算处理得到输出(或实现 ...

  8. 【补档STM32】STM32F103俄罗斯方块游戏实现

    项目地址:https://gitee.com/daycen/stm32-tetris/tree/master 使用Keil uVision5打开即可 一.概述 ​ 本文介绍了一个基于STM32的俄罗斯 ...

  9. Javascript写俄罗斯方块游戏

    俄罗斯方块这个游戏也做了移动端的兼容, 这个游戏难点是怎么翻转方块, 自己实现的方式是把方块放到一个二维数组, 然后逆时针旋转二维数组. 也有别的方法,比如直接用一个全局变量代表一个方向, 翻转的时候 ...

随机推荐

  1. P5287-[HNOI2019]JOJO【KMP】

    正题 题目链接:https://www.luogu.com.cn/problem/P5287 题目大意 开始一个空串,\(n\)个操作 在末尾加入\(x\)个\(c\)字符(保证和\(c\)和前面的字 ...

  2. python numpy loadtxt

    用numpy加载csv文件数据 发现python numpy loadtxt 方法和数据的结构有很大关系当我的数据有第一行文字是这样子的时候 我程序的运行结果永远都报错,编码格式也处理了统一utf-8 ...

  3. maven插件maven-install-plugin

    maven-install-plugin负责将获取的jar包安装到本地仓库 <build> <plugin> <groupId>org.apache.maven.p ...

  4. Python列表操作常用API

    1.列表的概念 (1)列表的定义 列表是Python中一种基本的数据结构.列表存储的数据,我们称为元素.在列表中的每个元素都会有一个下标来与之对应,第一个索引是0,第二个索引是1,依此类推的整数. 列 ...

  5. 3.docker容器常用命令

    docker容器的常用命令 docker有很多命令,让我们一个一个全部背下来,基本是不可能的,帮助文档的作用就很大了,想要查询那个命令,直接去找帮助文档,帮助文档地址:https://docs.doc ...

  6. 这两个基础seo插件，wordpress网站必装

    WordPress对搜索引擎非常友好,这一点很多人都知道.不过我们在制作完成WordPress主题后,还可以在原来的良好基础上,添加两个队seo非常有利的WordPress插件. 第一个插件:Baid ...

  7. 使用python -m pip install 和 pip install 安装包有什么区别？

    如果去看源码的话,你会发现 pip 作为执行文件的入口点是 pip._internal.main. 另一方面,pip 作为模块运行时入口是 _main.py,而该模块也只是调用 pip.interna ...

  8. Centos7最小安装后快速初始化脚本

    功能说明 服务器通常使用最小化安装操作系统,使用该脚本可快速初始化一些基本配置,包括以下: 1.ssh修改默认端口 2.ssh禁止root登陆 3.selinux及firewalld禁用 4.hist ...

  9. Java初步学习——2021.10.09每日总结，第五周周六

    (1)今天做了什么: (2)明天准备做什么? (3)遇到的问题,如何解决? 今天学习了菜鸟教程实例部分 一.字符串 1.字符串比较--compareTo方法 public class Main { p ...

  10. 2021.7.27--Benelux Algorithm Programming Contest 2020 补提

    I Jigsaw 题目内容: 链接:https://ac.nowcoder.com/acm/contest/18454/I 来源:牛客网 You have found an old jigsaw pu ...