tetrisaaa

#include "primlib.h"
#include "pieces.inl"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

#define COLOUR_BACKGROUND BLACK
#define COLOUR_FRAME WHITE
#define COLOUR_PIECE_STATIC BLUE
#define COLOUR_PIECE_MOVING MAGENTA
#define COLOUR_PIECE_COVERED RED
#define COLOUR_PIECE_FRAME BLACK
#define COLOUR_TEXT MAGENTA

#define COLUMNS 10
#define ROWS 20
#define BLOCK_SIZE 20
#define NUMBER_OF_PIECES 7
#define NUMBER_OF_ROTATIONS 4
#define PIECE_ARRAY_SIZE 4
#define FALLING_RATE 300
#define LOOP_ITERATION_TIME 50
#define QUICK_FALL_COEFFICIENT 5
#define FRAME_THICKNESS 3
#define NUMBER_OF_END_TEXTS 3
#define INSTRUCTION_SPACING 10
#define WINDOWS_DISTANCE 2//co to
#define FONT_SIZE 8
#define EMPTY_SPACE 0
#define MOVEMENT_LEFT -1
#define MOVEMENT_RIGHT 1

#define TEXT_INITIAL_CONTENT "PRESS ANY KEY TO START"
#define TEXT_NEXT_PIECE_CONTENT "NEXT PIECE:"
#define TEXT_GAMEOVER_CONTENT "GAME OVER"
#define TEXT_INSTRUCTION1_CONTENT "ESC TO CLOSE"
#define TEXT_INSTRUCTION2_CONTENT "SPACE TO TRY AGAIN"


#define BOARD_LEFTX (screenWidth() - sizeOfWindowNextPiece) / 2 - (calculatedBlockSize * COLUMNS) / 2
#define BOARD_BOTTOMY screenHeight() / 2 + (calculatedBlockSize * ROWS)/  2
#define BOARD_RIGHTX (screenWidth() - sizeOfWindowNextPiece) /2 + (calculatedBlockSize * COLUMNS) / 2
#define BOARD_TOPY screenHeight() / 2 - (calculatedBlockSize * ROWS) / 2
#define BOARD_FRAME_LEFTX BOARD_LEFTX - FRAME_THICKNESS
#define BOARD_FRAME_BOTTOMY BOARD_BOTTOMY + FRAME_THICKNESS
#define BOARD_FRAME_RIGHTX BOARD_RIGHTX + FRAME_THICKNESS
#define BOARD_FRAME_TOPY BOARD_TOPY - FRAME_THICKNESS

#define GAME_OVER_BOX_LEFT_X BOARD_FRAME_LEFTX
#define GAME_OVER_BOX_BOTTOM_Y INSTRUCTION2_TEXT_Y + INSTRUCTION_SPACING+FONT_SIZE
#define GAME_OVER_BOX_RIGHT_X BOARD_FRAME_RIGHTX
#define GAME_OVER_BOX_TOP_Y screenHeight()/2-NUMBER_OF_END_TEXTS * INSTRUCTION_SPACING
#define GAME_OVER_FRAME_LEFT_X BOARD_FRAME_LEFTX
#define GAME_OVER_FRAME_BOTTOM_Y GAME_OVER_BOX_BOTTOM_Y + FRAME_THICKNESS
#define GAME_OVER_FRAME_RIGHT_X BOARD_FRAME_RIGHTX
#define GAME_OVER_FRAME_TOP_Y GAME_OVER_BOX_TOP_Y - FRAME_THICKNESS

#define NEXT_PIECE_BOX_LEFT_X NEXT_PIECE_FRAME_LEFT_X + FRAME_THICKNESS
#define NEXT_PIECE_BOX_BOTTOM_Y NEXT_PIECE_FRAME_BOTTOM_Y - FRAME_THICKNESS
#define NEXT_PIECE_BOX_RIGHT_X NEXT_PIECE_FRAME_RIGHT_X - FRAME_THICKNESS
#define NEXT_PIECE_BOX_TOP_Y NEXT_PIECE_FRAME_TOP_Y + FRAME_THICKNESS
#define NEXT_PIECE_FRAME_LEFT_X screenWidth() - sizeOfWindowNextPiece
#define NEXT_PIECE_FRAME_BOTTOM_Y NEXT_PIECE_FRAME_TOP_Y + sizeOfWindowNextPiece - BORDER_TO_BOARD_DISTANCE / 2
#define NEXT_PIECE_FRAME_RIGHT_X NEXT_PIECE_FRAME_LEFT_X + sizeOfWindowNextPiece - BORDER_TO_BOARD_DISTANCE / 2
#define NEXT_PIECE_FRAME_TOP_Y BOARD_FRAME_TOPY+2*INSTRUCTION_SPACING

#define INITIAL_TEXT_X (screenWidth() - sizeOfWindowNextPiece) / 2 - (float)strlen(TEXT_INITIAL_CONTENT) / 2  *FONT_SIZE
#define INITIAL_TEXT_Y screenHeight() / 3
#define NEXT_PIECE_TEXT_X NEXT_PIECE_FRAME_LEFT_X
#define NEXT_PIECE_TEXT_Y BOARD_FRAME_TOPY
#define GAME_OVER_TEXT_X (screenWidth() - sizeOfWindowNextPiece) / 2 - (float)strlen(TEXT_GAMEOVER_CONTENT) / 2 * FONT_SIZE
#define GAME_OVER_TEXT_Y GAME_OVER_BOX_TOP_Y + INSTRUCTION_SPACING
#define INSTRUCTION1_TEXT_X (screenWidth() - sizeOfWindowNextPiece) / 2 - (float)strlen(TEXT_INSTRUCTION1_CONTENT) / 2 * FONT_SIZE
#define INSTRUCTION1_TEXT_Y GAME_OVER_TEXT_Y + 2 * INSTRUCTION_SPACING
#define INSTRUCTION2_TEXT_X (screenWidth() - sizeOfWindowNextPiece) / 2 - (float)strlen(TEXT_INSTRUCTION2_CONTENT) / 2 * FONT_SIZE
#define INSTRUCTION2_TEXT_Y INSTRUCTION1_TEXT_Y + INSTRUCTION_SPACING

#define BLOCK_X BOARD_LEFTX + calculatedBlockSize * boardXPosition
#define BLOCK_Y BOARD_BOTTOMY-calculatedBlockSize * boardYPosition
#define NEXT_PIECE_BLOCK_X NEXT_PIECE_BOX_LEFT_X + BLOCK_SIZE * boardXPosition + 10
#define NEXT_PIECE_BLOCK_Y NEXT_PIECE_BOX_TOP_Y + BLOCK_SIZE * (boardYPosition + 1) + 10

#define SPAWN_BOARD_POSITION COLUMNS / 2 - PIECE_ARRAY_SIZE / 4
#define QUICK_FALL LOOP_ITERATION_TIME * QUICK_FALL_COEFFICIENT
#define NEXT_PIECE_NOT_DISPLAYED NUMBER_OF_PIECES + 1
#define BLOCK_COVERED 2
#define BORDER_TO_BOARD_DISTANCE 4 * FRAME_THICKNESS


void initialize(void);
void randomSpawn(void);
void drawing(void);
void falling(void);
void moving(void);
void rotating(void);
void drop(void);
void cleaningLine(void);
void gameOver(void);
void checkingBoundry(void);

int movingGameState[COLUMNS][ROWS];
int staticGameState[COLUMNS][ROWS];
int pressedButton, checkSpawn, timeCounter, currentMovingPiece, nextMovingPiece;
int currentMovingPieceRotation, nextMovingPieceRotation, loseCondition, calculatedBlockSize, sizeOfWindowNextPiece;


int main(int argc, char* argv[])
{

    if(initGraph())
    {
        exit(3);
    }

    do
    {
        initialize();
        pressedButton = pollkey();
        if(pressedButton == SDLK_ESCAPE)
        {
            exit(3);
        }
        else if((pressedButton != -1) && (pressedButton != SDLK_ESCAPE))
        {
            nextMovingPiece = rand()%NUMBER_OF_PIECES;
            nextMovingPieceRotation = rand()%NUMBER_OF_ROTATIONS;
            do
            {
                if(checkSpawn)
                {
                    randomSpawn();
                }
                if(loseCondition)
                {
                gameOver();
                break;
                }

                drawing();
                updateScreen();
                pressedButton = pollkey();

                switch(pressedButton)
                {
                    case SDLK_LEFT:
                    case SDLK_RIGHT:
                        moving();
                        break;
                    case SDLK_SPACE:
                        rotating();
                        break;
                    case SDLK_DOWN:
                        drop();
                        break;
                    case SDLK_ESCAPE:
                        exit(3);
                }

                if(timeCounter >= FALLING_RATE)
                {
                    falling();
                }
                cleaningLine();

                SDL_Delay(LOOP_ITERATION_TIME);

                timeCounter += LOOP_ITERATION_TIME;
            }while(1);
        }
    }while(1);

  return 0;
}


void initialize()
{
    int initialHorizontalPosition;
    int initialVerticalPosition;

    srand(time(NULL));
    checkSpawn = 1;
    timeCounter = 0;
    currentMovingPiece = 0;
    currentMovingPieceRotation = 0;
    loseCondition = 0;
    nextMovingPiece = NEXT_PIECE_NOT_DISPLAYED;

    for(initialHorizontalPosition = 0; initialHorizontalPosition < COLUMNS; initialHorizontalPosition++)
    {
        for(initialVerticalPosition = 0; initialVerticalPosition < ROWS; initialVerticalPosition++)
        {
            movingGameState[initialHorizontalPosition][initialVerticalPosition] = EMPTY_SPACE;//here
            staticGameState[initialHorizontalPosition][initialVerticalPosition] = EMPTY_SPACE;//here
        }
    }

    sizeOfWindowNextPiece = BORDER_TO_BOARD_DISTANCE + (PIECE_ARRAY_SIZE + 1) * BLOCK_SIZE;

    if(COLUMNS > ROWS)
    {
        calculatedBlockSize = (screenWidth() - sizeOfWindowNextPiece-  BORDER_TO_BOARD_DISTANCE) / (COLUMNS);
    }else if(ROWS >= COLUMNS)
    {
    calculatedBlockSize = (screenHeight() - BORDER_TO_BOARD_DISTANCE) / (ROWS);
    }

    drawing();
    textout(INITIAL_TEXT_X, INITIAL_TEXT_Y ,TEXT_INITIAL_CONTENT, COLOUR_TEXT);
    updateScreen();
}


void randomSpawn()//al this functon what doese it do
{
    int arrayX;
    int arrayPositionY;
    int arrayPieceY;

    currentMovingPiece = nextMovingPiece;
    nextMovingPiece = rand()%NUMBER_OF_PIECES;
    currentMovingPieceRotation = nextMovingPieceRotation;
    nextMovingPieceRotation = rand()%NUMBER_OF_ROTATIONS;

    for(arrayX = 0; arrayX < PIECE_ARRAY_SIZE; arrayX++)
    {
        for(arrayPositionY = 0, arrayPieceY = PIECE_ARRAY_SIZE - 1; arrayPositionY < PIECE_ARRAY_SIZE; arrayPositionY++, arrayPieceY--)
        {
            if((staticGameState[SPAWN_BOARD_POSITION+arrayX][ROWS-PIECE_ARRAY_SIZE + arrayPositionY] != 0) && (pieces[currentMovingPiece][currentMovingPieceRotation][arrayX][arrayPieceY] != 0))
            {
                staticGameState[SPAWN_BOARD_POSITION+arrayX][ROWS-PIECE_ARRAY_SIZE+arrayPositionY] = 0;
                movingGameState[SPAWN_BOARD_POSITION+arrayX][ROWS-PIECE_ARRAY_SIZE+arrayPositionY] = BLOCK_COVERED;
                loseCondition = 1;
            }
            else if(staticGameState[SPAWN_BOARD_POSITION + arrayX][ROWS-PIECE_ARRAY_SIZE+arrayPositionY] == 0)
                    {
                    movingGameState[SPAWN_BOARD_POSITION + arrayX][ROWS-PIECE_ARRAY_SIZE+arrayPositionY] = pieces[currentMovingPiece][currentMovingPieceRotation]   [arrayX][arrayPieceY];
                    }
        }
    }

    checkSpawn = 0;
}


void drawing()
{
    int boardXPosition;
    int boardYPosition;

    filledRect(0, 0, screenWidth() - 1, screenHeight() - 1, COLOUR_BACKGROUND);

    filledRect(BOARD_FRAME_LEFTX, BOARD_FRAME_BOTTOMY, BOARD_FRAME_RIGHTX, BOARD_FRAME_TOPY, COLOUR_FRAME);
    filledRect(BOARD_LEFTX, BOARD_BOTTOMY, BOARD_RIGHTX, BOARD_TOPY, COLOUR_BACKGROUND);

    for(boardXPosition = 0; boardXPosition < COLUMNS; boardXPosition++)
    {
        for(boardYPosition = 0; boardYPosition < ROWS; boardYPosition++)
        {
            if(movingGameState[boardXPosition][boardYPosition] > 0)
            {
                if(movingGameState[boardXPosition][boardYPosition] == BLOCK_COVERED)
                {
                    filledRect(BLOCK_X, BLOCK_Y, BLOCK_X + calculatedBlockSize, BLOCK_Y - calculatedBlockSize, COLOUR_PIECE_COVERED);
                    rect(BLOCK_X, BLOCK_Y, BLOCK_X + calculatedBlockSize, BLOCK_Y - calculatedBlockSize, COLOUR_PIECE_FRAME);
                }
                else
                {
                    filledRect(BLOCK_X, BLOCK_Y, BLOCK_X + calculatedBlockSize, BLOCK_Y - calculatedBlockSize, COLOUR_PIECE_MOVING);
                    rect(BLOCK_X, BLOCK_Y, BLOCK_X + calculatedBlockSize, BLOCK_Y - calculatedBlockSize, COLOUR_PIECE_FRAME);
                }
            }
            else if(staticGameState[boardXPosition][boardYPosition] > 0)
            {
                filledRect(BLOCK_X,BLOCK_Y,BLOCK_X+calculatedBlockSize,BLOCK_Y-calculatedBlockSize,COLOUR_PIECE_STATIC);
                rect(BLOCK_X,BLOCK_Y,BLOCK_X+calculatedBlockSize,BLOCK_Y-calculatedBlockSize,COLOUR_PIECE_FRAME);
            }
        }
    }

    filledRect(NEXT_PIECE_FRAME_LEFT_X, NEXT_PIECE_FRAME_BOTTOM_Y, NEXT_PIECE_FRAME_RIGHT_X, NEXT_PIECE_FRAME_TOP_Y, COLOUR_FRAME);
    filledRect(NEXT_PIECE_BOX_LEFT_X, NEXT_PIECE_BOX_BOTTOM_Y, NEXT_PIECE_BOX_RIGHT_X, NEXT_PIECE_BOX_TOP_Y, COLOUR_BACKGROUND);
    textout(NEXT_PIECE_TEXT_X, NEXT_PIECE_TEXT_Y, TEXT_NEXT_PIECE_CONTENT, COLOUR_TEXT);


    if(nextMovingPiece != NEXT_PIECE_NOT_DISPLAYED)
    {
        for(boardXPosition = 0; boardXPosition < PIECE_ARRAY_SIZE; boardXPosition++)
        {
            for(boardYPosition = 0; boardYPosition < PIECE_ARRAY_SIZE; boardYPosition++)
            {
                if(pieces[nextMovingPiece][nextMovingPieceRotation][boardXPosition][boardYPosition] > 0)
                {
                    filledRect(NEXT_PIECE_BLOCK_X, NEXT_PIECE_BLOCK_Y, NEXT_PIECE_BLOCK_X + BLOCK_SIZE,
                               NEXT_PIECE_BLOCK_Y -BLOCK_SIZE, COLOUR_PIECE_MOVING);
                    rect(NEXT_PIECE_BLOCK_X, NEXT_PIECE_BLOCK_Y, NEXT_PIECE_BLOCK_X + BLOCK_SIZE,
                         NEXT_PIECE_BLOCK_Y - BLOCK_SIZE, COLOUR_PIECE_FRAME);
                }
            }
        }
    }
}


void falling(void)
{
    int fallingX, fallingY;
    int convertToStatic = 0;

    for(fallingY = 0; fallingY < ROWS; fallingY++)
    {
        for(fallingX = 0; fallingX < COLUMNS; fallingX++)
        {
            if(((fallingY == 0) && (movingGameState[fallingX][fallingY] > 0 )) || ((fallingY > 0) && (movingGameState[fallingX][fallingY] > 0) && (staticGameState[fallingX][fallingY - 1]> 0)))
            {
                convertToStatic = 1;
                break;
            }
        }
        if(convertToStatic)
        {
            break;
        }
    }

    for(fallingY = 0; fallingY < ROWS; fallingY++)
    {
        for(fallingX = 0;fallingX < COLUMNS; fallingX++)
        {
            if((convertToStatic == 1) && (movingGameState[fallingX][fallingY] > 0))
            {
                staticGameState[fallingX][fallingY] = movingGameState[fallingX][fallingY];
                movingGameState[fallingX][fallingY] = 0;
                checkSpawn = 1;
            }
            else if((convertToStatic == 0) && (movingGameState[fallingX][fallingY] > 0))
            {
                movingGameState[fallingX][fallingY - 1] = movingGameState[fallingX][fallingY];
                movingGameState[fallingX][fallingY] = 0;
                }
        }
    }

    timeCounter = 0;
}


void moving(void)
{
    int directionOfMovement, movementXPosition, movementYPosition, moveable = 1;

    if(pressedButton==SDLK_LEFT)
    {
        directionOfMovement = MOVEMENT_LEFT;
    }
    else if(pressedButton == SDLK_RIGHT)
    {
        directionOfMovement = MOVEMENT_RIGHT;
    }

    for(movementYPosition = 0; movementYPosition < ROWS; movementYPosition++)
    {
        if(directionOfMovement > 0)
        {
            for(movementXPosition = COLUMNS - 1; movementXPosition >= 0; movementXPosition--)
            {
                if((movingGameState[movementXPosition][movementYPosition] > 0) &&((movementXPosition == COLUMNS - 1)||(staticGameState[movementXPosition+directionOfMovement][movementYPosition] > 0)))
                {
                    moveable = 0;
                    break;
                }
            }
        }
        else if(directionOfMovement < 0)
        {
            for(movementXPosition = 0; movementXPosition < COLUMNS; movementXPosition++)
            {
                if((movingGameState[movementXPosition][movementYPosition] > 0) && ((movementXPosition == 0)||(staticGameState[movementXPosition+directionOfMovement][movementYPosition] > 0)))
                {
                    moveable  0;
                    break;
                }
            }
        }
        if(moveable == 0)
        {
            break;
        }
    }

    if(moveable)
    {
        for(movementYPosition = 0;movementYPosition < ROWS; movementYPosition++)
        {
            if(directionOfMovement > 0)
            {
                for(movementXPosition = COLUMNS - 1;movementXPosition >= 0; movementXPosition--)
                {
                    if(movingGameState[movementXPosition][movementYPosition] > EMPTY_SPACE)
                    {
                        movingGameState[movementXPosition + directionOfMovement][movementYPosition] = movingGameState[movementXPosition][movementYPosition];
                        movingGameState[movementXPosition][movementYPosition] = EMPTY_SPACE;
                    }
                }
            }
            else if(directionOfMovement < 0)
            {
                for(movementXPosition = 0; movementXPosition < COLUMNS; movementXPosition++)
                {
                    if(movingGameState[movementXPosition][movementYPosition] > EMPTY_SPACE)
                    {
                        movingGameState[movementXPosition+directionOfMovement][movementYPosition] = movingGameState[movementXPosition][movementYPosition];
                        movingGameState[movementXPosition][movementYPosition] = EMPTY_SPACE;
                    }
                }
            }
        }
    }
}


void rotating(void)
{
    int nextPieceX,nextPieceY,xBeforeRotation,yBeforeRotation,newRotation,foundCenter,rotationIsValid, nextPieceStartX,nextPieceStartY,pieceWidth,pieceHeight,piece_inversed_height;

    if(currentMovingPieceRotation == NUMBER_OF_ROTATIONS - 1)
    {
        newRotation=0;
    }
    else if((currentMovingPieceRotation >= 0) && (currentMovingPieceRotation < NUMBER_OF_ROTATIONS - 1))
    {
        newRotation = currentMovingPieceRotation + 1;
    }

    foundCenter = 0;
    for(pieceWidth = 0; pieceWidth < COLUMNS; pieceWidth++)
    {
        for(pieceHeight = 0;pieceHeight < ROWS; pieceHeight++)
        {
            if(movingGameState[pieceWidth][pieceHeight] > 1)
            {
                foundCenter = 1;
                xBeforeRotation = pieceWidth;
                yBeforeRotation = pieceHeight;
                break;
            }
        }
        if(foundCenter)
        {
            break;
        }
    }

    foundCenter = 0;
    for(pieceWidth = 0; pieceWidth < PIECE_ARRAY_SIZE; pieceWidth++)
    {
        for(pieceHeight = 0; pieceHeight < PIECE_ARRAY_SIZE; pieceHeight++)
        {
            if(pieces[currentMovingPiece][newRotation][pieceWidth][pieceHeight] > 1)
            {
                foundCenter = 1;
                nextPieceX = pieceWidth;
                nextPieceY = PIECE_ARRAY_SIZE - 1- pieceHeight;
                break;
            }
        }
        if(foundCenter)
        {
            break;
        }
    }

    nextPieceStartX  = xBeforeRotation - nextPieceX;
    nextPieceStartY = yBeforeRotation - nextPieceY;

    if(nextPieceStartX >= 0 && nextPieceStartY >= 0)
    {
        rotationIsValid = 1;
        for(pieceWidth = 0; pieceWidth < PIECE_ARRAY_SIZE; pieceWidth++)
        {
            for(pieceHeight = 0,piece_inversed_height = PIECE_ARRAY_SIZE - 1;pieceHeight < PIECE_ARRAY_SIZE; pieceHeight++, piece_inversed_height--)
            {
                if((pieces[currentMovingPiece][newRotation][pieceWidth][piece_inversed_height]>0)&&
                (((nextPieceStartX+pieceWidth)>=COLUMNS)||((nextPieceStartY+pieceHeight)>=ROWS)||
                ((nextPieceStartX+pieceWidth)<0)||((nextPieceStartY+pieceHeight)<0)||
                (staticGameState[nextPieceStartX+pieceWidth][nextPieceStartY+pieceHeight]>0)))
                {
                rotationIsValid = 0;
                break;
                }
            }
            if(rotationIsValid == 0)
            {
                break;
            }
        }
    }else rotationIsValid = 0;

    if(rotationIsValid)
    {
        for(pieceWidth = 0; pieceWidth < COLUMNS; pieceWidth++)
        {
            for(pieceHeight = 0;pieceHeight < ROWS; pieceHeight++)
            {
                movingGameState[pieceWidth][pieceHeight] = EMPTY_SPACE;
            }
        }
        for(pieceHeight = 0, piece_inversed_height = PIECE_ARRAY_SIZE - 1; pieceHeight < PIECE_ARRAY_SIZE; pieceHeight++, piece_inversed_height--)
        {
            for(pieceWidth = 0; pieceWidth < PIECE_ARRAY_SIZE; pieceWidth++)
            {
                if((nextPieceStartX + pieceWidth >= 0) && (nextPieceStartX + pieceWidth < COLUMNS) &&
                    (nextPieceStartY+pieceHeight >= 0) && (nextPieceStartY + pieceHeight < ROWS))
                {
                    movingGameState[nextPieceStartX + pieceWidth][nextPieceStartY + pieceHeight] = pieces[currentMovingPiece][newRotation][pieceWidth][piece_inversed_height];
                }
            }
        }
        currentMovingPieceRotation=newRotation;
    }
}


void drop(void)
{
    while(checkSpawn == 0) falling();
    timeCounter = 0;
}


void cleaningLine(void)
{
    int rowIndex,columnIndex,emptyColumnIndex,moveRowDown,takenSpacesCount;

    for(rowIndex=0;rowIndex<ROWS;rowIndex++)
    {
        takenSpacesCount=0;
        for(columnIndex=0;columnIndex<COLUMNS;columnIndex++)
        {
            if(staticGameState[columnIndex][rowIndex]>EMPTY_SPACE)
            {
                takenSpacesCount++;
            }
            else if(staticGameState[columnIndex][rowIndex]==EMPTY_SPACE)
            {
                break;
            }
            if(takenSpacesCount==COLUMNS)
                    for(emptyColumnIndex=0;emptyColumnIndex<COLUMNS;emptyColumnIndex++)
                    {
                        staticGameState[emptyColumnIndex][rowIndex] = EMPTY_SPACE;
                        for(moveRowDown = rowIndex;moveRowDown<ROWS - 1;moveRowDown++)
                        {
                            staticGameState[emptyColumnIndex][moveRowDown] = staticGameState[emptyColumnIndex][moveRowDown + 1];
                        }
                    }
        }
    }
}


void gameOver(void)
{
    nextMovingPiece = 0;
    drawing();
    filledRect(GAME_OVER_FRAME_LEFT_X, GAME_OVER_FRAME_BOTTOM_Y, GAME_OVER_FRAME_RIGHT_X, GAME_OVER_FRAME_TOP_Y, COLOUR_FRAME);
    filledRect(GAME_OVER_BOX_LEFT_X, GAME_OVER_BOX_BOTTOM_Y, GAME_OVER_BOX_RIGHT_X, GAME_OVER_BOX_TOP_Y, COLOUR_BACKGROUND);
    textout(GAME_OVER_TEXT_X,GAME_OVER_TEXT_Y,TEXT_GAMEOVER_CONTENT,COLOUR_TEXT);
    textout(INSTRUCTION1_TEXT_X, INSTRUCTION1_TEXT_Y, TEXT_INSTRUCTION1_CONTENT, COLOUR_TEXT);
    textout(INSTRUCTION2_TEXT_X, INSTRUCTION2_TEXT_Y, TEXT_INSTRUCTION2_CONTENT, COLOUR_TEXT);
    updateScreen();
    do{
        pressedButton = pollkey();
        if(pressedButton == SDLK_ESCAPE)
        {
            exit(3);
        }
        if(pressedButton == SDLK_SPACE)
        {
            break;
        }
    }while(1);
}