SaveText.Ru

tetraminovkonsole4ke
  1. #include <iostream>
  2. #include <ctime>
  3. #include <cstdlib>
  4. #include <conio.h>
  5. #include <windows.h>
  6. using namespace std;
  7.  
  8. static char block = 219, space = 176, failBlock = 178;
  9. short difficulty, xNull, yNull, timer;
  10. short nextF = (rand() % 19);
  11. unsigned short score;
  12. char field[10][20];
  13. short newF;
  14. bool gameOver, workOver = 1, failOver;
  15.  
  16. short rotate(short f)
  17. {
  18.         short answer;
  19.         switch (f)
  20.         {
  21.         case 0:
  22.                 answer = 0;
  23.                 break;
  24.         case 1:
  25.                 answer = 2;
  26.                 break;
  27.         case 2:
  28.                 answer = 1;
  29.                 break;
  30.         case 3:
  31.                 answer = 4;
  32.                 break;
  33.         case 4:
  34.                 answer = 5;
  35.                 break;
  36.         case 5:
  37.                 answer = 6;
  38.                 break;
  39.         case 6:
  40.                 answer = 3;
  41.                 break;
  42.         case 7:
  43.                 answer = 8;
  44.                 break;
  45.         case 8:
  46.                 answer = 9;
  47.                 break;
  48.         case 9:
  49.                 answer = 10;
  50.                 break;
  51.         case 10:
  52.                 answer = 7;
  53.                 break;
  54.         case 11:
  55.                 answer = 12;
  56.                 break;
  57.         case 12:
  58.                 answer = 11;
  59.                 break;
  60.         case 13:
  61.                 answer = 14;
  62.                 break;
  63.         case 14:
  64.                 answer = 13;
  65.                 break;
  66.         case 15:
  67.                 answer = 18;
  68.                 break;
  69.         case 16:
  70.                 answer = 17;
  71.                 break;
  72.         case 17:
  73.                 answer = 15;
  74.                 break;
  75.         case 18:
  76.                 answer = 16;
  77.                 break;
  78.         }
  79.         return answer;
  80. }
  81.  
  82. void failCleaner()
  83. {
  84.         for (short y = 0; y < 20; y++)
  85.         {
  86.                 for (short x = 0; x < 10; x++)
  87.                 {
  88.                         if (field[x][y] == failBlock)
  89.                         {
  90.                                 field[x][y] = space;
  91.                         }
  92.                 }
  93.         }
  94. }
  95. // удаление всех падающих блоков
  96.  
  97. void newFrame()
  98. {
  99.  
  100.         system("cls");
  101.         cout << "score: " << score << "n" << endl;
  102.         for (short y = 19; y >= 0; y--)
  103.         {
  104.                 for (short x = 0; x < 10; x++)
  105.                 {
  106.                         cout << field[x][y];
  107.                 }
  108.                 cout << endl;
  109.         }
  110. }
  111. // отрисовка нового кадра
  112.  
  113. class figure
  114. {
  115. private:
  116.         short pixel[4][2]; // второй аргумент  1=y 0=x
  117.  
  118. public:
  119.         void set(short p0, short p1, short p2, short p3)
  120.         {
  121.                 //y
  122.                 pixel[0][1] = p0 % 10;
  123.                 pixel[1][1] = p1 % 10;
  124.                 pixel[2][1] = p2 % 10;
  125.                 pixel[3][1] = p3 % 10;
  126.                 //x
  127.                 pixel[0][0] = p0 / 10;
  128.                 pixel[1][0] = p1 / 10;
  129.                 pixel[2][0] = p2 / 10;
  130.                 pixel[3][0] = p3 / 10;
  131.         }
  132.  
  133.         void create()
  134.         {
  135.                 for (short i = 0; i < 4; i++)
  136.                 {
  137.                         field[xNull + pixel[i][0]][yNull + pixel[i][1]] = failBlock;
  138.                 }
  139.         }
  140.  
  141.         bool check_action(short setAction)
  142.         {
  143.                 switch (setAction)
  144.                 {
  145.                 case 72:
  146.                         for (short i = 0; i < 4; i++)
  147.                         {
  148.                                 if ((field[xNull + pixel[i][0]][yNull + pixel[i][1]] == block) || (xNull + pixel[i][0] > 9))
  149.                                 {
  150.                                         return 0;
  151.                                 }
  152.                         }
  153.                         return 1;
  154.                         break;
  155.                 case 80://down                        
  156.                         for (short i = 0; i < 4; i++)
  157.                         {
  158.                                 if ((field[xNull + pixel[i][0]][yNull + pixel[i][1] - 1] == block) ||
  159.                                         (yNull == 0))
  160.                                 {
  161.                                         return 0;
  162.                                 }
  163.                         }
  164.                         return 1;
  165.                         break;
  166.                 case 75://left
  167.  
  168.                         for (short i = 0; i < 4; i++)
  169.                         {
  170.                                 if ((field[xNull + pixel[i][0] - 1][yNull + pixel[i][1]] == block) || (xNull - 1 < 0))
  171.                                 {
  172.                                         return 0;
  173.                                 }
  174.                         }
  175.                         return 1;
  176.                         break;
  177.                 case 77://right
  178.  
  179.                         for (short i = 0; i < 4; i++)
  180.                         {
  181.                                 if ((field[xNull + pixel[i][0] + 1][yNull + pixel[i][1]] == block) || (xNull + 1 + pixel[i][0] > 9))
  182.                                 {
  183.                                         return 0;
  184.                                 }
  185.                         }
  186.                         return 1;
  187.                         break;
  188.                 }
  189.  
  190.         }
  191.  
  192.         void action(short setAction)
  193.         {
  194.                 switch (setAction)
  195.                 {
  196.                 case 75://left
  197.                         failCleaner();
  198.                         --xNull;
  199.                         for (short i = 0; i < 4; i++)
  200.                         {
  201.                                 field[xNull + pixel[i][0]][yNull + pixel[i][1]] = failBlock;
  202.                         }
  203.                         //field[xNull][yNull] = '0';
  204.                         break;
  205.                 case 77://right
  206.                         failCleaner();
  207.                         ++xNull;
  208.                         for (short i = 0; i < 4; i++)
  209.                         {
  210.                                 field[xNull + pixel[i][0]][yNull + pixel[i][1]] = failBlock;
  211.                         }
  212.                         //field[xNull][yNull] = '0';
  213.                         break;
  214.                 case 80://down
  215.                         failCleaner();
  216.                         --yNull;
  217.                         for (short i = 0; i < 4; i++)
  218.                         {
  219.                                 field[xNull + pixel[i][0]][yNull + pixel[i][1]] = failBlock;
  220.                         }
  221.                         //field[xNull][yNull] = '0';
  222.                         break;
  223.                 case 72://rotate
  224.                         failCleaner();
  225.                         newF = rotate(newF);
  226.                         create();
  227.                         newFrame;
  228.                         break;
  229.                 }
  230.         }
  231.  
  232. };
  233.  
  234. figure f[19];
  235.  
  236. void cleaner()
  237. {
  238.         score = 0;
  239.         gameOver = 1;
  240.         failOver = 1;
  241.         workOver = 1;
  242.         difficulty = 1;
  243.         system("cls");
  244.         for (short y = 0; y < 20; y++)
  245.         {
  246.                 for (short x = 0; x < 10; x++)
  247.                 {
  248.                         field[x][y] = space;
  249.                 }
  250.         }
  251.         xNull = 4;
  252.         yNull = 17;
  253. }
  254. // отчистка поля и переменных
  255.  
  256.  
  257. bool checkGameOver()
  258. {
  259.         for (short i = 0; i < 10; i++)
  260.         {
  261.                 if (field[i][16] == block)
  262.                 {
  263.                         return 0;
  264.                 }
  265.         }
  266.         return 1;
  267. }
  268. // проверка условий конца игры (блок в 4х клетках от верха или меньше)
  269.  
  270. void failEnd()
  271. {
  272.         for (short y = 0; y < 20; y++)
  273.         {
  274.                 for (short x = 0; x < 10; x++)
  275.                 {
  276.                         if (field[x][y] == failBlock)
  277.                         {
  278.                                 field[x][y] = block;
  279.                         }
  280.                 }
  281.         }
  282.  
  283. }
  284. // замена всех падающих блоков - статичными
  285.  
  286. void burnLine(short y)
  287. {
  288.         //анимация сгорания линии
  289.         for (short j = 0; j < 4; j++)//колличество вспышек
  290.         {
  291.                 for (short i = 0; i < 10; i++)
  292.                 {
  293.                         field[i][y] = failBlock;
  294.                 }
  295.                 newFrame();
  296.                 Sleep(100);
  297.                 failCleaner();
  298.                 newFrame();
  299.                 for (short i = 0; i < 10; i++)
  300.                 {
  301.                         field[i][y] = 'x';
  302.                 }
  303.                 newFrame();
  304.                 Sleep(100);
  305.         }
  306.         for (short i = 0; i < 10; i++)
  307.         {
  308.                 field[i][y] = failBlock;
  309.         }
  310.         newFrame();
  311.         Sleep(100);
  312.         failCleaner();
  313.         newFrame();
  314.         //падение линий вниз
  315.         for (short i = y; i < 19; i++)
  316.         {
  317.                 for (short x = 0; x < 10; x++)
  318.                 {
  319.                         field[x][i] = field[x][i + 1];
  320.                 }
  321.         }
  322.         newFrame;
  323.         score++;
  324.         difficulty = 2 + (score / 5);
  325. }
  326.  
  327. short checkLine()
  328. {
  329.         short j = 0;
  330.         for (short y = 0; y < 20; y++)
  331.         {       
  332.                 j = 0;
  333.                 for (short i = 0; i < 10; i++)
  334.                 {
  335.                         if (field[i][y] == block)
  336.                         {
  337.                                 j++;
  338.                         }
  339.                 }
  340.                 if (j == 10)
  341.                 {
  342.                         return y;
  343.                 }
  344.         }
  345.         return 100;
  346. }
  347.  
  348. short randomFigureGenerate()
  349. {
  350.         short answer = (rand() % 7);
  351.         switch (answer)
  352.         {
  353.         case 0:
  354.                 answer = 0;
  355.                 break;
  356.         case 1:
  357.                 answer = 2;
  358.                 break;
  359.         case 2:
  360.                 answer = 3;
  361.                 break;
  362.         case 3:
  363.                 answer = 7;
  364.                 break;
  365.         case 4:
  366.                 answer = 11;
  367.                 break;
  368.         case 5:
  369.                 answer = 14;
  370.                 break;
  371.         case 6:
  372.                 answer = 16;
  373.                 break;
  374.  
  375.         }
  376.  
  377.         return answer;
  378. }
  379.  
  380. int main()
  381. {
  382.         system("color 02");
  383.         f[0].set(00, 10, 11, 01); //квадрат
  384.         f[1].set(00, 10, 20, 30); //полоска 1
  385.         f[2].set(00, 01, 02, 03); //полоска 2
  386.         f[3].set(00, 01, 02, 12); //z 1
  387.         f[4].set(01, 11, 21, 20); //z 2
  388.         f[5].set(00, 10, 11, 12); //z зеркальное 1
  389.         f[6].set(00, 01, 10, 20); //z зеркальное 2
  390.         f[7].set(02, 12, 11, 10); //г 1
  391.         f[8].set(00, 10, 20, 21); //г 2
  392.         f[9].set(00, 01, 02, 10); //г 3
  393.         f[10].set(00, 01, 11, 21); //г 4
  394.         f[11].set(00, 01, 11, 12); //г зеркальное 1
  395.         f[12].set(01, 11, 10, 20); //г зеркальное 2
  396.         f[13].set(21, 11, 10, 00); //г зеркальное 3
  397.         f[14].set(02, 01, 11, 10); //г зеркальное 4
  398.         f[15].set(01, 11, 10, 21); //T 1
  399.         f[16].set(00, 10, 20, 11); //T 2
  400.         f[17].set(00, 01, 02, 11); //T 3
  401.         f[18].set(01, 10, 11, 12); //T 4
  402.  
  403.         srand(time(nullptr));
  404.        
  405.         workOver = 1;
  406.         while (workOver)
  407.         {
  408.                 cleaner();
  409.                 while (gameOver)
  410.                 {
  411.                         newF = randomFigureGenerate();
  412.                         failOver = 1;
  413.                         if (newF == 2)
  414.                         {
  415.                                 --yNull;
  416.                         }
  417.                         f[newF].create();
  418.                         newFrame();
  419.                         while (failOver)
  420.                         {
  421.                                 timer = 0;
  422.                                 while (timer < 500)
  423.                                 {
  424.                                         if (_kbhit())
  425.                                         {
  426.                                                 short move = _getch();
  427.                                                 if (move != 72)
  428.                                                 {
  429.                                                         if (f[newF].check_action(move))
  430.                                                         {
  431.                                                                 f[newF].action(move);
  432.                                                                 newFrame();
  433.                                                         }
  434.                                                 }
  435.                                                 else
  436.                                                 {
  437.                                                         if (f[rotate(newF)].check_action(72))
  438.                                                         {
  439.                                                                 failCleaner();
  440.                                                                 f[newF].action(72);
  441.                                                         }
  442.                                                 }
  443.                                         }
  444.                                         timer += difficulty;
  445.                                         Sleep(1);
  446.                                 }
  447.                                 if (f[newF].check_action(80))
  448.                                 {
  449.                                         f[newF].action(80);
  450.                                         newFrame();
  451.                                 }
  452.                                 else
  453.                                 {
  454.                                         failOver = 0;
  455.                                         failEnd();
  456.                                         newFrame();
  457.                                         xNull = 4;
  458.                                         yNull = 17;
  459.                                 }
  460.                         }
  461.                         short triggerBurn = checkLine();
  462.                         while (triggerBurn != 100)
  463.                         {
  464.                                 burnLine(triggerBurn);
  465.                                 triggerBurn = checkLine();
  466.                         }
  467.                         gameOver = checkGameOver();
  468.                 }
  469.                 cout << "GAME OVER!" << endl;
  470.                 cout << "one more time? YES(1) NO (0)" << endl;
  471.                 cin >> workOver;
  472.         }
  473.         return 0;
  474. }
  475.  

Share with your friends:

Распечатать