good version of boad and piece

src/backend/Board.java

@@ -1,317 +1,633 @@
 package backend;
 
+ 
+
 import java.util.ArrayList;
 
+ 
+
 public class Board {
 
+ 
+
 public int width;
+
 public int height;
+
 private Piece[][] board;
+
 private boolean hasSelectedPiece = false;
+
 private int selectedX = -1;
+
 private int selectedY = -1;
+
 private int turnNumber = 0;
+
 private boolean turnWhite = true;
+
 private ArrayList<int[]> highlightedSquares = new ArrayList<>();
 
+ 
+
 public Board(int colNum, int lineNum) {
+
 this.width = colNum;
+
 this.height = lineNum;
+
 this.board = new Piece[width][height];
+
 }
 
+ 
+
 public int getWidth() {
+
 return width;
+
 }
 
+ 
+
 public int getHeight() {
+
 return height;
+
 }
 
+ 
+
 public int getTurnNumber() {
+
 return turnNumber;
+
 }
 
+ 
+
 public boolean isTurnWhite() {
+
 return turnWhite;
+
 }
 
+ 
+
 public void setPiece(boolean isWhite, PieceType type, int x, int y) {
+
 if (x >= 0 && x < width && y >= 0 && y < height) {
+
 board[x][y] = new Piece(x, y, isWhite, type);
+
 }
+
 }
 
+ 
+
 public void populateBoard() {
+
 cleanBoard();
+
 // White pawns
+
 for (int x = 0; x < 8; x++) {
+
 setPiece(true, PieceType.Pawn, x, 1);
+
 }
+
 // Black pawns
+
 for (int x = 0; x < 8; x++) {
+
 setPiece(false, PieceType.Pawn, x, 6);
+
 }
 
+ 
+
 PieceType[] backRow = {
+
 PieceType.Rook, PieceType.Knight, PieceType.Bishop,
+
 PieceType.Queen, PieceType.King, PieceType.Bishop,
+
 PieceType.Knight, PieceType.Rook
+
 };
 
+ 
+
 // White back row
+
 for (int x = 0; x < 8; x++) {
+
 setPiece(true, backRow[x], x, 0);
+
 }
+
 // Black back row
+
 for (int x = 0; x < 8; x++) {
+
 setPiece(false, backRow[x], x, 7);
+
 }
+
 }
 
+ 
+
 public void cleanBoard() {
+
 for (int x = 0; x < width; x++) {
+
 for (int y = 0; y < height; y++) {
+
 board[x][y] = null;
+
 }
+
 }
+
 }
 
+ 
+
 public String toString() {
+
 StringBuilder stringboard= new StringBuilder();
+
 for (int row = height - 1; row >= 0; row--) {
 
+ 
+
 for (int column = 0; column < width; column++) {
+
 Piece piece = board[column][row];
+
 if (piece == null) {
+
 stringboard.append(". ");
+
 } else {
+
 char sym = piece.getType().name().charAt(0);
+
 stringboard.append(piece.isWhite() ? sym : Character.toLowerCase(sym))
+
 .append(' ');
+
 }
+
 }
+
 stringboard.append("\n");
+
 }
+
 stringboard.append(" ");
+
 for (int x = 0; x < width; x++) {
+
 stringboard.append((char)('a' + x)).append(' ');
+
 }
+
 stringboard.append("\n");
+
 stringboard.append("Turn: ").append(isTurnWhite() ? "White" : "Black");
+
 return stringboard.toString();
+
 }
 
  
+
+ 
+
 public ArrayList<Piece> getPieces() {
+
 ArrayList<Piece> pieces = new ArrayList<>();
+
 for (int x = 0; x < width; x++) {
+
 for (int y = 0; y < height; y++) {
+
 if (board[x][y] != null) {
+
 pieces.add(board[x][y]);
+
 }
+
 }
+
 }
+
 return pieces;
 
  
 
  
+
+ 
+
+ 
+
 }
 
+ 
+
 public boolean isSelected(int x, int y) {
+
 return hasSelectedPiece && selectedX == x && selectedY == y;
+
 }
 
+ 
+
 private boolean inBounds(int x, int y) {
+
 return x >= 0 && x < width && y >= 0 && y < height;
+
 }
 
  
+
+ 
+
 private ArrayList<int[]> getValidMoves(Piece piece) {
+
 ArrayList<int[]> moves = new ArrayList<>();
+
 int x = piece.getX();
+
 int y = piece.getY();
+
 PieceType type = piece.getType();
 
+ 
+
 if (type == PieceType.Pawn) {
+
 int dir = piece.isWhite() ? 1 : -1;
+
 int startRow = piece.isWhite() ? 1 : 6;
 
+ 
+
 int oneStep = y + dir;
+
 if (inBounds(x, oneStep) && board[x][oneStep] == null) {
+
 moves.add(new int[]{x, oneStep});
 
+ 
+
 // If on start row, try two steps forward
+
 int twoStep = y + 2 * dir;
+
 if (y == startRow && inBounds(x, twoStep) && board[x][twoStep] == null) {
+
 moves.add(new int[]{x, twoStep});
+
 }
+
 }
 
+ 
+
 // Capture diagonals
+
 for (int dx : new int[]{-1, 1}) {
+
 int nx = x + dx;
+
 int ny = y + dir;
+
 if (inBounds(nx, ny) && board[nx][ny] != null &&
+
 board[nx][ny].isWhite() != piece.isWhite()) {
+
 moves.add(new int[]{nx, ny});
+
 }
+
 }
+
 }
+
 else if (type == PieceType.Rook) {
+
 int[][] dirs = {{1,0}, {-1,0}, {0,1}, {0,-1}};
+
 for (int[] d : dirs) {
+
 int nx = x + d[0], ny = y + d[1];
+
 while (inBounds(nx, ny)) {
+
 if (board[nx][ny] == null) {
+
 moves.add(new int[]{nx, ny});
+
 } else {
+
 if (board[nx][ny].isWhite() != piece.isWhite()) {
+
 moves.add(new int[]{nx, ny});
+
 }
+
 break;
+
 }
+
 nx += d[0]; ny += d[1];
+
 }
+
 }
+
 }
 
+ 
+
 else if (type == PieceType.Bishop) {
+
 int[][] dirs = {{1,1}, {-1,1}, {-1,-1}, {1,-1}};
+
 for (int[] d : dirs) {
+
 int nx = x + d[0], ny = y + d[1];
+
 while (inBounds(nx, ny)) {
+
 if (board[nx][ny] == null) {
+
 moves.add(new int[]{nx, ny});
+
 } else {
+
 if (board[nx][ny].isWhite() != piece.isWhite()) {
+
 moves.add(new int[]{nx, ny});
+
 }
+
 break;
+
 }
+
 nx += d[0]; ny += d[1];
+
 }
+
 }
+
 }
 
+ 
+
 else if (type == PieceType.Queen) {
+
 // Queen = Rook + Bishop
+
 moves.addAll(getValidMoves(new Piece(x, y, piece.isWhite(), PieceType.Rook)));
+
 moves.addAll(getValidMoves(new Piece(x, y, piece.isWhite(), PieceType.Bishop)));
+
 }
 
+ 
+
 else if (type == PieceType.Knight) {
+
 int[][] jumps = {
+
 {2,1},{1,2},{-1,2},{-2,1},
+
 {-2,-1},{-1,-2},{1,-2},{2,-1}
+
 };
+
 for (int[] j : jumps) {
+
 int nx = x + j[0], ny = y + j[1];
+
 if (inBounds(nx, ny)) {
+
 if (board[nx][ny] == null || board[nx][ny].isWhite() != piece.isWhite()) {
+
 moves.add(new int[]{nx, ny});
+
 }
+
 }
+
 }
+
 }
 
+ 
+
 else if (type == PieceType.King) {
+
 int[][] dirs = {
+
 {1,0}, {-1,0}, {0,1}, {0,-1},
+
 {1,1}, {-1,1}, {-1,-1}, {1,-1}
+
 };
+
 for (int[] d : dirs) {
+
 int nx = x + d[0], ny = y + d[1];
+
 if (inBounds(nx, ny)) {
+
 if (board[nx][ny] == null || board[nx][ny].isWhite() != piece.isWhite()) {
+
 moves.add(new int[]{nx, ny});
-                    }
-                }
-            }
+
 }
 
-        return moves;
 }
 
+}
+
+}
+
+ 
+
+return moves;
+
+}
+
+ 
+
+ 
+
+ 
 
  
 
 public void userTouch(int x, int y) {
+
 if (x < 0 || x >= width || y < 0 || y >= height) return;
 
+ 
+
 Piece clicked = board[x][y];
 
+ 
+
 if (!hasSelectedPiece) {
+
 if (clicked != null && clicked.isWhite() == turnWhite) {
+
 // Select piece
+
 selectedX = x;
+
 selectedY = y;
+
 hasSelectedPiece = true;
+
 highlightedSquares = getValidMoves(clicked); // ✅ Highlight legal moves
+
 }
+
 } else {
+
 // Check if clicked again on the same square to unselect
+
 if (selectedX == x && selectedY == y) {
+
 hasSelectedPiece = false;
+
 highlightedSquares.clear();
+
 }
+
 // If clicked on a highlighted square, move there
+
 else if (isHighlighted(x, y)) {
+
 Piece selectedPiece = board[selectedX][selectedY];
 
+ 
+
 // Move piece
+
 board[x][y] = selectedPiece;
+
 board[selectedX][selectedY] = null;
+
 selectedPiece.setX(x);
+
 selectedPiece.setY(y);
 
+ 
+
 // Update turn
+
 turnWhite = !turnWhite;
+
 turnNumber++;
 
+ 
+
 // Clear selection & highlights
+
 hasSelectedPiece = false;
+
 highlightedSquares.clear();
+
 }
+
 // Invalid move: just unselect
+
 else {
+
 hasSelectedPiece = false;
+
 highlightedSquares.clear();
+
 }
+
 }
+
 }
 
  
 
+ 
+
+ 
+
 /* saving-loading feature */
+
 public String[] toFileRep() {
+
 return null;
+
 }
 
+ 
+
 public Board(String[] array) {
+
 // TODO
+
 }
 
+ 
+
 /* The following methods require more work */
+
 public boolean isHighlighted(int x, int y) {
+
 for (int[] pos : highlightedSquares) {
+
 if (pos[0] == x && pos[1] == y) {
+
 return true;
+
 }
+
 }
+
 return false;
+
 }
 
+ 
+
 public void undoLastMove() {
+
 // TODO
+
 }
 
+ 
+
 public Board(Board board) {
+
 // TODO helloyo
+
 }
 
+ 
+
 public void playMove(Move move) {
+
 // TODO
+
 }
+
 }

src/backend/Piece.java

@@ -1,35 +1,86 @@
 package backend;
 
+ 
+
 public class Piece {
 
+ 
+
 private int x;
+
 private int y;
+
 private boolean isWhite;
+
 private PieceType type;
 
+ 
+
 public Piece(int x, int y, boolean isWhite, PieceType type) {
+
 this.x = x;
+
 this.y = y;
+
 this.isWhite = isWhite;
+
 this.type = type;
+
 }
 
+ 
+
+ 
+
 public int getX() {
+
 return x;
+
 }
 
+ 
+
 public int getY() {
+
 return y;
+
 }
 
+ 
+
+public void setX(int x) {
+
+this.x = x;
+
+}
+
+ 
+
+public void setY(int y) {
+
+this.y = y;
+
+}
+
+ 
+
+ 
+
 public PieceType getType() {
 
+ 
+
 return type;
+
 }
 
+ 
+
 public boolean isWhite() {
 
+ 
+
 return isWhite;
-	}
 
 }
+}