Code666 (代码贴、代码片段)

[C++] 俄罗斯方块 →→→→→进入此内容的聊天室

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

回复 "俄罗斯方块"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666