Chess Project Commit

clean_code_projects/_1_project_requirements_chess/src/main/java/clean/code/chess/requirements/ChessBoard.java

@@ -1,22 +1,97 @@
 package clean.code.chess.requirements;
 
+import clean.code.chess.requirements.pieces.Pawn;
+import clean.code.chess.requirements.pieces.Piece;
+import clean.code.chess.requirements.pieces.attributes.PieceColor;
+import clean.code.chess.requirements.pieces.attributes.Position;
+
+import java.util.HashMap;
+import java.util.Map;
+
 public class ChessBoard {
 
-    public static int MAX_BOARD_WIDTH = 7;
-    public static int MAX_BOARD_HEIGHT = 7;
+    public static final int MAX_BOARD_WIDTH = 7;
+    public static final int MAX_BOARD_HEIGHT = 7;
+
+    private Map<Position, Piece> mapOfPositionAndPiece;
+    private Map<Piece, Position> mapOfPieceAndPosition;
+    private ChessBoardValidator chessBoardValidator;
 
-    private Pawn[][] pieces;
+    private final Pawn[][] pieces;
+    private int nrOfPawns;
 
     public ChessBoard() {
+        this.mapOfPieceAndPosition = new HashMap<>(MAX_BOARD_WIDTH * MAX_BOARD_HEIGHT);
+        this.mapOfPositionAndPiece = new HashMap<>(MAX_BOARD_WIDTH * MAX_BOARD_HEIGHT);
+        this.chessBoardValidator = new ChessBoardValidator();
         pieces = new Pawn[MAX_BOARD_WIDTH][MAX_BOARD_HEIGHT];
+    }
+
+    public void addPieceOnChessBoard(Piece piece, int xCoordinate, int yCoordinate) {
+        if (chessBoardValidator.isValidPieceRow(xCoordinate, piece.getColor())) {
+            piece.setPieceOnChessBoard(this, xCoordinate, yCoordinate);
+        }
+    }
+
+    public void updatePiecePositionOnChessBoard(Piece piece, int xCoordinate, int yCoordinate) {
+        Position newPosition = getNewPiecePosition(xCoordinate, yCoordinate);
+        this.mapOfPieceAndPosition.put(piece, newPosition);
+        this.mapOfPositionAndPiece.put(newPosition, piece);
+    }
+
+    private Position getNewPiecePosition(int xCoordinate, int yCoordinate) {
+        if (this.IsLegalBoardPosition(xCoordinate, yCoordinate)) {
+            return new Position(xCoordinate, yCoordinate);
+        } else {
+            return new Position(-1, -1);
+        }
+    }
 
+    public Position getPosition(Piece piece) {
+        return this.mapOfPieceAndPosition.get(piece);
+    }
+
+    public Piece getPiece(Position position) {
+        return this.mapOfPositionAndPiece.get(position);
     }
 
     public void Add(Pawn pawn, int xCoordinate, int yCoordinate, PieceColor pieceColor) {
-        throw new UnsupportedOperationException("Need to implement ChessBoard.add()");
+        if (IsLegalBoardPosition(xCoordinate, yCoordinate) && nrOfPawns < MAX_BOARD_WIDTH) {
+            pieces[xCoordinate][yCoordinate] = pawn;
+            pawn.setXCoordinate(xCoordinate);
+            pawn.setYCoordinate(yCoordinate);
+            pawn.setChessBoard(this);
+            nrOfPawns++;
+        } else {
+            pawn.setXCoordinate(-1);
+            pawn.setYCoordinate(-1);
+        }
     }
 
     public boolean IsLegalBoardPosition(int xCoordinate, int yCoordinate) {
-        throw new UnsupportedOperationException("Need to implement ChessBoard.IsLegalBoardPosition()");
+        return chessBoardValidator.isValidCoordinates(xCoordinate, yCoordinate) && chessBoardValidator.isFreePosition(xCoordinate, yCoordinate);
+    }
+
+    private class ChessBoardValidator {
+
+        public boolean isFreePosition(int xCoordinate, int yCoordinate) {
+            return getPiece(new Position(xCoordinate, yCoordinate)) == null;
+        }
+
+        public boolean isValidCoordinates(int xCoordinate, int yCoordinate) {
+            return this.isInsideTheTable(xCoordinate, MAX_BOARD_WIDTH) && this.isInsideTheTable(yCoordinate, MAX_BOARD_HEIGHT);
+        }
+
+        public boolean isInsideTheTable(int coordinate, int tableLimit) {
+            return 0 <= coordinate && coordinate < tableLimit;
+        }
+
+        public boolean isValidPieceRow(int xCoordinate, PieceColor color) {
+            if (color == PieceColor.WHITE) {
+                return xCoordinate == 0 || xCoordinate == 1;
+            }
+            return xCoordinate == MAX_BOARD_HEIGHT - 1 || xCoordinate == MAX_BOARD_HEIGHT;
+        }
+
     }
 }

clean_code_projects/_1_project_requirements_chess/src/main/java/clean/code/chess/requirements/Pawn.java → clean_code_projects/_1_project_requirements_chess/src/main/java/clean/code/chess/requirements/pieces/Pawn.java

@@ -1,4 +1,8 @@
-package clean.code.chess.requirements;
+package clean.code.chess.requirements.pieces;
+
+import clean.code.chess.requirements.ChessBoard;
+import clean.code.chess.requirements.MovementType;
+import clean.code.chess.requirements.pieces.attributes.PieceColor;
 
 public class Pawn {
 
@@ -44,7 +48,16 @@ private void setPieceColor(PieceColor value) {
     }
 
     public void Move(MovementType movementType, int newX, int newY) {
-        throw new UnsupportedOperationException("Need to implement Pawn.Move()");
+        if (chessBoard.IsLegalBoardPosition(newX, newY)) {
+            if (movementType == MovementType.MOVE) {
+                if (newX == xCoordinate) {
+                    if ((pieceColor == PieceColor.BLACK && newY == yCoordinate - 1) ||
+                            (pieceColor == PieceColor.WHITE && newY == yCoordinate + 1)) {
+                        yCoordinate = newY;
+                    }
+                }
+            }
+        }
     }
 
     @Override

clean_code_projects/_1_project_requirements_chess/src/main/java/clean/code/chess/requirements/pieces/Piece.java

@@ -0,0 +1,58 @@
+package clean.code.chess.requirements.pieces;
+
+import clean.code.chess.requirements.ChessBoard;
+import clean.code.chess.requirements.pieces.attributes.PieceColor;
+
+import java.util.logging.Logger;
+
+public abstract class Piece {
+
+    private final static Logger logger = Logger.getLogger(Piece.class.getName());
+    protected final PieceColor color;
+    protected ChessBoard chessBoard;
+
+    public Piece(PieceColor color) {
+        this.color = color;
+    }
+
+    public void setPieceOnChessBoard(ChessBoard chessBoard, int xCoordinate, int yCoordinate) {
+        this.chessBoard = chessBoard;
+        this.chessBoard.updatePiecePositionOnChessBoard(this, xCoordinate, yCoordinate);
+        logger.finest(toString());
+    }
+
+    public void move(int newX, int newY) {
+        if (this.isValidNewPosition(newX, newY)) {
+            this.chessBoard.updatePiecePositionOnChessBoard(this, newX, newY);
+        }
+        logger.finest(toString());
+    }
+
+    public void capture(int newX, int newY) {
+        throw new UnsupportedOperationException("Need to implement Piece.capture()");
+    }
+
+    public abstract boolean isValidNewPosition(int newX, int newY);
+
+    public int getXCoordinate() {
+        return this.chessBoard.getPosition(this).getX();
+    }
+
+    public int getYCoordinate() {
+        return this.chessBoard.getPosition(this).getY();
+    }
+
+    public PieceColor getColor() {
+        return this.color;
+    }
+
+    @Override
+    public String toString() {
+        return currentPositionAsString();
+    }
+
+    protected String currentPositionAsString() {
+        String eol = System.lineSeparator();
+        return String.format("Current X: {1}{0}Current Y: {2}{0}Piece Color: {3}", eol, getXCoordinate(), getYCoordinate(), color);
+    }
+}

clean_code_projects/_1_project_requirements_chess/src/main/java/clean/code/chess/requirements/pieces/attributes/PieceColor.java

@@ -0,0 +1,7 @@
+package clean.code.chess.requirements.pieces.attributes;
+
+public enum PieceColor {
+
+    BLACK, WHITE;
+
+}

clean_code_projects/_1_project_requirements_chess/src/main/java/clean/code/chess/requirements/pieces/attributes/Position.java

@@ -0,0 +1,35 @@
+package clean.code.chess.requirements.pieces.attributes;
+
+import java.util.Objects;
+
+public class Position {
+    private final int x;
+    private final int y;
+
+    public Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Position that = (Position) o;
+        return x == that.x &&
+                y == that.y;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y);
+    }
+}

clean_code_projects/_1_project_requirements_chess/src/test/java/clean/code/chess/requirements/ChessBoardTest.java

@@ -1,5 +1,7 @@
 package clean.code.chess.requirements;
 
+import clean.code.chess.requirements.pieces.Pawn;
+import clean.code.chess.requirements.pieces.attributes.PieceColor;
 import junit.framework.TestCase;
 import org.junit.Assert;
 import org.junit.Before;
@@ -39,7 +41,7 @@ public void testIsLegalBoardPosition_True_X_equals_5_Y_equals_5() {
     @Test
     public void testIsLegalBoardPosition_False_X_equals_11_Y_equals_5() {
         boolean isValidPosition = testSubject.IsLegalBoardPosition(11, 5);
-        assertTrue(isValidPosition);
+        assertFalse(isValidPosition);
     }
 
     @Test

clean_code_projects/_1_project_requirements_chess/src/test/java/clean/code/chess/requirements/PawnTest.java

@@ -1,5 +1,7 @@
 package clean.code.chess.requirements;
 
+import clean.code.chess.requirements.pieces.Pawn;
+import clean.code.chess.requirements.pieces.attributes.PieceColor;
 import org.junit.Before;
 import org.junit.Test;