SHARE
TWEET

tetris 2.1

Mary_99 Apr 23rd, 2019 95 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdlib.h>
  2. #include <unistd.h>//usleep  suspends the performance for a period of time expressed in microseconds
  3. #include <stdio.h>
  4. #include "primlib.h"
  5. #include "pieces.inl"
  6. #include <stdbool.h>
  7.  
  8. #define SQUARE_SIZE 20
  9. #define GAME_WIDTH 15
  10. #define GAME_HEIGHT 20
  11. #define MOVING_PIECE_COLOR MAGENTA
  12. #define STATIC_PIECE_COLOR BLUE
  13. #define PICES_TIME 20000
  14. #define SLEEP 3
  15. #define ARENA_FRAME_COLOUR WHITE
  16. #define GROUND_COLOR BLACK
  17. #define TEXT_COLOR MAGENTA
  18. #define ROTATION_COLOR RED
  19. #define X_LEFT_UPPER_CORDINATE 100
  20. #define Y_LEFT_UPPER_CORDINATE 60
  21.  
  22. void playMainGameLoop();
  23. int isPossible(int area[GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char piece[4][4], char move);
  24. int play(int area[GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char whichPiece[4][4][4]);
  25. void startingPiecePosition(int area [GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char thatPiece[4][4], enum color colour, enum color color);
  26. void updatingState(int area [GAME_WIDTH][GAME_HEIGHT][3], char nextPiece [4][4]);
  27. void checkingBoundry();
  28. bool deleteRows(int area[GAME_WIDTH][GAME_HEIGHT][3]);
  29. void DrawingBackground();
  30. void findCenter(int rotation, char whichPiece[4][4][4]);
  31. void cleaningBackground(int area [GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char piece[4][4], enum color colors);
  32. void endingGame();
  33.  
  34. int coordinatesOfCenter[2];
  35.  
  36. int main ()
  37. {
  38.     initGraph();
  39.     playMainGameLoop();
  40.     updateScreen();
  41.     return 0;
  42. }
  43.  
  44.  
  45. void playMainGameLoop()
  46. {
  47.     int columnCounter;
  48.     int rowCounter;
  49.     int area[GAME_WIDTH][GAME_HEIGHT][3];
  50.     int whichPiece;
  51.     int nextPiece;
  52.    
  53.     for(columnCounter = 0; columnCounter < GAME_WIDTH; columnCounter++)
  54.     {
  55.         for(rowCounter=0;rowCounter<GAME_HEIGHT;rowCounter++)
  56.         {
  57.             area [columnCounter][rowCounter][0] = X_LEFT_UPPER_CORDINATE + columnCounter * SQUARE_SIZE;
  58.             area [columnCounter][rowCounter][1] = Y_LEFT_UPPER_CORDINATE + rowCounter * SQUARE_SIZE;
  59.             area [columnCounter][rowCounter][2] = 0;
  60.         }
  61.     }
  62.     whichPiece = (int)rand()%7;
  63.    
  64.     while(1)
  65.     {
  66.         nextPiece = (int)rand()%7;
  67.         updatingState(area, pieces[nextPiece][0]);
  68.         updateScreen();
  69.         if(isPossible(area, (GAME_WIDTH / 2) - 1, 0, pieces[whichPiece][0], '0') == 0)
  70.         {
  71.             endingGame();
  72.             break;
  73.         }
  74.         startingPiecePosition(area, (GAME_WIDTH / 2) - 1, 0, pieces[whichPiece][0], MOVING_PIECE_COLOR, ROTATION_COLOR);
  75.         updateScreen();
  76.  
  77.         if(play(area,(GAME_WIDTH / 2) - 1, 0, pieces[whichPiece]) == 0)
  78.         {
  79.             endingGame();
  80.             break;
  81.         }
  82.        
  83.         deleteRows(area);
  84.         whichPiece = nextPiece;
  85.     }
  86.  
  87. }
  88.  
  89.  
  90. void checkingBoundry()
  91. {
  92.     if(GAME_WIDTH < 10 || GAME_WIDTH > 20)
  93.     {
  94.         printf("Invalid GAME_WIDTH \n");
  95.         exit(3);
  96.     }
  97.  
  98.     if(GAME_HEIGHT < 10 || GAME_HEIGHT >20)
  99.     {
  100.         printf("Invalid GAME_HEIGHT\n");
  101.         exit(3);
  102.     }
  103. }
  104.  
  105.  
  106. int isPossible(int area[GAME_WIDTH][GAME_HEIGHT][3], int x,int y,char piece[4][4], char move)
  107. {
  108.     int columnCounter;
  109.     int rowCounter;
  110.  
  111.     switch(move)
  112.     {
  113.         case('l'):
  114.             x--;
  115.             break;
  116.         case('r'):
  117.             x++;
  118.             break;
  119.         case('d'):
  120.             y++;
  121.             break;
  122.         case('0'):
  123.             break;
  124.     };
  125.    
  126.     if(x < 0 || x >= GAME_WIDTH || y >= GAME_HEIGHT)
  127.     {
  128.         return 0;
  129.     }
  130.    
  131.     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  132.     {
  133.         for(rowCounter = 0 ; rowCounter < 4; rowCounter++)
  134.         {
  135.             if(piece[columnCounter][rowCounter]!= 0 && (x + columnCounter >= GAME_WIDTH || y + rowCounter >= GAME_HEIGHT))
  136.             {
  137.            
  138.                 return 0; //piece out of the game area
  139.             }
  140.             if ((piece[columnCounter][rowCounter]!= 0) && (area[x + columnCounter][y + rowCounter][2]!= 0))
  141.             {
  142.                 return 0; // piece reaches the non-empty place
  143.             }
  144.         }
  145.     }
  146.        
  147.     return 1;
  148. }
  149.  
  150. bool deleteRows(int area[GAME_WIDTH][GAME_HEIGHT][3])
  151. {
  152.     int columnCounter;
  153.     int rowCounter;
  154.     int deletedRow;
  155.     int checkingEmptySpot;
  156.  
  157.     for(rowCounter = 0; rowCounter < GAME_HEIGHT; rowCounter++)
  158.     {
  159.         for(columnCounter = 0; columnCounter < GAME_WIDTH; columnCounter++)
  160.         {
  161.             checkingEmptySpot*= area[columnCounter][rowCounter][2]; //because the black colour is'0' value
  162.             if (checkingEmptySpot == false)
  163.             {
  164.                 break; // if empty spot we not need  check anything more
  165.        
  166.             }
  167.         }
  168.         if(checkingEmptySpot != 0)
  169.         {
  170.             for(deletedRow = rowCounter; deletedRow > 0; deletedRow--)
  171.             {
  172.                 for(columnCounter = 0; columnCounter < GAME_WIDTH; columnCounter++)
  173.                 {
  174.                     area[columnCounter][deletedRow][2] = area[columnCounter][deletedRow - 1][2];
  175.                 }
  176.             }
  177.             for(columnCounter = 0; columnCounter < GAME_WIDTH; columnCounter++)
  178.             {
  179.                 area[columnCounter][0][2]=0;
  180.             }
  181.  
  182.         }
  183.         checkingEmptySpot = true;
  184.     }
  185. }
  186.  
  187.  
  188. int play(int area[GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char whichPiece[4][4][4])
  189. {
  190.     int columnCounter;
  191.     int rowCounter;
  192.     int turnCounter;
  193.     int rotation = 0;
  194.     int oldCenter_x;
  195.     int oldCenter_y, newCenter_x, newCenter_y;
  196.  
  197.     while(1)
  198.     {
  199.         for(turnCounter = 0; turnCounter < 10; turnCounter++) //10moves 0.1s each,gives 1s time for the movement downward
  200.         {
  201.             if(isKeyDown('e') == 1) return 0; // to quit the game
  202.             switch(pollkey())
  203.             {
  204.                 case(SDLK_DOWN):
  205.                     while(isPossible(area, x, y, whichPiece[rotation], 'd') == 1)
  206.                     {
  207.                         y++;
  208.                         startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  209.                         updateScreen();
  210.                     }
  211.                     goto storingPices;
  212.  
  213.                 case(SDLK_RIGHT):
  214.                     if(isPossible(area, x, y, whichPiece[rotation], 'r') == 1)
  215.                     {
  216.                         cleaningBackground(area, x, y, whichPiece[rotation], GROUND_COLOR);
  217.                         x++;
  218.                         startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  219.                         updateScreen();
  220.                     }break;
  221.                 case(SDLK_LEFT):
  222.                     if(isPossible(area, x, y, whichPiece[rotation],'l') == 1)
  223.                     {
  224.                         cleaningBackground(area, x, y, whichPiece[rotation], GROUND_COLOR);
  225.                         x--;
  226.                         startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  227.                         updateScreen();
  228.                     }break;
  229.                    
  230.                 case(SDLK_SPACE):
  231.                     if(isPossible(area, x, y, whichPiece[(rotation + 1) % 4],'0'))
  232.                     {
  233.            
  234.                     int counter = 0;
  235.                     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  236.                     {
  237.                         for(rowCounter = 0; rowCounter < 4; rowCounter++)
  238.                         {
  239.                             if(whichPiece[rotation][columnCounter][rowCounter] == 2)
  240.                             {
  241.                                 oldCenter_x = columnCounter;
  242.                                 oldCenter_y = rowCounter;
  243.                                 counter += 1;
  244.                                 break;
  245.                             }
  246.                         }
  247.                         if(counter != 0)
  248.                         {
  249.                             break;
  250.                         }
  251.                     }
  252.                    
  253.                    cleaningBackground(area, x, y, whichPiece[rotation], GROUND_COLOR);;
  254.                     ++rotation;
  255.                     rotation %= 4;
  256.                
  257.                     counter = 0;
  258.                     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  259.                     {
  260.                         for(rowCounter = 0; rowCounter < 4; rowCounter++)
  261.                         {
  262.                             if(whichPiece[rotation][columnCounter][rowCounter] == 2)
  263.                             {
  264.                                 newCenter_x = columnCounter;
  265.                                 newCenter_y = rowCounter;
  266.                                 counter += 1;
  267.                                 break;
  268.                             }
  269.                         }
  270.                         if(counter != 0)
  271.                         {
  272.                             break;
  273.                         }
  274.                     }
  275.                    
  276.                 coordinatesOfCenter[0] = oldCenter_x - newCenter_x;
  277.                 coordinatesOfCenter[1] = oldCenter_y - newCenter_y;
  278.                 x = x + coordinatesOfCenter[0];
  279.                 y = y + coordinatesOfCenter[1];
  280.                
  281.                 startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  282.                 updateScreen();
  283.                 }
  284.                 else if (isPossible(area, x - 1, y, whichPiece[(rotation + 1) % 4],'0'))
  285.                 {
  286.                 cleaningBackground(area, x, y, whichPiece[rotation], GROUND_COLOR);;
  287.                 ++rotation;
  288.                 rotation %= 4;
  289.                 findCenter(rotation, whichPiece[4][4][4]);
  290.                 x = coordinatesOfCenter[0];
  291.                 y = coordinatesOfCenter[1];
  292.                 x--;
  293.                 startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  294.                 updateScreen();
  295.                 }
  296.                 else if (isPossible(area, x + 1, y, whichPiece[(rotation + 1) % 4], '0'))
  297.                 {
  298.                 cleaningBackground(area, x, y, whichPiece[rotation], GROUND_COLOR);
  299.                 ++rotation;
  300.                 rotation %= 4;
  301.                 findCenter(rotation, whichPiece[4][4][4]);
  302.                 x = coordinatesOfCenter[0];
  303.                 y = coordinatesOfCenter[1];
  304.                 x++;
  305.                 startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  306.                 updateScreen();
  307.                 }
  308.                 break;
  309.                 };
  310.                 usleep(PICES_TIME);
  311.             }
  312.             if(isPossible(area, x, y, whichPiece[rotation],'d') == 1)
  313.             {
  314.                 cleaningBackground(area, x, y, whichPiece[rotation], GROUND_COLOR);  
  315.                 y++;
  316.                 startingPiecePosition(area, x, y, whichPiece[rotation], MOVING_PIECE_COLOR, ROTATION_COLOR);
  317.                 updateScreen();
  318.             }
  319.             else break;
  320.         }
  321. storingPices:
  322.     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  323.     {
  324.         for(rowCounter = 0;rowCounter < 4; rowCounter++)
  325.         {
  326.             if(whichPiece[rotation][columnCounter][rowCounter] != 0)
  327.             {
  328.                 area[x+columnCounter][y+rowCounter][2] = STATIC_PIECE_COLOR;
  329.             }
  330.         }
  331.     }
  332.     return 1;
  333. }
  334.  
  335. void DrawingBackground()
  336. {
  337.     filledRect(0, 0, screenWidth() - 1, screenHeight() - 1, GROUND_COLOR);
  338.  
  339.     textout(0, 10, "Use arrows on your keyboard to move the piece and space to rotate it.", TEXT_COLOR);
  340.     textout(0, 20, "To Accelerate the pice press downn arrow.TO END THE GAME PRESS 'e'", TEXT_COLOR);
  341.    
  342.  
  343.     filledRect(X_LEFT_UPPER_CORDINATE - 5, Y_LEFT_UPPER_CORDINATE, X_LEFT_UPPER_CORDINATE - 1, Y_LEFT_UPPER_CORDINATE + (GAME_HEIGHT * SQUARE_SIZE) + 4,
  344.                ARENA_FRAME_COLOUR);
  345.  
  346.     filledRect(X_LEFT_UPPER_CORDINATE, Y_LEFT_UPPER_CORDINATE + (GAME_HEIGHT * SQUARE_SIZE), X_LEFT_UPPER_CORDINATE + (GAME_WIDTH * SQUARE_SIZE) - 1,
  347.                Y_LEFT_UPPER_CORDINATE + (GAME_HEIGHT * SQUARE_SIZE) + 4, ARENA_FRAME_COLOUR);
  348.    
  349.     filledRect(X_LEFT_UPPER_CORDINATE + (GAME_WIDTH * SQUARE_SIZE), Y_LEFT_UPPER_CORDINATE, X_LEFT_UPPER_CORDINATE + (GAME_WIDTH*SQUARE_SIZE) + 4,
  350.                Y_LEFT_UPPER_CORDINATE + (GAME_HEIGHT * SQUARE_SIZE) + 4, ARENA_FRAME_COLOUR);
  351. }
  352.  
  353. void updatingState(int area [GAME_WIDTH][GAME_HEIGHT][3], char nextPiece [4][4])
  354. {
  355.     int columnCounter;
  356.     int rowCounter;
  357.    
  358.     DrawingBackground();
  359.  
  360.     //StaticPices
  361.     for(columnCounter = 0; columnCounter < GAME_WIDTH; columnCounter++)
  362.     {
  363.         for(rowCounter = 0; rowCounter < GAME_HEIGHT; rowCounter++)
  364.         {
  365.            filledRect(area[columnCounter][rowCounter][0] + 1, area[columnCounter][rowCounter][1] + 1,
  366.                       area[columnCounter][rowCounter][0] + SQUARE_SIZE - 2, area[columnCounter][rowCounter][1] + SQUARE_SIZE - 2,
  367.                       area[columnCounter][rowCounter][2]);
  368.         }
  369.     }
  370.  
  371.     textout( X_LEFT_UPPER_CORDINATE + (GAME_WIDTH * 20) + 11, Y_LEFT_UPPER_CORDINATE, "next piece: ", TEXT_COLOR);
  372.    
  373.     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  374.     {
  375.         for(rowCounter = 0; rowCounter < 4; rowCounter++)
  376.         {
  377.             if (nextPiece[columnCounter][rowCounter]!= 0)
  378.             {
  379.                 filledRect(area[columnCounter][rowCounter][0] + (GAME_WIDTH * SQUARE_SIZE) + 11, area[columnCounter][rowCounter][1] + 11,
  380.                            area[columnCounter][rowCounter][0] + (GAME_WIDTH * SQUARE_SIZE) + 28, area[columnCounter][rowCounter][1] + 28,
  381.                            MOVING_PIECE_COLOR);
  382.             }
  383.        }
  384.     }
  385. }
  386.  
  387.  
  388. void startingPiecePosition(int area [GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char piece[4][4], enum color colour, enum color color)
  389. // enum is the keyword to declare a new enumeration type. color is the tag name that you can use later as a type name.
  390. {
  391.     int columnCounter;
  392.     int rowCounter;
  393.  
  394.     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  395.     {
  396.         for(rowCounter = 0;rowCounter < 4; rowCounter++)
  397.         {
  398.             if(piece[columnCounter][rowCounter] != 0) /*draws pices of when their colour is other than black */
  399.             {
  400.                 filledRect(area[x + columnCounter][y + rowCounter][0] + 1, area[x + columnCounter][y + rowCounter][1] + 1,
  401.                            area[x + columnCounter][y + rowCounter][0] + SQUARE_SIZE - 2, area[x + columnCounter][y + rowCounter][1] + SQUARE_SIZE - 2, colour);
  402.             }
  403.            
  404.             if(piece[columnCounter][rowCounter] == 2)
  405.             {
  406.                 filledRect(area[x + columnCounter][y + rowCounter][0] + 1,
  407.                            area[x + columnCounter][y + rowCounter][1] + 1,
  408.                            area[x + columnCounter][y + rowCounter][0] + SQUARE_SIZE - 2,
  409.                            area[x + columnCounter][y + rowCounter][1] + SQUARE_SIZE - 2, color);
  410.             }
  411.  
  412.         }
  413.     }
  414. }
  415.  
  416.  
  417. void endingGame()
  418. {
  419.     filledRect(0, 0,screenWidth() - 1, screenHeight() -1, GROUND_COLOR);  
  420.     textout(280, 240, "Game over , sorry  :( ", TEXT_COLOR );
  421.     updateScreen();
  422.     sleep(SLEEP);
  423. }
  424. void findCenter(int rotation, char whichPiece[4][4][4])
  425. {
  426.     int oldCenter_x, oldCenter_y, columnCounter, rowCounter;
  427.     int counter = 0;
  428.     for(columnCounter = 0; columnCounter < GAME_WIDTH; columnCounter++)
  429.     {
  430.         for(rowCounter = 0; rowCounter < GAME_HEIGHT; rowCounter++)
  431.         {
  432.             if(whichPiece[rotation][columnCounter][rowCounter] == 2)
  433.             {
  434.                 oldCenter_x = columnCounter;
  435.                 oldCenter_y = rowCounter;
  436.                 counter += 1;
  437.                 break;
  438.             }
  439.         }
  440.         if(counter != 0)
  441.         {
  442.             break;
  443.         }
  444.     }
  445.     coordinatesOfCenter[0] = oldCenter_x;
  446.     coordinatesOfCenter[1] = oldCenter_y;
  447. }
  448.  
  449. void cleaningBackground(int area [GAME_WIDTH][GAME_HEIGHT][3], int x, int y, char piece[4][4], enum color colors)
  450. {
  451.     int columnCounter;
  452.     int rowCounter;
  453.  
  454.     for(columnCounter = 0; columnCounter < 4; columnCounter++)
  455.     {
  456.         for(rowCounter = 0;rowCounter < 4; rowCounter++)
  457.         {
  458.             if(piece[columnCounter][rowCounter] != 0)
  459.             {
  460.                     filledRect(area[x + columnCounter][y + rowCounter][0] + 1,
  461.                                area[x + columnCounter][y + rowCounter][1] + 1,
  462.                                area[x + columnCounter][y + rowCounter][0] + SQUARE_SIZE - 2,
  463.                                area[x + columnCounter][y + rowCounter][1] + SQUARE_SIZE - 2, colors);
  464.             }
  465.  
  466.         }
  467.     }
  468. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top