diff --git a/ChessBoardImpl/.gitignore b/ChessBoardImpl/.gitignore new file mode 100644 index 00000000..ae3c1726 --- /dev/null +++ b/ChessBoardImpl/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/ChessBoardImpl/src/com/chess/ChessApplication.java b/ChessBoardImpl/src/com/chess/ChessApplication.java new file mode 100644 index 00000000..5651a3a1 --- /dev/null +++ b/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); + } + +} diff --git a/ChessBoardImpl/src/com/chess/interfaces/IChessApplication.java b/ChessBoardImpl/src/com/chess/interfaces/IChessApplication.java new file mode 100644 index 00000000..f535d3ba --- /dev/null +++ b/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); +} diff --git a/ChessBoardImpl/src/com/chessBoard/ChessBoard.java b/ChessBoardImpl/src/com/chessBoard/ChessBoard.java new file mode 100644 index 00000000..777caf36 --- /dev/null +++ b/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> attacksMap; + + private Map> attackedByMap; + + private Map coordinateMap; + + private List> coordinatesMatrix; + + private ChessPieceColor currentChanceBy; + + private Map> blockedPositionsForKing; + + private int maxX; + + private int maxY; + + private IChessBoardInitialPositionInitiator chessBoardInitialPositionInitiator; + + private Map> checkMap; + + private IChessPieceFactory chessPieceFactory; + + private Map 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()); + } + + 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 attacks = this.attacksMap.get(currentCoordinates); + + attacks.remove(currentCoordinates); + + Iterator 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 attacks = chessPiece.getAllPossibleNextCoordinates(this, currentCoordinates); + + Iterator 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 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; + } + +} diff --git a/ChessBoardImpl/src/com/chessBoard/DefaultChessBoardInitialPositionInitiator.java b/ChessBoardImpl/src/com/chessBoard/DefaultChessBoardInitialPositionInitiator.java new file mode 100644 index 00000000..27d702d4 --- /dev/null +++ b/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; + } + +} diff --git a/ChessBoardImpl/src/com/chessBoard/interfaces/IChessBoard.java b/ChessBoardImpl/src/com/chessBoard/interfaces/IChessBoard.java new file mode 100644 index 00000000..7cbf9af6 --- /dev/null +++ b/ChessBoardImpl/src/com/chessBoard/interfaces/IChessBoard.java @@ -0,0 +1,27 @@ +package com.chessBoard.interfaces; + +import java.util.Set; + +import com.chessPiece.interfaces.IChessPiece; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; + +public interface IChessBoard { + IChessPiece getChessPieceAtCoordinate(Coordinates coordinates); + + int getMaxX(); + + int getMaxY(); + + boolean setChessPieceAtCoordinate(Coordinates coordinates, IChessPiece chessPiece); + + boolean instantiateBoard(); + + boolean isValidMove(Coordinates startCoordinates, Coordinates endCoordinates); + + Set getBlockedPositionsForKing(ChessPieceColor chessPieceColor); + + Coordinates getCoordinatesAtChessBoardObject(Coordinates coordinates); + + boolean isChecked(ChessPieceColor chessPieceColor); +} diff --git a/ChessBoardImpl/src/com/chessBoard/interfaces/IChessBoardInitialPositionInitiator.java b/ChessBoardImpl/src/com/chessBoard/interfaces/IChessBoardInitialPositionInitiator.java new file mode 100644 index 00000000..0967de07 --- /dev/null +++ b/ChessBoardImpl/src/com/chessBoard/interfaces/IChessBoardInitialPositionInitiator.java @@ -0,0 +1,7 @@ +package com.chessBoard.interfaces; + +import com.coordinates.Coordinates; + +public interface IChessBoardInitialPositionInitiator { + boolean setChessPieceAtCoordinate(Coordinates coordinates, IChessBoard chessBoard); +} diff --git a/ChessBoardImpl/src/com/chessPiece/BishopChessPiece.java b/ChessBoardImpl/src/com/chessPiece/BishopChessPiece.java new file mode 100644 index 00000000..bd2a80b9 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/BishopChessPiece.java @@ -0,0 +1,30 @@ +package com.chessPiece; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public class BishopChessPiece extends ChessPiece { + + + public BishopChessPiece(ChessPieceColor chessPieceColor) { + super(ChessPieceType.BISHOP, chessPieceColor); + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + return super.isValidMove(startPosition, endPosition, chessBoard); + } + + @Override + protected void instantiatePossibleDirections() { + this.possibleDirections.add(Direction.LEFT_DOWN); + this.possibleDirections.add(Direction.LEFT_UP); + this.possibleDirections.add(Direction.RIGHT_DOWN); + this.possibleDirections.add(Direction.RIGHT_UP); + } + + +} diff --git a/ChessBoardImpl/src/com/chessPiece/ChessPiece.java b/ChessBoardImpl/src/com/chessPiece/ChessPiece.java new file mode 100644 index 00000000..f02d8683 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/ChessPiece.java @@ -0,0 +1,205 @@ +package com.chessPiece; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +import com.chessBoard.interfaces.IChessBoard; +import com.chessPiece.interfaces.IChessPiece; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public abstract class ChessPiece implements IChessPiece { + + private ChessPieceType chessPieceType; + + private ChessPieceColor chessPieceColor; + + protected Set possibleDirections; + + ChessPiece(ChessPieceType chessPieceType, ChessPieceColor chessPieceColor) { + this.chessPieceType = chessPieceType; + this.instantiatePossibleDirections(); + } + + protected abstract void instantiatePossibleDirections(); + @Override + public ChessPieceType getChessPieceType() { + return this.chessPieceType; + } + + @Override + public ChessPieceColor getChessPieceColor() { + // TODO Auto-generated method stub + return this.chessPieceColor; + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + if (startPosition.getChessCellColor() != endPosition.getChessCellColor()) { + return false; + } + + Direction direction = this.getDirection(startPosition, endPosition); + + if (!this.possibleDirections.contains(direction)) { + return false; + } + + if (!this.isPathEmpty(startPosition, endPosition, direction, chessBoard)) { + return false; + } + + return false; + } + + + + @Override + public Set getAllPossibleNextCoordinates(IChessBoard chessBoard, Coordinates currentPosition) { + Set coordinateList = new HashSet<>(); + + Iterator it = this.possibleDirections.iterator(); + + while (it.hasNext()) { + Direction direction = it.next(); + Set directionCoordinates = this.getAllPossibleNextCoordinatesInDirection(chessBoard, currentPosition, direction); + + if (directionCoordinates != null) { + coordinateList.addAll(directionCoordinates); + } + } + + return coordinateList; + } + + + + @Override + public Set getAllPossibleNextCoordinatesInDirection(IChessBoard chessBoard, + Coordinates currentPosition, Direction direction) { + Set coordinateList = new HashSet<>(); + Coordinates tracker = new Coordinates(currentPosition.getX(), currentPosition.getY(), null); + + if (direction == Direction.RANDOM) { + return null; + } + + tracker = this.updateNextPosition(tracker, direction); + while (tracker.getX() < chessBoard.getMaxX() && tracker.getY() < chessBoard.getMaxY() && tracker.getX() >= 0 && tracker.getY() >= 0) { + + coordinateList.add(chessBoard.getCoordinatesAtChessBoardObject(tracker)); + + if (chessBoard.getChessPieceAtCoordinate(tracker).getChessPieceType() != ChessPieceType.NONE) { + break; + } + + + tracker = this.updateNextPosition(tracker, direction); + } + + return coordinateList; + } + + protected Direction getDirection(Coordinates startCoordinates, Coordinates endCoordinates) { + int diffX = startCoordinates.getX() - endCoordinates.getX(); + + int diffY = startCoordinates.getY() - endCoordinates.getY(); + + if (diffX != 0 && diffY != 0 && this.getAbsValue(diffY) != this.getAbsValue(diffX)) { + return Direction.RANDOM; + } + + if (diffX < 0 && diffY < 0) { + return Direction.LEFT_UP; + } else if (diffX < 0 && diffY == 0) { + return Direction.UP; + } else if (diffX < 0) { + return Direction.RIGHT_UP; + } else if (diffX == 0 && diffY < 0) { + return Direction.LEFT; + } else if (diffX == 0) { + return Direction.RIGHT; + } else if (diffX > 0 && diffY > 0) { + return Direction.RIGHT_DOWN; + } else if (diffX > 0 && diffY == 0) { + return Direction.DOWN; + } else { + return Direction.LEFT_DOWN; + } + } + + protected boolean isPathEmpty(Coordinates startPosition, Coordinates endPosition, Direction direction, IChessBoard chessBoard) { + if (direction == Direction.RANDOM) { + return true; + } + Coordinates tracker = new Coordinates(startPosition.getX(), startPosition.getY(), null); + + tracker = this.updateNextPosition(tracker, direction); + while (tracker.getX() != endPosition.getX() && tracker.getY() != endPosition.getY()) { + if (chessBoard.getChessPieceAtCoordinate(tracker).getChessPieceType() != ChessPieceType.NONE) { + return false; + } + + tracker = this.updateNextPosition(tracker, direction); + } + + return true; + } + + private Coordinates updateNextPosition(Coordinates tracker, Direction direction) { + int newX = tracker.getX(); + + int newY = tracker.getY(); + + switch (direction) { + case DOWN: + newX++; + break; + case LEFT: + newY--; + break; + case LEFT_DOWN: + newY--; + newX++; + break; + case LEFT_UP: + newY--; + newX--; + break; + case RIGHT: + newY++; + break; + case RIGHT_DOWN: + newY++; + newX++; + break; + case RIGHT_UP: + newY++; + newX--; + break; + case UP: + newX--; + break; + default: + break; + } + + return new Coordinates(newX, newY, null); + + } + + protected int getAbsValue(int number) { + if (number < 0) { + return number * -1; + } + + return number; + } + + + + +} diff --git a/ChessBoardImpl/src/com/chessPiece/KingChessPiece.java b/ChessBoardImpl/src/com/chessPiece/KingChessPiece.java new file mode 100644 index 00000000..3588f172 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/KingChessPiece.java @@ -0,0 +1,52 @@ +package com.chessPiece; + +import java.util.stream.Stream; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public class KingChessPiece extends ChessPiece { + + public KingChessPiece(ChessPieceColor chessPieceColor) { + super(ChessPieceType.KING, chessPieceColor); + // TODO Auto-generated constructor stub + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + if (!super.isValidMove(startPosition, endPosition, chessBoard)) { + return false; + } + + if (chessBoard.getBlockedPositionsForKing(this.getChessPieceColor()).contains(endPosition)) { + return false; + } + + int diffX = startPosition.getX() - endPosition.getX(); + + int diffY = startPosition.getY() - endPosition.getY(); + + if (diffX < -1 || diffX > 1) { + return false; + } + + if (diffY < -1 || diffY > 1) { + return false; + } + + return true; + } + + @Override + protected void instantiatePossibleDirections() { + Stream.of(Direction.values()).forEach(s -> { + this.possibleDirections.add(s); + }); + } + + + +} diff --git a/ChessBoardImpl/src/com/chessPiece/KnightChessPiece.java b/ChessBoardImpl/src/com/chessPiece/KnightChessPiece.java new file mode 100644 index 00000000..d835a756 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/KnightChessPiece.java @@ -0,0 +1,37 @@ +package com.chessPiece; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public class KnightChessPiece extends ChessPiece { + + public KnightChessPiece(ChessPieceColor chessPieceColor) { + super(ChessPieceType.KNIGHT, chessPieceColor); + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + if (!super.isValidMove(startPosition, endPosition, chessBoard)) { + return false; + } + + int diffX = startPosition.getX() - endPosition.getY(); + + int diffY = startPosition.getY() - endPosition.getY(); + + if (this.getAbsValue(diffY) > 2 || this.getAbsValue(diffX) > 2 || this.getAbsValue(diffY) + this.getAbsValue(diffX) != 3) { + return false; + } + + return true; + } + + @Override + protected void instantiatePossibleDirections() { + this.possibleDirections.add(Direction.RANDOM); + } + +} diff --git a/ChessBoardImpl/src/com/chessPiece/NoChessPiece.java b/ChessBoardImpl/src/com/chessPiece/NoChessPiece.java new file mode 100644 index 00000000..592e428b --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/NoChessPiece.java @@ -0,0 +1,27 @@ +package com.chessPiece; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceType; + +public class NoChessPiece extends ChessPiece { + + public NoChessPiece() { + super(ChessPieceType.NONE, null); + // TODO Auto-generated constructor stub + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + // TODO Auto-generated method stub + return false; + } + + @Override + protected void instantiatePossibleDirections() { + // TODO Auto-generated method stub + + } + + +} diff --git a/ChessBoardImpl/src/com/chessPiece/PawnChessPiece.java b/ChessBoardImpl/src/com/chessPiece/PawnChessPiece.java new file mode 100644 index 00000000..a3d143d4 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/PawnChessPiece.java @@ -0,0 +1,78 @@ +package com.chessPiece; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public class PawnChessPiece extends ChessPiece { + + + + public PawnChessPiece(ChessPieceColor chessPieceColor) { + super(ChessPieceType.PAWN, chessPieceColor); + // TODO Auto-generated constructor stub + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + if (!super.isValidMove(startPosition, endPosition, chessBoard)) { + return false; + } + + Direction direction = this.getDirection(startPosition, endPosition); + + if (direction == Direction.DOWN || direction == Direction.UP) { + int absDiff = this.getAbsValue(startPosition.getX() - endPosition.getX()); + + int boardStartPos; + + if (this.getChessPieceColor() == ChessPieceColor.BLACK) { + boardStartPos = 1; + } else { + boardStartPos = chessBoard.getMaxX() - 2; + } + + if (startPosition.getX() == boardStartPos && (absDiff > 2)) { + return false; + } else if (startPosition.getX() != boardStartPos && absDiff > 1) { + return false; + } + if (chessBoard.getChessPieceAtCoordinate(endPosition).getChessPieceType() != ChessPieceType.NONE) { + return false; + } + + return true; + } + + int absDiffX = this.getAbsValue(startPosition.getX() - endPosition.getX()); + + int absDiffY = this.getAbsValue(endPosition.getY() - endPosition.getY()); + + if (absDiffX != 1 || absDiffY != 1) { + return false; + } + + if (chessBoard.getChessPieceAtCoordinate(endPosition).getChessPieceType() == ChessPieceType.NONE || chessBoard.getChessPieceAtCoordinate(endPosition).getChessPieceColor() == this.getChessPieceColor()) { + return false; + } + + return true; + + } + + @Override + protected void instantiatePossibleDirections() { + if (this.getChessPieceColor() == ChessPieceColor.BLACK) { + this.possibleDirections.add(Direction.DOWN); + this.possibleDirections.add(Direction.LEFT_DOWN); + this.possibleDirections.add(Direction.RIGHT_DOWN); + } else { + this.possibleDirections.add(Direction.UP); + this.possibleDirections.add(Direction.LEFT_UP); + this.possibleDirections.add(Direction.RIGHT_UP); + } + } + +} diff --git a/ChessBoardImpl/src/com/chessPiece/QueenChessPiece.java b/ChessBoardImpl/src/com/chessPiece/QueenChessPiece.java new file mode 100644 index 00000000..a8913a11 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/QueenChessPiece.java @@ -0,0 +1,29 @@ +package com.chessPiece; + +import java.util.stream.Stream; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public class QueenChessPiece extends ChessPiece { + + public QueenChessPiece(ChessPieceColor chessPieceColor) { + super(ChessPieceType.QUEEN, chessPieceColor); + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + return super.isValidMove(startPosition, endPosition, chessBoard); + } + + @Override + protected void instantiatePossibleDirections() { + Stream.of(Direction.values()).forEach(s -> { + this.possibleDirections.add(s); + }); + } + +} diff --git a/ChessBoardImpl/src/com/chessPiece/RookChessPiece.java b/ChessBoardImpl/src/com/chessPiece/RookChessPiece.java new file mode 100644 index 00000000..d07aa5b6 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/RookChessPiece.java @@ -0,0 +1,29 @@ +package com.chessPiece; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public class RookChessPiece extends ChessPiece { + + public RookChessPiece(ChessPieceColor chessPieceColor) { + super(ChessPieceType.ROOK, chessPieceColor); + // TODO Auto-generated constructor stub + } + + @Override + public boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard) { + return super.isValidMove(startPosition, endPosition, chessBoard); + } + + @Override + protected void instantiatePossibleDirections() { + this.possibleDirections.add(Direction.DOWN); + this.possibleDirections.add(Direction.RIGHT); + this.possibleDirections.add(Direction.UP); + this.possibleDirections.add(Direction.LEFT); + } + +} diff --git a/ChessBoardImpl/src/com/chessPiece/factory/ChessPieceFactory.java b/ChessBoardImpl/src/com/chessPiece/factory/ChessPieceFactory.java new file mode 100644 index 00000000..439c1039 --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/factory/ChessPieceFactory.java @@ -0,0 +1,39 @@ +package com.chessPiece.factory; + +import com.chessPiece.BishopChessPiece; +import com.chessPiece.KingChessPiece; +import com.chessPiece.KnightChessPiece; +import com.chessPiece.NoChessPiece; +import com.chessPiece.PawnChessPiece; +import com.chessPiece.QueenChessPiece; +import com.chessPiece.RookChessPiece; +import com.chessPiece.interfaces.IChessPiece; +import com.chessPiece.interfaces.IChessPieceFactory; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; + +public class ChessPieceFactory implements IChessPieceFactory { + + @Override + public IChessPiece createChessPiece(ChessPieceType chessPieceType, ChessPieceColor chessPieceColor) { + switch (chessPieceType) { + case PAWN: + return new PawnChessPiece(chessPieceColor); + case QUEEN: + return new QueenChessPiece(chessPieceColor); + case KING: + return new KingChessPiece(chessPieceColor); + case ROOK: + return new RookChessPiece(chessPieceColor); + case BISHOP: + return new BishopChessPiece(chessPieceColor); + case KNIGHT: + return new KnightChessPiece(chessPieceColor); + case NONE: + default: + return new NoChessPiece(); + + } + } + +} diff --git a/ChessBoardImpl/src/com/chessPiece/interfaces/IChessPiece.java b/ChessBoardImpl/src/com/chessPiece/interfaces/IChessPiece.java new file mode 100644 index 00000000..48b036ec --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/interfaces/IChessPiece.java @@ -0,0 +1,21 @@ +package com.chessPiece.interfaces; + +import java.util.Set; + +import com.chessBoard.interfaces.IChessBoard; +import com.coordinates.Coordinates; +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; +import com.enums.Direction; + +public interface IChessPiece { + boolean isValidMove(Coordinates startPosition, Coordinates endPosition, IChessBoard chessBoard); + + ChessPieceType getChessPieceType(); + + ChessPieceColor getChessPieceColor(); + + Set getAllPossibleNextCoordinates(IChessBoard chessBoard, Coordinates currentPosition); + + Set getAllPossibleNextCoordinatesInDirection(IChessBoard chessBoard, Coordinates currentPosition, Direction direction); +} diff --git a/ChessBoardImpl/src/com/chessPiece/interfaces/IChessPieceFactory.java b/ChessBoardImpl/src/com/chessPiece/interfaces/IChessPieceFactory.java new file mode 100644 index 00000000..0365195d --- /dev/null +++ b/ChessBoardImpl/src/com/chessPiece/interfaces/IChessPieceFactory.java @@ -0,0 +1,8 @@ +package com.chessPiece.interfaces; + +import com.enums.ChessPieceColor; +import com.enums.ChessPieceType; + +public interface IChessPieceFactory { + IChessPiece createChessPiece(ChessPieceType chessPieceType, ChessPieceColor chessPieceColor); +} diff --git a/ChessBoardImpl/src/com/coordinates/Coordinates.java b/ChessBoardImpl/src/com/coordinates/Coordinates.java new file mode 100644 index 00000000..d5540e46 --- /dev/null +++ b/ChessBoardImpl/src/com/coordinates/Coordinates.java @@ -0,0 +1,32 @@ +package com.coordinates; + +import com.enums.ChessCellColor; + +public class Coordinates { + private int x; + + private int y; + + private ChessCellColor chessCellColor; + + + public Coordinates(int x, int y, ChessCellColor chessCellColor) { + this.x = x; + this.y = y; + this.chessCellColor = chessCellColor; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + public ChessCellColor getChessCellColor() { + return chessCellColor; + } + + +} diff --git a/ChessBoardImpl/src/com/enums/ChessCellColor.java b/ChessBoardImpl/src/com/enums/ChessCellColor.java new file mode 100644 index 00000000..469ae5b7 --- /dev/null +++ b/ChessBoardImpl/src/com/enums/ChessCellColor.java @@ -0,0 +1,6 @@ +package com.enums; + +public enum ChessCellColor { + BLACK, + WHITE +} diff --git a/ChessBoardImpl/src/com/enums/ChessPieceColor.java b/ChessBoardImpl/src/com/enums/ChessPieceColor.java new file mode 100644 index 00000000..31b371e9 --- /dev/null +++ b/ChessBoardImpl/src/com/enums/ChessPieceColor.java @@ -0,0 +1,21 @@ +package com.enums; + +public enum ChessPieceColor { + + BLACK('B'), + WHITE('W'), + NONE('-'); + + private char value; + + private ChessPieceColor(char value) { + this.value = value; + } + + public char getValue() { + return value; + } + + + +} diff --git a/ChessBoardImpl/src/com/enums/ChessPieceType.java b/ChessBoardImpl/src/com/enums/ChessPieceType.java new file mode 100644 index 00000000..dc3bd47c --- /dev/null +++ b/ChessBoardImpl/src/com/enums/ChessPieceType.java @@ -0,0 +1,23 @@ +package com.enums; + +public enum ChessPieceType { + PAWN('P'), + ROOK('R'), + KNIGHT('N'), + BISHOP('B'), + QUEEN('Q'), + KING('K'), + NONE('-'); + + + private char value; + + private ChessPieceType(char value) { + this.value = value; + } + + public char getValue() { + return value; + } + +} diff --git a/ChessBoardImpl/src/com/enums/Direction.java b/ChessBoardImpl/src/com/enums/Direction.java new file mode 100644 index 00000000..542c1de0 --- /dev/null +++ b/ChessBoardImpl/src/com/enums/Direction.java @@ -0,0 +1,13 @@ +package com.enums; + +public enum Direction { + LEFT, + RIGHT, + UP, + DOWN, + LEFT_UP, + LEFT_DOWN, + RIGHT_UP, + RIGHT_DOWN, + RANDOM +} diff --git a/ChessBoardImpl/src/module-info.java b/ChessBoardImpl/src/module-info.java new file mode 100644 index 00000000..b16f021a --- /dev/null +++ b/ChessBoardImpl/src/module-info.java @@ -0,0 +1,8 @@ +/** + * + */ +/** + * + */ +module ChessBoard { +} \ No newline at end of file