SaveText.Ru

tetramino govno iz jopy
  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][0]][y + pixel[i][1] + 1] != space)
  43.                                         {
  44.                                                 return 0;
  45.                                         }
  46.                                 }
  47.                                 return 1;
  48.                                         break;
  49.                         case 75://left
  50.                                
  51.                                 for (int i = 0; i < 4; i++)
  52.                                 {
  53.                                         if (field[x + pixel[i][0] - 1][y + pixel[i][1]] != space )
  54.                                         {
  55.                                                 return 0;
  56.                                         }
  57.                                 }
  58.  
  59.                                 return 1;
  60.                                         break;
  61.                         case 77://right
  62.                                
  63.                                 for (int i = 0; i < 4; i++)
  64.                                 {
  65.                                         if (field[x + pixel[i][0] + 1][y + pixel[i][1]] != space)
  66.                                         {
  67.                                                 return 0;
  68.                                         }
  69.                                 }
  70.                                 return 1;
  71.                                         break;
  72.                         }
  73.                 }
  74.                 void create()
  75.                 {
  76.                         x = 5;
  77.                         y = 4;
  78.                         for (short i = 0; i < 4; i++)
  79.                         {
  80.                                 field[5 + pixel[i][1]][4 + pixel[i][0]] = failBlock;
  81.                         }
  82.                 }
  83.                 void fail()
  84.                 {
  85.                         y++;
  86.                         for (short i = 0; i < 4; i++)
  87.                         {
  88.                                 field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  89.                         }
  90.                        
  91.                 }
  92.                 void action(short setAction)
  93.                 {
  94.                         switch (setAction)
  95.                         {
  96.                         case 75://left
  97.                                 x--;
  98.                                 for (short i = 0; i < 4; i++)
  99.                                 {
  100.                                         field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  101.                                 }
  102.                                 break;
  103.                         case 77://right
  104.                                 x++;
  105.                                 for (short i = 0; i < 4; i++)
  106.                                 {
  107.                                         field[x + pixel[i][1]][y + pixel[i][0]] = failBlock;
  108.                                 }
  109.                                 break;
  110.                         case 72://rotate
  111.  
  112.                                 break;
  113.                         }
  114.                 }
  115. };
  116.  
  117. figure f[15];
  118.  
  119.  
  120. void cleaner()
  121. {
  122.         score = 0;
  123.         gameOver = 1;
  124.         difficulty = 1;
  125.         system("cls");
  126.         for (short y = 0; y < 20; y++)
  127.         {
  128.                 for (short x = 0; x < 10; x++)
  129.                 {
  130.                         field[x][y] = space;
  131.                 }
  132.         }
  133. }
  134.  
  135. void failBlockClean()
  136. {
  137.         for (short y = 0; y < 20; y++)
  138.         {
  139.                 for (short x = 0; x < 10; x++)
  140.                 {
  141.                         if (field[x][y] == failBlock)
  142.                         {
  143.                                 field[x][y] = space;
  144.                         }
  145.                 }
  146.         }
  147. }
  148.  
  149. void fieldUp()
  150. {
  151.         system("cls");
  152.         cout << "n" << "score: " << score << "n" << endl;
  153.         for (short y = 0; y < 20; y++)
  154.         {
  155.                 for (short x = 0; x < 10; x++)
  156.                 {
  157.                         cout << field[x][y];
  158.                 }
  159.                 cout << endl;
  160.         }
  161. }
  162.  
  163. bool checkGameOver()
  164. {
  165.         for (short i = 0; i<10; i++)
  166.         {
  167.                 if (field[i][4] == block)
  168.                 {
  169.                         return 0;
  170.                 }
  171.         }
  172.         return 1;
  173. }
  174.  
  175. int main()
  176. {
  177.         f[0].set(00,10,11,01);
  178.         f[1].set(00,10,20,30);
  179.         f[2].set(00,01,02,03);
  180.         f[3].set(00,01,02,12);
  181.         f[4].set(01,11,21,20);
  182.         f[5].set(00,10,11,12);
  183.         f[6].set(00,01,10,20);
  184.         f[7].set(02,12,11,10);
  185.         f[8].set(00,10,20,21);
  186.         f[9].set(00,01,02,10);
  187.         f[10].set(00,01,11,21);
  188.         f[11].set(00,01,11,12);
  189.         f[12].set(01,11,10,20);
  190.         f[13].set(21,11,10,00);
  191.         f[14].set(02,01,11,10);
  192.         srand(time(nullptr));
  193.         short timer,r,moove;
  194.         bool failOver = 1, workOver = 1;
  195.         short randomFigure = (rand() % 15);
  196.  
  197.         system("color 02");
  198.        
  199.         cleaner();
  200.         fieldUp();
  201.         while (true)
  202.         {
  203.                 timer = 0;
  204.                 while (timer < 1000)
  205.                 {
  206.                         if (_kbhit())
  207.                         {
  208.                                 moove = _getch();
  209.                                 if (f[randomFigure].check_action(moove))
  210.                                 {
  211.                                         failBlockClean();
  212.                                         f[randomFigure].action(moove);
  213.                                         fieldUp();
  214.                                 }
  215.                         }
  216.                         timer += difficulty;
  217.                         Sleep(1);
  218.                 }
  219.                 failBlockClean();
  220.                 f[randomFigure].fail();
  221.                 fieldUp();
  222.         }
  223.         cout << "n" << "see you later!" << endl;
  224.         Sleep(1500);
  225.         return 0;

Share with your friends:

Распечатать