Chess Board Implementation

ChessBoardImpl/.gitignore

@@ -0,0 +1 @@
+/bin/

ChessBoardImpl/src/com/chess/ChessApplication.java

@@ -0,0 +1,34 @@
+package com.chess;
+
+import com.chess.interfaces.IChessApplication;
+import com.chessBoard.interfaces.IChessBoard;
+import com.chessPiece.interfaces.IChessPiece;
+import com.chessPiece.interfaces.IChessPieceFactory;
+import com.coordinates.Coordinates;
+import com.enums.ChessPieceType;
+
+public class ChessApplication implements IChessApplication {
+
+	private IChessBoard chessBoard;
+
+	private IChessPieceFactory chessPieceFactory;
+
+	@Override
+	public boolean makeAMove(Coordinates startCoordinates, Coordinates endCoordinates) {
+		if (!this.isValidMove(startCoordinates, endCoordinates)) {
+			return false;
+		}
+
+		IChessPiece chessPiece = this.chessBoard.getChessPieceAtCoordinate(startCoordinates);
+
+		this.chessBoard.setChessPieceAtCoordinate(startCoordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.NONE, null));
+		this.chessBoard.setChessPieceAtCoordinate(endCoordinates, chessPiece);
+
+		return true;
+	}
+
+	private boolean isValidMove(Coordinates startCoordinates, Coordinates endCoordinates) {
+		return this.isValidMove(startCoordinates, endCoordinates);
+	}
+
+}

ChessBoardImpl/src/com/chess/interfaces/IChessApplication.java

@@ -0,0 +1,7 @@
+package com.chess.interfaces;
+
+import com.coordinates.Coordinates;
+
+public interface IChessApplication {
+	boolean makeAMove(Coordinates startCoordinates, Coordinates endCoordinates);
+}

ChessBoardImpl/src/com/chessBoard/ChessBoard.java

@@ -0,0 +1,258 @@
+package com.chessBoard;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.chessBoard.interfaces.IChessBoard;
+import com.chessBoard.interfaces.IChessBoardInitialPositionInitiator;
+import com.chessPiece.interfaces.IChessPiece;
+import com.chessPiece.interfaces.IChessPieceFactory;
+import com.coordinates.Coordinates;
+import com.enums.ChessCellColor;
+import com.enums.ChessPieceColor;
+import com.enums.ChessPieceType;
+
+public class ChessBoard implements IChessBoard {
+
+	private static int DEFAULT_MAX_X = 8;
+
+	private static int DEFAULT_MAX_Y = 8;
+
+	private static ChessPieceColor DEFAULT_START_CHANCE_BY = ChessPieceColor.WHITE;
+
+	private Map<Coordinates, Set<Coordinates>> attacksMap;
+
+	private Map<Coordinates, Set<Coordinates>> attackedByMap;
+
+	private Map<Coordinates, IChessPiece> coordinateMap;
+
+	private List<List<Coordinates>> coordinatesMatrix;
+
+	private ChessPieceColor currentChanceBy;
+
+	private Map<ChessPieceColor, Set<Coordinates>> blockedPositionsForKing;
+
+	private int maxX;
+
+	private int maxY;
+
+	private IChessBoardInitialPositionInitiator chessBoardInitialPositionInitiator;
+
+	private Map<ChessPieceColor, Set<Coordinates>> checkMap;
+
+	private IChessPieceFactory chessPieceFactory;
+
+	private Map<ChessPieceColor, Coordinates> currentPositionOfKingMap;
+
+
+	public ChessBoard(IChessBoardInitialPositionInitiator chessBoardInitialPositionInitiator, IChessPieceFactory chessPieceFactory) {
+		this(ChessBoard.DEFAULT_MAX_X, ChessBoard.DEFAULT_MAX_Y, chessBoardInitialPositionInitiator, chessPieceFactory);
+	}
+
+
+
+	public ChessBoard(int maxX, int maxY, IChessBoardInitialPositionInitiator chessBoardInitialPositionInitiator, IChessPieceFactory chessPieceFactory) {
+		this(ChessBoard.DEFAULT_START_CHANCE_BY, maxX, maxY, chessBoardInitialPositionInitiator, chessPieceFactory);
+	}
+
+
+	public ChessBoard(ChessPieceColor currentChanceBy, int maxX, int maxY,
+			IChessBoardInitialPositionInitiator chessBoardInitialPositionInitiator, IChessPieceFactory chessPieceFactory) {
+		this.currentChanceBy = currentChanceBy;
+		this.maxX = maxX;
+		this.maxY = maxY;
+		this.chessBoardInitialPositionInitiator = chessBoardInitialPositionInitiator;
+		this.chessPieceFactory = chessPieceFactory;
+		this.instantiateBoard();
+	}
+
+
+
+	@Override
+	public IChessPiece getChessPieceAtCoordinate(Coordinates coordinates) {
+		// TODO Auto-generated method stub
+		return this.coordinateMap.get(this.getCoordinatesAtChessBoardObject(coordinates));
+	}
+
+	@Override
+	public int getMaxX() {
+		return this.maxX;
+	}
+
+	@Override
+	public int getMaxY() {
+		// TODO Auto-generated method stub
+		return this.maxY;
+	}
+
+	@Override
+	public boolean instantiateBoard() {
+		int i = 0;
+
+		this.coordinateMap = new HashMap<>();
+
+		this.attackedByMap = new HashMap<>();
+
+		this.attacksMap = new HashMap<>();
+
+		this.blockedPositionsForKing = new HashMap<>();
+
+		this.blockedPositionsForKing.put(ChessPieceColor.BLACK, new HashSet<>());
+
+		this.blockedPositionsForKing.put(ChessPieceColor.WHITE, new HashSet<>());
+
+		this.checkMap = new HashMap<>();
+
+		this.checkMap.put(ChessPieceColor.BLACK, new HashSet<>());
+
+		this.checkMap.put(ChessPieceColor.WHITE, new HashSet<>());
+
+		this.coordinatesMatrix = new ArrayList<>();
+
+		while (i < this.maxX) {
+			int j = 0;
+
+			ChessCellColor chessCellColor = ChessCellColor.BLACK;
+
+			if (i % 2 == 1) {
+				chessCellColor = ChessCellColor.WHITE;
+			}
+
+			while (j < this.maxY) {
+				if (this.coordinatesMatrix.size() <= i) {
+					this.coordinatesMatrix.add(new ArrayList<Coordinates>());
+				}
+
+				if (j % 2 == 1) {
+					this.coordinatesMatrix.get(i).add(new Coordinates(i, j, chessCellColor == ChessCellColor.BLACK ? ChessCellColor.WHITE : ChessCellColor.BLACK));
+				} else {
+					this.coordinatesMatrix.get(i).add(new Coordinates(i, j, chessCellColor));
+				}
+
+				this.chessBoardInitialPositionInitiator.setChessPieceAtCoordinate(this.coordinatesMatrix.get(i).get(j), this);
+				j++;
+			}
+
+			i++;
+		}
+
+		this.currentPositionOfKingMap = new HashMap<>();
+
+		this.currentPositionOfKingMap.put(ChessPieceColor.BLACK, this.coordinatesMatrix.get(0).get(maxY / 2));
+
+		this.currentPositionOfKingMap.put(ChessPieceColor.WHITE, this.coordinatesMatrix.get(maxX - 1).get(maxY / 2));
+
+		return true;
+
+	}
+
+	@Override
+	public boolean setChessPieceAtCoordinate(Coordinates coordinates, IChessPiece chessPiece) {
+		if (this.coordinateMap == null) {
+			this.coordinateMap = new HashMap<>();
+		}
+		Coordinates currentCoordinates = this.getCoordinatesAtChessBoardObject(coordinates);
+
+		if (this.coordinateMap.get(currentCoordinates).getChessPieceType() != ChessPieceType.NONE) {
+			this.setChessPieceAtCoordinate(currentCoordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.NONE, ChessPieceColor.NONE));
+		}
+
+		if (chessPiece.getChessPieceType() == ChessPieceType.NONE) {	
+			Set<Coordinates> attacks = this.attacksMap.get(currentCoordinates);
+
+			attacks.remove(currentCoordinates);
+
+			Iterator<Coordinates> it = attacks.iterator();
+
+			while (it.hasNext()) {
+				this.attackedByMap.get(it.next()).remove(currentCoordinates);
+			}
+
+			this.coordinateMap.put(currentCoordinates, chessPiece);
+			return true;
+		}
+
+		this.coordinateMap.put(currentCoordinates, chessPiece);
+
+		Set<Coordinates> attacks = chessPiece.getAllPossibleNextCoordinates(this, currentCoordinates);
+
+		Iterator<Coordinates> it = attacks.iterator();
+
+		while (it.hasNext()) {
+			Coordinates next = it.next();
+
+			if (!this.attacksMap.containsKey(currentCoordinates)) {
+				this.attacksMap.put(currentCoordinates, new HashSet<>());
+			}
+
+			this.attacksMap.get(currentCoordinates).add(next);
+
+			if (!this.attackedByMap.containsKey(next)) {
+				this.attackedByMap.put(next, new HashSet<>());
+			}
+
+			this.attackedByMap.get(next).add(currentCoordinates);
+
+
+		}
+
+
+		return true;
+	}
+
+	@Override
+	public boolean isValidMove(Coordinates startCoordinates, Coordinates endCoordinates) {
+		if (startCoordinates.getX() < 0 || startCoordinates.getY() < 0 || startCoordinates.getX() >= this.getMaxX() || startCoordinates.getY() >= this.getMaxY()) {
+			return false;
+		}
+
+		if (endCoordinates.getX() < 0 || endCoordinates.getY() < 0 || endCoordinates.getX() >= this.getMaxX() || endCoordinates.getY() >= this.getMaxY()) {
+			return false;
+		}
+
+		Coordinates start = this.coordinatesMatrix.get(startCoordinates.getX()).get(startCoordinates.getY());
+
+		Coordinates end = this.coordinatesMatrix.get(endCoordinates.getX()).get(endCoordinates.getY());
+
+		if (this.coordinateMap.get(start).getChessPieceColor() != this.currentChanceBy) {
+			return false;
+		}
+
+		if (this.coordinateMap.get(start).getChessPieceColor() == this.coordinateMap.get(end).getChessPieceColor()) {
+			return false;
+		}
+
+		return this.coordinateMap.get(start).isValidMove(start, end, this);
+	}
+
+
+
+	@Override
+	public Set<Coordinates> getBlockedPositionsForKing(ChessPieceColor chessPieceColor) {
+		return this.blockedPositionsForKing.get(chessPieceColor);
+	}
+
+
+
+	@Override
+	public Coordinates getCoordinatesAtChessBoardObject(Coordinates coordinates) {
+		return this.coordinatesMatrix.get(coordinates.getX()).get(coordinates.getY());
+	}
+
+
+
+	@Override
+	public boolean isChecked(ChessPieceColor chessPieceColor) {
+		if (this.checkMap.get(chessPieceColor) != null && this.checkMap.get(chessPieceColor).size() > 0) {
+			return true;
+		}
+
+		return false;
+	}
+
+}

ChessBoardImpl/src/com/chessBoard/DefaultChessBoardInitialPositionInitiator.java

@@ -0,0 +1,72 @@
+package com.chessBoard;
+
+import com.chessBoard.interfaces.IChessBoard;
+import com.chessBoard.interfaces.IChessBoardInitialPositionInitiator;
+import com.chessPiece.interfaces.IChessPieceFactory;
+import com.coordinates.Coordinates;
+import com.enums.ChessPieceColor;
+import com.enums.ChessPieceType;
+
+public class DefaultChessBoardInitialPositionInitiator implements IChessBoardInitialPositionInitiator {
+
+	private IChessPieceFactory chessPieceFactory;
+
+
+
+	public DefaultChessBoardInitialPositionInitiator(IChessPieceFactory chessPieceFactory) {
+		this.chessPieceFactory = chessPieceFactory;
+	}
+
+
+
+	@Override
+	public boolean setChessPieceAtCoordinate(Coordinates coordinates, IChessBoard chessBoard) {
+
+		if (coordinates.getX() > 1 && coordinates.getY() < chessBoard.getMaxX() - 2) {
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.NONE, null));
+
+			return true;
+		}
+
+		ChessPieceColor chessPieceColor;
+		if (coordinates.getX() < 2) {
+			chessPieceColor = ChessPieceColor.BLACK;
+		} else {
+			chessPieceColor = ChessPieceColor.WHITE;
+		}
+
+		if (coordinates.getX() == 1 || coordinates.getX() == chessBoard.getMaxX() - 1) {
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.PAWN, chessPieceColor));
+			return true;
+		}
+
+		if (coordinates.getY() == chessBoard.getMaxY() / 2) {
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.QUEEN, chessPieceColor));
+		}
+
+		if (coordinates.getY() == chessBoard.getMaxY() / 2 + 1) {
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.KING, chessPieceColor));
+		}
+
+		int y = coordinates.getY();
+
+		if (y > chessBoard.getMaxY() / 2) {
+			y = chessBoard.getMaxY() - y;
+		}
+
+		switch(y) {
+		case 0: 
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.ROOK, chessPieceColor));
+			break;
+		case 1:
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.KNIGHT, chessPieceColor));
+			break;
+		case 2:
+			chessBoard.setChessPieceAtCoordinate(coordinates, this.chessPieceFactory.createChessPiece(ChessPieceType.BISHOP, chessPieceColor));
+			break;
+		}
+
+		return true;
+	}
+
+}