Hanoi Tower

#include "primlib.h"
#define NUMBER_OF_RODS 5
#define HEIGHT_OF_GROUND  (screenHeight() - WIDTH_GROUND)
#define WIDTH_GROUND 50
#define WIDTH_OF_ROD 5
#define NUMBER_OF_DISKS 9
#define STEP 2
#define DISKS_WIDTH 10
#define HEIGHT_OF_ROD 200
#define DISKS_HEIGHT ((HEIGHT_OF_ROD - 15) / NUMBER_OF_DISKS)
#define FRAME_COLOR BLACK
#define DISKS_COLOR BLUE
#define ROD_COLOR RED
#define TOWERS_COLOR GREEN

int gameArray[NUMBER_OF_DISKS + 1][NUMBER_OF_RODS];
int howManyDisksArr[NUMBER_OF_RODS];

double DistanceBetweenRods();

void DrawRods();

void DrawDisks();

void Draw();

void InitialGame();

int FindingTopDisc(int tower);

void MovingConditions();

int Win();

void HowManyDisks(int tower);

void Animation(int startTower, int stopTower, int startRow, int stopRow);

void MovingUp(int position_x, int position_y, int diskValue, int stopTower, int direction);

void MovingHorizontally(int position_x, int position_y, int stopTower, int diskValue, int direction);

void MovingDown(int position_x, int position_y, int stopTower, int diskValue);

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

    InitialGame();

    while(1){

        filledRect(0, 0, screenWidth() - 1, screenHeight() - 1, BLACK);
        filledRect(0, screenHeight(), screenWidth(), screenHeight() - 50 , YELLOW);
        DrawRods();
        DrawDisks();
        updateScreen();


        if(Win() == 1)
        {
            break;
        }
        MovingConditions();
        updateScreen();
        if (isKeyDown(SDLK_SPACE) == 1){
            break;
        }
    }

        SDL_Delay(40);

    return 0;
}

void Draw()
{
  filledRect(0, 0, screenWidth() - 1, screenHeight() - 1, BLACK);
  filledRect(0, screenHeight(), screenWidth(), screenHeight() - 50 , YELLOW);
  DrawRods();
  DrawDisks();

}

double DistanceBetweenRods()
{
    return (screenWidth()/(NUMBER_OF_RODS + 1));
}

void DrawRods()
{
    int column;
    for(column = 0; column < NUMBER_OF_RODS; column++){

      filledRect((column * 2 + 1) * screenWidth() / (NUMBER_OF_RODS * 2) - WIDTH_OF_ROD / 2,
                  screenHeight() - ((NUMBER_OF_DISKS + 1) * DISKS_HEIGHT + WIDTH_GROUND),
                  (column * 2 + 1) * screenWidth() / (NUMBER_OF_RODS * 2) + WIDTH_OF_ROD / 2,
                  screenHeight() - WIDTH_GROUND - 1, TOWERS_COLOR);
        /*filledRect((DistanceBetweenRods() * iterationNumber) - WIDTH_OF_ROD, HEIGHT_OF_GROUND - 1,
        (DistanceBetweenRods() * iterationNumber) + WIDTH_OF_ROD, HEIGHT_OF_GROUND - HEIGHT_OF_ROD , ROD_COLOR);
    */}
}

void DrawDisks()
{
    int row, column, individualWidth;
    for(column = 0; column < NUMBER_OF_RODS; column++){
      for(row = 0; row < NUMBER_OF_DISKS; row++){
                individualWidth = DISKS_WIDTH * gameArray[row][column];
        if(gameArray[row][column] != 0){
                    if(individualWidth > ((screenWidth() / NUMBER_OF_RODS) - WIDTH_OF_ROD) / 2){
                        individualWidth = ((screenWidth() / NUMBER_OF_RODS) - WIDTH_OF_ROD) / 2;
                    }
          filledRect(screenWidth() / (NUMBER_OF_RODS * 2) * ( 1 + 2 * column) - individualWidth - WIDTH_OF_ROD / 2,
                    //(DistanceBetweenRods() * (column + 1)) - (DISKS_WIDTH * gameArray[row][column]),
                                        HEIGHT_OF_GROUND - (NUMBER_OF_DISKS - row) * DISKS_HEIGHT,
                                        //screenHeight() - (NUMBER_OF_DISKS - row) * DISKS_HEIGHT - WIDTH_GROUND,
                    //                   screenHeight()-(NUMBER_OF_DISKS-row)*DISKS_HEIGHT- WIDTH_GROUND,
                    screenWidth() / (NUMBER_OF_RODS * 2) * (1+2*column)+ individualWidth + WIDTH_OF_ROD/2,
                    //(DistanceBetweenRods() * (column + 1)) + (DISKS_WIDTH * gameArray[row][column]),
                    HEIGHT_OF_GROUND - ((NUMBER_OF_DISKS - row - 1) * DISKS_HEIGHT) - 1, DISKS_COLOR);
                    //                   screenHeight()-((NUMBER_OF_DISKS-row-1)*DISKS_HEIGHT)- WIDTH_GROUND -1, DISKS_COLOR);

          rect(screenWidth()/(NUMBER_OF_RODS*2)*(1+2*column)-DISKS_WIDTH * gameArray[row][column]-WIDTH_OF_ROD/2,
          //(DistanceBetweenRods() * (column + 1)) - (DISKS_WIDTH * gameArray[row][column]),
          HEIGHT_OF_GROUND - (NUMBER_OF_DISKS - row) * DISKS_HEIGHT,
          //              screenHeight()-(NUMBER_OF_DISKS-row)*DISKS_HEIGHT- WIDTH_GROUND,
          screenWidth()/(NUMBER_OF_RODS*2)*(1+2*column)+DISKS_WIDTH * gameArray[row][column]+WIDTH_OF_ROD/2,
          //              (DistanceBetweenRods() * (column + 1)) + (DISKS_WIDTH * gameArray[row][column]),
          HEIGHT_OF_GROUND - ((NUMBER_OF_DISKS - row - 1) * DISKS_HEIGHT) - 1, FRAME_COLOR);
          //              screenHeight()-((NUMBER_OF_DISKS-row-1)*DISKS_HEIGHT)- WIDTH_GROUND -1, FRAME_COLOR);

    }
  }
}


}

void InitialGame()
{
  int i, j;
  for(i = 0; i < NUMBER_OF_DISKS; i++)
  {
    for(j = 0; j < NUMBER_OF_RODS; j++)
    {
      if(j==0){
        gameArray[i][j] = i + 1;
      } else {
        gameArray[i][j] = 0;
      }
    }
  }
}

int FindingTopDisc(int tower)
{
    int row, topDisc;
    for(row = NUMBER_OF_DISKS; row >= 0; row--)
    {
        if(gameArray[row][tower] != 0)
        {
            topDisc = row;
        }
    }
    return topDisc;
}

void MovingConditions()
{
  int startTower, stopTower, startRow, stopRow;
  startTower = getkey() - '1';
  stopTower = getkey() - '1';
  if((startTower < NUMBER_OF_RODS) && (startTower >= 0) && (startTower != stopTower) &&
     (stopTower >= 0) && (stopTower < NUMBER_OF_RODS))
  {
    startRow = NUMBER_OF_DISKS;
    stopRow = NUMBER_OF_DISKS;
    gameArray[NUMBER_OF_DISKS][startTower] = NUMBER_OF_DISKS;
    gameArray[NUMBER_OF_DISKS][stopTower] = NUMBER_OF_DISKS;

    startRow = FindingTopDisc(startTower);
    stopRow = FindingTopDisc(stopTower);

  if((startRow != NUMBER_OF_DISKS) && (gameArray[startRow][startTower] <= gameArray[stopRow][stopTower]))
  {
    Animation(startTower, stopTower, startRow, stopRow - 1 );
  }
}
}

int Win()
{
  if(gameArray[0][NUMBER_OF_RODS - 1] == 1){
    textout((screenWidth()/2) - 100, (screenHeight()/2) - 50, "YOU WON", RED);
    updateScreen();
    getkey();
    return 1;
  }
  return 0;
}

void HowManyDisks(int tower)
{
  int row;
  howManyDisksArr[tower] = 0;
  for(row = 0; row < NUMBER_OF_DISKS; row++)
  {
    if(gameArray[row][tower] != 0)
    {
      howManyDisksArr[tower] += 1;
    }
  }
}

void Animation(int startTower, int stopTower, int startRow, int stopRow)
{
    int position_y, position_x, diskValue, direction;

    HowManyDisks(startTower);

    diskValue = gameArray[startRow][startTower];
    gameArray[startRow][startTower] = 0;

    position_y = screenHeight() - (WIDTH_GROUND + DISKS_HEIGHT * howManyDisksArr[startTower]);
    position_x = (startTower * 2 + 1) * screenWidth() / (NUMBER_OF_RODS * 2);

    if(startTower < stopTower)
  {
        direction = 1;
  }
  if(startTower > stopTower)
    {
    direction = -1;
  }
  MovingUp( position_x, position_y, diskValue, stopTower, direction);
    HowManyDisks(stopTower);

  gameArray[stopRow][stopTower] = diskValue;
}

void MovingUp(int position_x, int position_y, int diskValue, int stopTower, int direction)
{
  while((position_y + STEP) >= (screenHeight() - (WIDTH_GROUND + (NUMBER_OF_DISKS + 4) * DISKS_HEIGHT)))
    {
    Draw();
    filledRect(position_x - (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH),
    position_y, position_x + (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH),
    position_y + DISKS_HEIGHT, DISKS_COLOR);
    rect(position_x - (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y,
    position_x + (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y + DISKS_HEIGHT, FRAME_COLOR);

    position_y -= STEP;
    updateScreen();
    }
    MovingHorizontally(position_x, position_y, stopTower, diskValue, direction);
}

void MovingHorizontally(int position_x, int position_y, int stopTower, int diskValue, int direction)
{
  while(abs(position_x - (stopTower * 2 + 1) * screenWidth() / (NUMBER_OF_RODS * 2)) >= STEP)
        {
        Draw();
        filledRect(position_x - (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y,
    position_x + (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH),
    position_y + DISKS_HEIGHT, DISKS_COLOR);
        rect(position_x - (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y,
    position_x + (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y + DISKS_HEIGHT, FRAME_COLOR);

        position_x = position_x + direction * STEP;
        updateScreen();
        }
    MovingDown(position_x, position_y, stopTower, diskValue);
}

void MovingDown(int position_x, int position_y, int stopTower, int diskValue)
{
    while(position_y < (screenHeight() - (WIDTH_GROUND + (howManyDisksArr[stopTower] + 1) * DISKS_HEIGHT)))
        {
        Draw();
        filledRect(position_x - (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y,
      position_x + (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH),
      position_y + DISKS_HEIGHT, DISKS_COLOR);
        rect(position_x - (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH), position_y,
      position_x + (WIDTH_OF_ROD / 2 + diskValue * DISKS_WIDTH),
      position_y + DISKS_HEIGHT, FRAME_COLOR);

        position_y += STEP;
        updateScreen();
        }
}