SaveText.Ru

tetro
  1. #include <iostream>
  2. #include <ctime>
  3. #include <cstdlib>
  4. #include <conio.h>
  5. #include <windows.h>
  6. using namespace std;
  7.  
  8. bool gameOver;
  9. short newFigure, x, y;
  10. char field[10][20];
  11. short positionX, positionY;
  12. short score, difficulty;
  13. const char block = 219, space = 176, failBlock = 178;
  14.  
  15. class figure
  16. {
  17.         short pixel[4][2];
  18.         public:
  19.                 void set(short p0, short p1, short p2, short p3)
  20.                 {
  21.                         //y
  22.                         pixel[0][1] = p0 % 10;
  23.                         pixel[1][1] = p1 % 10;
  24.                         pixel[2][1] = p2 % 10;
  25.                         pixel[3][1] = p3 % 10;
  26.                         //x
  27.                         pixel[0][0] = p0 / 10;
  28.                         pixel[1][0] = p1 / 10;
  29.                         pixel[2][0] = p2 / 10;
  30.                         pixel[3][0] = p3 / 10;
  31.                 }
  32.                 bool check_action(short setAction)
  33.                 {
  34.                         switch (setAction)
  35.                         {
  36.                         case 72://rotate
  37.  
  38.                                 break;
  39.                         case 80://down                         
  40.                                 for (int i = 0; i < 4; i++)
  41.                                 {
  42.                                         if ((field[x + pixel[i][1]][y + pixel[i][0] + 1] != space) ||
  43.                                                 (y == 19))
  44.                                         {
  45.                                                 return 0;
  46.                                         }
  47.                                 }
  48.                                 return 1;
  49.                                         break;
  50.                         case 75://left
  51.                                
  52.                                 for (int i = 0; i < 4; i++)
  53.                                 {
  54.                                         if ((field[x + pixel[i][0] - 1][y + pixel[i][1]] != space ) || (x - 1 < 0))
  55.                                         {
  56.                                                 return 0;
  57.                                         }
  58.                                 }
  59.  
  60.                                 return 1;
  61.                                         break;
  62.                         case 77://right
  63.                                
  64.                                 for (int i = 0; i < 4; i++)
  65.                                 {
  66.                                         if ((field[x + pixel[i][0] + 1][y + pixel[i][1]] != space) || (x + 1 + pixel[i][0] > 9))
  67.                                         {
  68.                                                 return 0;
  69.                                         }
  70.                                 }
  71.                                 return 1;
  72.                                         break;
  73.                         }
  74.                 }
  75.                 void create()
  76.                 {
  77.                         x = 5;
  78.                         y = 4;
  79.                         for (short i = 0; i < 4; i++)
  80.                         {
  81.                                 field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  82.                         }
  83.                 }
  84.                 void fail()
  85.                 {
  86.                         y++;
  87.                         for (short i = 0; i < 4; i++)
  88.                         {
  89.                                 field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  90.                         }
  91.                        
  92.                 }
  93.                 void action(short setAction)
  94.                 {
  95.                         switch (setAction)
  96.                         {
  97.                         case 75://left
  98.                                 x--;
  99.                                 for (short i = 0; i < 4; i++)
  100.                                 {
  101.                                         field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  102.                                 }
  103.                                 break;
  104.                         case 77://right
  105.                                 x++;
  106.                                 for (short i = 0; i < 4; i++)
  107.                                 {
  108.                                         field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  109.                                 }
  110.                                 break;
  111.                         case 72://rotate
  112.  
  113.                                 break;
  114.                         }
  115.                 }
  116. };
  117.  
  118. figure f[15];
  119.  
  120.  
  121. void cleaner()
  122. {
  123.         score = 0;
  124.         gameOver = 1;
  125.         difficulty = 1;
  126.         system("cls");
  127.         for (short y = 0; y < 20; y++)
  128.         {
  129.                 for (short x = 0; x < 10; x++)
  130.                 {
  131.                         field[x][y] = space;
  132.                 }
  133.         }
  134.         x = 0;
  135.         y = 0;
  136. }
  137.  
  138. void failBlockClean()
  139. {
  140.         for (short y = 0; y < 20; y++)
  141.         {
  142.                 for (short x = 0; x < 10; x++)
  143.                 {
  144.                         if (field[x][y] == failBlock)
  145.                         {
  146.                                 field[x][y] = space;
  147.                         }
  148.                 }
  149.         }
  150. }
  151.  
  152. void fieldUp()
  153. {
  154.         system("cls");
  155.         cout << "n" << "score: " << score << "n" << endl;
  156.         for (short y = 0; y < 20; y++)
  157.         {
  158.                 for (short x = 0; x < 10; x++)
  159.                 {
  160.                         cout << field[x][y];
  161.                 }
  162.                 cout << endl;
  163.         }
  164. }
  165.  
  166. bool checkGameOver()
  167. {
  168.         for (short i = 0; i<10; i++)
  169.         {
  170.                 if (field[i][4] == block)
  171.                 {
  172.                         return 0;
  173.                 }
  174.         }
  175.         return 1;
  176. }
  177.  
  178. void endOfFail()
  179. {
  180.         for (short y = 0; y < 20; y++)
  181.         {
  182.                 for (short x = 0; x < 10; x++)
  183.                 {
  184.                         if (field[x][y] == failBlock)
  185.                         {
  186.                                 field[x][y] = block;
  187.                         }
  188.                 }
  189.         }
  190.  
  191. }
  192.  
  193. int main()
  194. {
  195.         f[0].set(00,10,11,01);
  196.         f[1].set(00,10,20,30);
  197.         f[2].set(00,01,02,03);
  198.         f[3].set(00,01,02,12);
  199.         f[4].set(01,11,21,20);
  200.         f[5].set(00,10,11,12);
  201.         f[6].set(00,01,10,20);
  202.         f[7].set(02,12,11,10);
  203.         f[8].set(00,10,20,21);
  204.         f[9].set(00,01,02,10);
  205.         f[10].set(00,01,11,21);
  206.         f[11].set(00,01,11,12);
  207.         f[12].set(01,11,10,20);
  208.         f[13].set(21,11,10,00);
  209.         f[14].set(02,01,11,10);
  210.         f[15].set(01,11,10,21);
  211.         f[16].set(00,10,20,11);
  212.         f[17].set(00,01,02,11);
  213.         f[18].set(01,10,11,12);
  214.         srand(time(nullptr));
  215.         short timer,r,moove;
  216.         bool failOver = 1, workOver = 1;
  217.         short randomFigure = (rand() % 15);
  218.  
  219.         system("color 02");
  220.        
  221.         cleaner();
  222.         fieldUp();
  223.         /*while (true)
  224.         {
  225.                 timer = 0;
  226.                 while (timer < 1000)
  227.                 {
  228.                         if (_kbhit())
  229.                         {
  230.                                 moove = _getch();
  231.                                 if (f[randomFigure].check_action(moove))
  232.                                 {
  233.                                         failBlockClean();
  234.                                         f[randomFigure].action(moove);
  235.                                         fieldUp();
  236.                                 }
  237.                         }
  238.                         timer += difficulty;
  239.                         Sleep(1);
  240.                 }
  241.                 failBlockClean();
  242.                 f[randomFigure].fail();
  243.                 fieldUp();
  244.         }
  245.         */
  246.         while (workOver)
  247.         {
  248.                 cleaner();
  249.                 while (gameOver)
  250.                 {
  251.                         while (failOver)
  252.                         {
  253.                                 fieldUp();
  254.                                 timer = 0;
  255.                                 while (timer < 100)
  256.                                 {
  257.                                         if (_kbhit())
  258.                                         {
  259.                                                 moove = _getch();
  260.                                                 if (f[randomFigure].check_action(moove))
  261.                                                 {
  262.                                                         failBlockClean();
  263.                                                         f[randomFigure].action(moove);
  264.                                                 }
  265.                                                 fieldUp();
  266.                                         }
  267.                                         timer += difficulty;
  268.                                         Sleep(1);
  269.                                 }
  270.                                 if (!f[randomFigure].check_action(80))
  271.                                 {
  272.                                         failBlockClean();
  273.                                         f[randomFigure].fail();
  274.                                         fieldUp();
  275.                                 }
  276.                                 else
  277.                                 {
  278.                                         endOfFail();
  279.                                 }
  280.                         }
  281.                         checkGameOver();
  282.                         failOver = 1;
  283.                 }
  284.                 cout << "GAME OVER!" << endl;
  285.                 cout << "n" << "one more time?  YES(1) NO(0)" << endl;
  286.                 cin >> gameOver;
  287.                 workOver = gameOver;
  288.         }
  289.         cout << "n" << "see you later!" << endl;
  290.         Sleep(1500);
  291.         return 0;
  292. }

Share with your friends:

Распечатать