Tetris_do_oddania

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <stdbool.h>

#include "primlib.h"
#include "pieces.inl"

#define SQUARE_SIZE 20
#define GAME_WIDTH 15
#define GAME_HEIGHT 20
#define MOVING_PIECE_COLOR GREEN
#define STATIC_PIECE_COLOR YELLOW
#define GAME_OVER_TIME 2
#define TIME 100000
#if (GAME_WIDTH < 10 || GAME_WIDTH > 20 || GAME_HEIGHT < 10 || GAME_HEIGHT > 20)
    #error: "the wrong dimension of the game's area"
#endif


void updateState (char nextPiece[4][4]);
bool isPossible(int x, int y, char piece[4][4], char move);
bool play(int x,int y, char whichPiece[4][4][4]);
void deleteRows();
void setPiece(int x,int y, char thatPiece[4][4], enum color colour);
void gameOver();
void drawBoundaries();
void showComingPiece(char nextPiece[4][4]);


int gameArray[GAME_WIDTH][GAME_HEIGHT][3];
int leftCorner_x = 100;
int leftCorner_y = 70;


int main()
{
  int column, row;
  int whichPiece, nextPiece;

  initGraph();

  for(column = 0; column < GAME_WIDTH; column++)
  {
    for(row = 0;row < GAME_HEIGHT; row++)
    {
      gameArray[column][row][0] = leftCorner_x + column * SQUARE_SIZE;
      gameArray[column][row][1] = leftCorner_y + row * SQUARE_SIZE;
      gameArray[column][row][2] = 0;
    }
  }

  whichPiece = (int) rand() % 7;

  while(1)
  {
    nextPiece = (int) rand() % 7;

    updateState(pieces[nextPiece][0]);
    updateScreen();

    if(isPossible((GAME_WIDTH / 2) - 1, 0, pieces[whichPiece][0], '0') == false)
    {
      gameOver();
      break;
    }

    setPiece((GAME_WIDTH / 2) - 1, 0, pieces[whichPiece][0], MOVING_PIECE_COLOR);
    updateScreen();

    if(play((GAME_WIDTH / 2) - 1, 0, pieces[whichPiece]) == false)
    {
      gameOver();
      break;
    }

    deleteRows();

    whichPiece = nextPiece;
  }

  updateScreen();
  return 0;
}

void updateState(char nextPiece [4][4])
{
    int column, row;

    filledRect(0, 0, screenWidth() - 1, screenHeight() - 1, BLACK);
  drawBoundaries();

    for(column = 0; column < GAME_WIDTH; column++)
  {
    for(row = 0; row < GAME_HEIGHT; row++)
    {
      filledRect(gameArray[column][row][0] + 1, gameArray[column][row][1] + 1,
                 gameArray[column][row][0] + SQUARE_SIZE - 2, gameArray[column][row][1] + SQUARE_SIZE - 2, gameArray[column][row][2]);
    }
  }
  showComingPiece(nextPiece);
}

void drawBoundaries()
{
  filledRect(leftCorner_x - 5, leftCorner_y,
             leftCorner_x - 1, leftCorner_y + (GAME_HEIGHT * SQUARE_SIZE) + 4, WHITE);
  filledRect(leftCorner_x, leftCorner_y + (GAME_HEIGHT * SQUARE_SIZE),
             leftCorner_x + (GAME_WIDTH * SQUARE_SIZE) - 1, leftCorner_y + (GAME_HEIGHT * SQUARE_SIZE) + 4, WHITE);
  filledRect(leftCorner_x + (GAME_WIDTH * SQUARE_SIZE), leftCorner_y,
             leftCorner_x + (GAME_WIDTH * SQUARE_SIZE) + 4, leftCorner_y + (GAME_HEIGHT * SQUARE_SIZE) + 4, WHITE);

}

void showComingPiece(char nextPiece[4][4])
{
    textout( leftCorner_x + (GAME_WIDTH * SQUARE_SIZE) + 11, leftCorner_y - 11, "next: ", BLUE);
    int column, row;

    for(column = 0; column < 4; column++)
    {
      for(row = 0; row < 4; row++)
        {
        if (nextPiece[column][row] != 0)
            {
          filledRect(gameArray[column][row][0] + (GAME_WIDTH * SQUARE_SIZE) + 11, gameArray[column][row][1] + 11,
                     gameArray[column][row][0] + (GAME_WIDTH * SQUARE_SIZE) + 28, gameArray[column][row][1] + 28,  MOVING_PIECE_COLOR);
        }
      }
    }
}

bool isPossible(int x, int y, char piece[4][4], char move)
{
    int column, row;

    switch(move)
    {
        case('l'):
                x--;
                break;
        case('r'):
                x++;
                break;
        case('d'):
                y++;
                break;
        case('0'):
          break;
    }

    if(x < 0 || x >= GAME_WIDTH || y >= GAME_HEIGHT)
  {
    return false;
  }

    for(column = 0; column < 4; column++)
  {
    for(row = 0; row < 4; row++)
        {
            if(piece[column][row] != 0 && (x + column >= GAME_WIDTH || y + row >= GAME_HEIGHT))
      {
        return false;
      }
      if (piece[column][row] != 0 && gameArray[x + column][y + row][2] != 0)
      {
        return false;
      }
        }
  }

    return true;
}

void setPiece(int x, int y, char piece[4][4], enum color colour)
{
  int column,row;
    for(column = 0; column < 4; column++)
  {
    for(row = 0; row < 4; row++)
        {
      if(piece[column][row] != 0)
            {
        filledRect(gameArray[x + column][y + row][0] + 1, gameArray[x + column][y + row][1] + 1,
                   gameArray[x + column][y + row][0] + SQUARE_SIZE - 2, gameArray[x + column][y + row][1] + SQUARE_SIZE - 2, colour);
      }
    }
  }
}

bool play(int x, int y, char whichPiece[4][4][4])
{
  int column, row, counter;
    int rotation = 0;

    while(1)
    {
        for(counter = 0; counter < 10; counter++)
        {
            if(isKeyDown(SDLK_ESCAPE) == 1)
      {
        return false;
      }

            switch(pollkey())
            {
                case(SDLK_DOWN):
                    while(isPossible(x, y, whichPiece[rotation], 'd') == true)
                    {
                        setPiece(x, y, whichPiece[rotation], BLACK);
                        y++;
                        setPiece(x, y, whichPiece[rotation], MOVING_PIECE_COLOR);
                        updateScreen();
                    }
                    goto saving;

                case(SDLK_RIGHT):
                    if(isPossible(x, y, whichPiece[rotation], 'r') == true)
                    {
                        setPiece(x,y,whichPiece[rotation],BLACK);
                        x++;
                        setPiece(x, y, whichPiece[rotation], MOVING_PIECE_COLOR);
                        updateScreen();
                    }
            break;

                case(SDLK_LEFT):
                    if(isPossible(x, y, whichPiece[rotation], 'l') == true)
                    {
                        setPiece(x, y, whichPiece[rotation], BLACK);
                        x--;
                        setPiece(x, y, whichPiece[rotation], MOVING_PIECE_COLOR);
                        updateScreen();
                    }
            break;

                case(SDLK_SPACE):
                    if(isPossible(x, y, whichPiece[(rotation + 1) % 4], '0'))
                    {
                        setPiece(x, y, whichPiece[rotation], BLACK);
                        ++rotation;
              rotation %= 4;
                        setPiece(x, y, whichPiece[rotation], MOVING_PIECE_COLOR);
                        updateScreen();
                    }
                    else if (isPossible(x - 1, y, whichPiece[(rotation + 1) % 4], '0'))
                    {
                        setPiece(x, y, whichPiece[rotation], BLACK);
                        ++rotation;
              rotation%=4;
              x--;
                        setPiece(x, y, whichPiece[rotation], MOVING_PIECE_COLOR);
                        updateScreen();
                    }
                    else if (isPossible(x + 1, y, whichPiece[(rotation + 1) % 4], '0'))
                    {
                        setPiece(x, y, whichPiece[rotation], BLACK);
                        ++rotation;
              rotation %= 4;
              x++;
                        setPiece(x, y, whichPiece[rotation], MOVING_PIECE_COLOR);
                        updateScreen();
                    }
                    break;
            }
            usleep(TIME);
        }
        if(isPossible(x, y, whichPiece[rotation], 'd') == true)
        {
            setPiece(x,y,whichPiece[rotation],BLACK);
            y++;
            setPiece(x,y,whichPiece[rotation], MOVING_PIECE_COLOR);
            updateScreen();
        }
        else
    {
      break;
    }
    }
saving:
    for(column = 0; column < 4; column++)
  {
    for(row = 0; row < 4; row++)
    {
      if(whichPiece[rotation][column][row] != 0)
      {
        gameArray[x + column][y + row][2] = STATIC_PIECE_COLOR;
      }
    }
  }
    return true;
}

void deleteRows()
{
  int column, row;
    int deletedRow;
    int checks = 1;

    for(row = 0; row < GAME_HEIGHT; row++)
    {
        for(column = 0; column < GAME_WIDTH; column++)
        {
            checks *= gameArray[column][row][2];
            if (checks == 0)
      {
        break;
      }
        }
        if(checks != 0)
        {
            for(deletedRow = row; deletedRow > 0; deletedRow--)
      {
        for(column = 0; column < GAME_WIDTH; column++)
        {
          gameArray[column][deletedRow][2] = gameArray[column][deletedRow - 1][2];
        }
      }

            for(column = 0; column < GAME_WIDTH; column++)
      {
        gameArray[column][0][2] = 0;
      }
        }
        checks = 1;
    }
}

void gameOver()
{
    filledRect(0, 0, screenWidth() - 1, screenHeight() - 1, BLACK);
    textout((screenWidth() - 1) / 2 - 60, (screenHeight() - 1) / 2, "GAME OVER", BLUE);
    updateScreen();
    sleep(GAME_OVER_TIME);
}