void calculateDiagonalMoves(int initial_x, int initial_y, int dx, int dy) {
  int x = initial_x;
  int y = initial_y;

  Serial.print("Initial coordinates: (");
  Serial.print(x);
  Serial.print(", ");
  Serial.print(y);
  Serial.println(")");

  while (x >= 0 && x <= 7 && y >= 0 && y <= 7) {
    Serial.print("Current coordinates: (");
    Serial.print(x);
    Serial.print(", ");
    Serial.print(y);
    Serial.println(")");

    x += dx;
    y += dy;
  }

  Serial.print("Final coordinates: (");
  Serial.print(x - dx);  // Adjust to print the last valid coordinates
  Serial.print(", ");
  Serial.print(y - dy);
  Serial.println(")");

  if (x < 0 || x > 7 || y < 0 || y > 7) {
    Serial.println("Out of bounds! Calculation stopped.");
  }
}

void calculateBishopMoves(int initial_x, int initial_y) {
  // Call calculateDiagonalMoves for each direction
  calculateDiagonalMoves(initial_x, initial_y, 1, -1); // xadd_yminus
  calculateDiagonalMoves(initial_x, initial_y, -1, -1); // xminus_yminus
  calculateDiagonalMoves(initial_x, initial_y, 1, 1); // xadd_yadd
  calculateDiagonalMoves(initial_x, initial_y, -1, 1); // xminus_yadd
}

void calculateKnightMoves(int initial_x1, int initial_y1) {
  // Define all possible knight move combinations
  int knightMoves[8][2] = {
    {2, -1}, {2, 1},   // x2+ y- and x2+ y+
    {-2, -1}, {-2, 1}, // x2- y- and x2- y+
    {1, -2}, {1, 2},   // y2+ x- and y2+ x+
    {-1, -2}, {-1, 2}  // y2- x- and y2- x+
  };

  Serial.print("Initial coordinates: (");
  Serial.print(initial_x1);
  Serial.print(", ");
  Serial.print(initial_y1);
  Serial.println(")");

  // Iterate through each possible move
  for (int i = 0; i < 8; ++i) {
    int dx = knightMoves[i][0];
    int dy = knightMoves[i][1];
    int x = initial_x1 + dx;
    int y = initial_y1 + dy;

    // Check if the new position is within the chessboard boundaries (0 to 7)
    if (x >= 0 && x <= 7 && y >= 0 && y <= 7) {
      Serial.print("Move ");
      Serial.print(i + 1); // Display move number
      Serial.print(": (");
      Serial.print(dx > 0 ? "+" : ""); // Print + sign for positive dx
      Serial.print(dx);
      Serial.print(", ");
      Serial.print(dy > 0 ? "+" : ""); // Print + sign for positive dy
      Serial.print(dy);
      Serial.print(") -> (");
      Serial.print(x);
      Serial.print(", ");
      Serial.print(y);
      Serial.println(")");
    }
  }
}

void calculateRookMoves(int initial_x2, int initial_y2) {
  // Define all possible rook move directions (x+, x-, y+, y-)
  int rookMoves[4][2] = {
    {1, 0}, {-1, 0}, // x+ and x-
    {0, 1}, {0, -1}  // y+ and y-
  };

  Serial.print("Initial coordinates: (");
  Serial.print(initial_x2);
  Serial.print(", ");
  Serial.print(initial_y2);
  Serial.println(")");

  // Iterate through each possible move direction
  for (int i = 0; i < 4; ++i) {
    int dx = rookMoves[i][0];
    int dy = rookMoves[i][1];
    int x2 = initial_x2 + dx;
    int y2 = initial_y2 + dy;

    // Continue moving in the same direction until out of bounds (0 to 7)
    while (x2 >= 0 && x2 <= 7 && y2 >= 0 && y2 <= 7) {
      Serial.print("Move ");
      Serial.print(i + 1); // Display move number
      Serial.print(": (");
      Serial.print(dx > 0 ? "+" : ""); // Print + sign for positive dx
      Serial.print(dx);
      Serial.print(", ");
      Serial.print(dy > 0 ? "+" : ""); // Print + sign for positive dy
      Serial.print(dy);
      Serial.print(") -> (");
      Serial.print(x2);
      Serial.print(", ");
      Serial.print(y2);
      Serial.println(")");

      x2 += dx;
      y2 += dy;
    }
  }
}

void calculateQueenMoves(int initial_x3, int initial_y3) {
  // Calculate rook-like moves
  calculateRookMoves(initial_x3, initial_y3);
  // Calculate bishop-like moves
  calculateBishopMoves(initial_x3, initial_y3);
}

void calculateKingMoves(int initial_x4, int initial_y4) {
  // Define all possible king move combinations
  int kingMoves[8][2] = {
    {1, 0}, {-1, 0},   // x+ y0 and x- y0
    {0, 1}, {0, -1},   // y+ x0 and y- x0
    {1, 1}, {1, -1},   // x+ y+ and x+ y-
    {-1, 1}, {-1, -1}  // x- y+ and x- y-
  };

  Serial.print("Initial coordinates: (");
  Serial.print(initial_x4);
  Serial.print(", ");
  Serial.print(initial_y4);
  Serial.println(")");

  // Iterate through each possible move
  for (int i = 0; i < 8; ++i) {
    int dx = kingMoves[i][0];
    int dy = kingMoves[i][1];
    int x = initial_x4 + dx;
    int y = initial_y4 + dy;

    // Check if the new position is within the chessboard boundaries (0 to 7)
    if (x >= 0 && x <= 7 && y >= 0 && y <= 7) {
      Serial.print("Move ");
      Serial.print(i + 1); // Display move number
      Serial.print(": (");
      Serial.print(dx > 0 ? "+" : ""); // Print + sign for positive dx
      Serial.print(dx);
      Serial.print(", ");
      Serial.print(dy > 0 ? "+" : ""); // Print + sign for positive dy
      Serial.print(dy);
      Serial.print(") -> (");
      Serial.print(x);
      Serial.print(", ");
      Serial.print(y);
      Serial.println(")");
    }
  }
}

void setup() {
  Serial.begin(9600); // Initialize serial communication

  int initial_x = 4; // Example initial x coordinate bishop
  int initial_y = 3; // Example initial y coordinate bishop

  int initial_x1 = 5; // Example initial x coordinate knight
  int initial_y1 = 3; // Example initial y coordinate knight

  int initial_x2 = 2; // Example initial x coordinate rook 
  int initial_y2 = 3; // Example initial y coordinate rook

  int initial_x3 = 3; // Example initial x coordinate queen
  int initial_y3 = 4; // Example initial y coordinate queen

  int initial_x4 = 2; // Example initial x coordinate king
  int initial_y4 = 4; // Example initial y coordinate king

  calculateKnightMoves(initial_x1, initial_y1);
  calculateBishopMoves(initial_x, initial_y);
  calculateRookMoves(initial_x2, initial_y2);
  calculateQueenMoves(initial_x3, initial_y3);
  calculateKingMoves(initial_x4, initial_y4);
}

void loop() {
}