diff --git a/src/main/java/chess/Board.java b/src/main/java/chess/Board.java index 37322ae5e..5566d9922 100644 --- a/src/main/java/chess/Board.java +++ b/src/main/java/chess/Board.java @@ -2,6 +2,7 @@ import chess.pieces.Color; import chess.pieces.Piece; +import chess.pieces.Position; import chess.pieces.Type; import utils.StringUtils; @@ -11,110 +12,107 @@ public class Board { public static final int BOARD_SIZE = 8; - private final List whitePieces = new ArrayList<>(); - private final List blackPieces = new ArrayList<>(); + private final List ranks = new ArrayList<>(BOARD_SIZE); - public void addWhitePieces(Piece piece) { - if (piece.isWhite()) { - whitePieces.add(piece); - return; - } - getAddErrorMessage(); + public int totalPiecesCount() { + return countingAllPiecesByColor(Color.WHITE) + countingAllPiecesByColor(Color.BLACK); } - public void addBlackPieces(Piece piece) { - if (piece.isBlack()) { - blackPieces.add(piece); - return; + public int countingAllPiecesByColor(Color color) { + int count = 0; + + for (Type type : Type.values()) { + count += countPiecesByColorAndType(color, type); } - getAddErrorMessage(); - } - private void getAddErrorMessage(){ - System.out.println("알 수 없는 color의 piece입니다."); - System.out.println("add에 실패하였습니다."); + return count; } - public int totalPiecesCount() { - return whitePieces.size() + blackPieces.size(); + public int countPiecesByColorAndType(Color color, Type type) { + int countPiece = 0; + for (Rank rank : ranks) { + countPiece += rank.getCountPiecesByColorAndType(color, type); + } + + return countPiece; } - private void appendChessPieceToSort(StringBuilder stringBuilder, Piece piece){ - stringBuilder.append(piece.getRepresentation()); - if (stringBuilder.length() == BOARD_SIZE) { - stringBuilder.append(StringUtils.getNewLine()); + public List findPiecesByColor(Color color) { + List pieces = new ArrayList<>(); + + for (Rank rank : ranks) { + pieces.addAll(rank.findPieceByColor(color)); } + + return pieces; } - private String getPiecesSort(Color color) { + public Piece findPiece(String position) { + Position positionNumber = new Position(position); + + return ranks.get(positionNumber.getFile()).getPiece(positionNumber.getRank()); + } + + private String getRank(Rank rank) { StringBuilder sb = new StringBuilder(); - switch (color) { - case WHITE: - for (Piece piece : whitePieces) { - appendChessPieceToSort(sb, piece); - } - return sb.toString(); - - case BLACK: - for (Piece piece : blackPieces) { - appendChessPieceToSort(sb, piece); - } - return sb.toString(); - - default: - return ""; + for (Piece piece : rank.getRank()) { + if (piece.isBlack()) { + sb.append(piece.getType().getBlackRepresentation()).append(" "); + } else { + sb.append(piece.getType().getWhiteRepresentation()).append(" "); + } + } + return sb.toString(); } public void initialize() { - initializeBlackPieces(); - initializeWhitePieces(); + final int FILE_INDEX = 8; + ranks.add(Rank.initializeWhitePieces(FILE_INDEX)); + ranks.add(Rank.initializeWhitePawns(FILE_INDEX - 1)); + ranks.add(Rank.initializeBlank(FILE_INDEX - 2)); + ranks.add(Rank.initializeBlank(FILE_INDEX - 3)); + ranks.add(Rank.initializeBlank(FILE_INDEX - 4)); + ranks.add(Rank.initializeBlank(FILE_INDEX - 5)); + ranks.add(Rank.initializeBlackPawns(FILE_INDEX - 6)); + ranks.add(Rank.initializeBlackPieces(FILE_INDEX - 7)); } - private void initializeWhitePieces() { - for (int i = 0; i < BOARD_SIZE; i++) { - addWhitePieces(Piece.createWhitePawn()); + public void initializeEmpty() { + for (int i = 1; i <= BOARD_SIZE; i++) { + ranks.add(Rank.initializeBlank(i)); } - - addWhitePieces(Piece.createWhiteRook()); - addWhitePieces(Piece.createWhiteKnight()); - addWhitePieces(Piece.createWhiteBishop()); - addWhitePieces(Piece.createWhiteQueen()); - addWhitePieces(Piece.createWhiteKing()); - addWhitePieces(Piece.createWhiteBishop()); - addWhitePieces(Piece.createWhiteKnight()); - addWhitePieces(Piece.createWhiteRook()); } - private void initializeBlackPieces() { + public void move(String position, Piece piece) { + Position positionNumber = new Position(position); - addBlackPieces(Piece.createBlackRook()); - addBlackPieces(Piece.createBlackKnight()); - addBlackPieces(Piece.createBlackBishop()); - addBlackPieces(Piece.createBlackQueen()); - addBlackPieces(Piece.createBlackKing()); - addBlackPieces(Piece.createBlackBishop()); - addBlackPieces(Piece.createBlackKnight()); - addBlackPieces(Piece.createBlackRook()); + ranks.get(positionNumber.getFile()).move(positionNumber.getRank(), piece, positionNumber); + } - for (int i = 0; i < BOARD_SIZE; i++) { - addBlackPieces(Piece.createBlackPawn()); + public double calculatePointByColor(Color color) { + List pieces = findPiecesByColor(color); + double point = 0.0; + for (Piece piece : pieces) { + point += piece.getPoint(pieces); } + + return point; } public String getChessBoard() { StringBuilder boardRank = new StringBuilder(); - String blank = "........"; - boardRank.append(StringUtils.addNewLine(getPiecesSort(Color.BLACK))); + String rankIndex = "a b c d e f g h"; - boardRank.append(StringUtils.addNewLine(blank)); - boardRank.append(StringUtils.addNewLine(blank)); - boardRank.append(StringUtils.addNewLine(blank)); - boardRank.append(StringUtils.addNewLine(blank)); - - boardRank.append(StringUtils.addNewLine(getPiecesSort(Color.WHITE))); + for (int fileIndex = BOARD_SIZE - 1; fileIndex >= 0; fileIndex--) { + boardRank.append(getRank(ranks.get(fileIndex))); + boardRank.append(" ").append(fileIndex + 1); + boardRank.append(StringUtils.getNewLine()); + } + boardRank.append(StringUtils.getNewLine()); + boardRank.append(StringUtils.addNewLine(rankIndex)); return boardRank.toString(); } -} \ No newline at end of file +} diff --git a/src/main/java/chess/Rank.java b/src/main/java/chess/Rank.java new file mode 100644 index 000000000..0433e2724 --- /dev/null +++ b/src/main/java/chess/Rank.java @@ -0,0 +1,135 @@ +package chess; + +import chess.pieces.Color; +import chess.pieces.Piece; +import chess.pieces.Position; +import chess.pieces.Type; + +import java.util.ArrayList; +import java.util.List; + +import static chess.pieces.Piece.*; + +public class Rank { + + private List pieces = new ArrayList<>(Board.BOARD_SIZE); + private final int RANK_INDEX = 8; + + public List getRank() { + return pieces; + } + + public Piece getPiece(int rankIndex) { + return pieces.get(rankIndex); + } + + public void addWhitePieces(Piece piece) { + if (piece.isWhite()) { + pieces.add(piece); + return; + } + getAddErrorMessage(); + } + + public void addBlackPieces(Piece piece) { + if (piece.isBlack()) { + pieces.add(piece); + return; + } + getAddErrorMessage(); + } + + public void addBlank(Piece piece) { + if (piece.getType() == Type.BLANK) { + pieces.add(piece); + return; + } + getAddErrorMessage(); + } + + public void move(int rankIndex, Piece piece, Position position) { + pieces.set(rankIndex, piece); + piece.setPosition(position); + } + + private void getAddErrorMessage() { + System.out.println("알 수 없는 color의 piece입니다."); + System.out.println("add에 실패하였습니다."); + } + + public static Rank initializeWhitePieces(int fileIndex) { + Rank rank = new Rank(); + rank.addWhitePieces(createWhiteRook(new Position(rank.RANK_INDEX, fileIndex))); + rank.addWhitePieces(createWhiteKnight(new Position(rank.RANK_INDEX - 1, fileIndex))); + rank.addWhitePieces(createWhiteBishop(new Position(rank.RANK_INDEX - 2, fileIndex))); + rank.addWhitePieces(createWhiteQueen(new Position(rank.RANK_INDEX - 3, fileIndex))); + rank.addWhitePieces(createWhiteKing(new Position(rank.RANK_INDEX - 4, fileIndex))); + rank.addWhitePieces(createWhiteBishop(new Position(rank.RANK_INDEX - 5, fileIndex))); + rank.addWhitePieces(createWhiteKnight(new Position(rank.RANK_INDEX - 6, fileIndex))); + rank.addWhitePieces(createWhiteRook(new Position(rank.RANK_INDEX - 7, fileIndex))); + + return rank; + } + + public static Rank initializeWhitePawns(int fileIndex) { + Rank rank = new Rank(); + for (int rankIndex = 0; rankIndex < Board.BOARD_SIZE; rankIndex++) { + rank.addWhitePieces(createWhitePawn(new Position(rankIndex, fileIndex))); + } + return rank; + } + + public static Rank initializeBlackPieces(int fileIndex) { + Rank rank = new Rank(); + rank.addBlackPieces(createBlackRook(new Position(rank.RANK_INDEX, fileIndex))); + rank.addBlackPieces(createBlackKnight(new Position(rank.RANK_INDEX - 1, fileIndex))); + rank.addBlackPieces(createBlackBishop(new Position(rank.RANK_INDEX - 2, fileIndex))); + rank.addBlackPieces(createBlackQueen(new Position(rank.RANK_INDEX - 3, fileIndex))); + rank.addBlackPieces(createBlackKing(new Position(rank.RANK_INDEX - 4, fileIndex))); + rank.addBlackPieces(createBlackBishop(new Position(rank.RANK_INDEX - 5, fileIndex))); + rank.addBlackPieces(createBlackKnight(new Position(rank.RANK_INDEX - 6, fileIndex))); + rank.addBlackPieces(createBlackRook(new Position(rank.RANK_INDEX - 7, fileIndex))); + + return rank; + } + + public static Rank initializeBlackPawns(int fileIndex) { + Rank rank = new Rank(); + for (int rankIndex = 0; rankIndex < Board.BOARD_SIZE; rankIndex++) { + rank.addBlackPieces(createBlackPawn(new Position(rankIndex, fileIndex))); + } + return rank; + } + + public static Rank initializeBlank(int fileIndex) { + Rank rank = new Rank(); + for (int rankIndex = 0; rankIndex < Board.BOARD_SIZE; rankIndex++) { + rank.addBlank(createBlank(new Position(rankIndex, fileIndex))); + } + return rank; + } + + public int getCountPiecesByColorAndType(Color color, Type type) { + int countPiece = 0; + + for (Piece piece : pieces) { + if (piece.matchColorAndType(color, type)) { + countPiece += 1; + } + } + + return countPiece; + } + + public List findPieceByColor(Color color) { + List pieceByColor = new ArrayList<>(Board.BOARD_SIZE); + + for (Piece piece : pieces) { + if (piece.matchColor(color)) { + pieceByColor.add(piece); + } + } + + return pieceByColor; + } +} diff --git a/src/main/java/chess/pieces/Color.java b/src/main/java/chess/pieces/Color.java index cd684a9f5..0af8da97f 100644 --- a/src/main/java/chess/pieces/Color.java +++ b/src/main/java/chess/pieces/Color.java @@ -2,5 +2,6 @@ public enum Color { WHITE, - BLACK + BLACK, + NO_COLOR } diff --git a/src/main/java/chess/pieces/Piece.java b/src/main/java/chess/pieces/Piece.java index 8f1ea145e..43e6d6ed7 100644 --- a/src/main/java/chess/pieces/Piece.java +++ b/src/main/java/chess/pieces/Piece.java @@ -1,18 +1,53 @@ package chess.pieces; -public class Piece { +import java.util.List; + +public class Piece implements Comparable { private final Color color; private final Type type; + private Position position; - private Piece(Color color, Type type) { + private Piece(Color color, Type type, Position position) { this.color = color; this.type = type; + this.position = position; } public Color getColor() { return this.color; } + public Type getType() { + return this.type; + } + + public Position getPosition() { + return this.position; + } + + public void setPosition(Position position) { + this.position = position; + } + + public double getDefaultPoint() { + return this.getType().getDefaultPoint(); + } + + public double getPoint(List pieces) { + if (getType() != Type.PAWN) { + return this.type.getDefaultPoint(); + } + + double halfPawnPoint = 0.5; + List positions = this.position.getFileNeighborPosition(); + for (Position position : positions) { + if (pieces.contains(new Piece(this.color, this.type, position))) { + return this.type.getDefaultPoint() - halfPawnPoint; + } + } + return this.type.getDefaultPoint(); + } + public boolean isWhite() { return getColor() == Color.WHITE; } @@ -25,51 +60,83 @@ public char getRepresentation() { return color == Color.WHITE ? type.getWhiteRepresentation() : type.getBlackRepresentation(); } - public static Piece createWhitePawn() { - return new Piece(Color.WHITE, Type.PAWN); + public boolean matchColorAndType(Color color, Type type) { + return getColor() == color && getType() == type; + } + + public boolean matchColor(Color color) { + return getColor() == color; } - public static Piece createBlackPawn() { - return new Piece(Color.BLACK, Type.PAWN); + + private static Piece createWhite(Type type, Position position) { + return new Piece(Color.WHITE, type, position); + } + + private static Piece createBlack(Type type, Position position) { + return new Piece(Color.BLACK, type, position); + } + + public static Piece createWhitePawn(Position position) { + return createWhite(Type.PAWN, position); + } + + public static Piece createBlackPawn(Position position) { + return createBlack(Type.PAWN, position); } - public static Piece createWhiteRook() { - return new Piece(Color.WHITE, Type.ROOK); + public static Piece createWhiteRook(Position position) { + return createWhite(Type.ROOK, position); } - public static Piece createBlackRook() { - return new Piece(Color.BLACK, Type.ROOK); + public static Piece createBlackRook(Position position) { + return createBlack(Type.ROOK, position); } - public static Piece createWhiteKnight() { - return new Piece(Color.WHITE, Type.KNIGHT); + public static Piece createWhiteKnight(Position position) { + return createWhite(Type.KNIGHT, position); } - public static Piece createBlackKnight() { - return new Piece(Color.BLACK, Type.KNIGHT); + public static Piece createBlackKnight(Position position) { + return createBlack(Type.KNIGHT, position); } - public static Piece createWhiteBishop() { - return new Piece(Color.WHITE, Type.BISHOP); + public static Piece createWhiteBishop(Position position) { + return createWhite(Type.BISHOP, position); } - public static Piece createBlackBishop() { - return new Piece(Color.BLACK, Type.BISHOP); + public static Piece createBlackBishop(Position position) { + return createBlack(Type.BISHOP, position); } - public static Piece createWhiteQueen() { - return new Piece(Color.WHITE, Type.QUEEN); + public static Piece createWhiteQueen(Position position) { + return createWhite(Type.QUEEN, position); } - public static Piece createBlackQueen() { - return new Piece(Color.BLACK, Type.QUEEN); + public static Piece createBlackQueen(Position position) { + return createBlack(Type.QUEEN, position); } - public static Piece createWhiteKing() { - return new Piece(Color.WHITE, Type.KING); + public static Piece createWhiteKing(Position position) { + return createWhite(Type.KING, position); } - public static Piece createBlackKing() { - return new Piece(Color.BLACK, Type.KING); + public static Piece createBlackKing(Position position) { + return createBlack(Type.KING, position); } + + public static Piece createBlank(Position position) { + return new Piece(Color.NO_COLOR, Type.BLANK, position); + } + + @Override + public String toString() { + return String.valueOf(getRepresentation()); + } + + @Override + public int compareTo(Piece o) { + return Double.compare(getDefaultPoint(), o.getDefaultPoint()) * -1; + } + } diff --git a/src/main/java/chess/pieces/Position.java b/src/main/java/chess/pieces/Position.java new file mode 100644 index 000000000..8620c0c12 --- /dev/null +++ b/src/main/java/chess/pieces/Position.java @@ -0,0 +1,39 @@ +package chess.pieces; + +import java.util.ArrayList; +import java.util.List; + +public class Position { + private int rank, file; + + public Position(String position) { + char rankIndex = position.charAt(0); + char fileIndex = position.charAt(1); + + this.rank = rankIndex - 'a'; + this.file = (Character.getNumericValue(fileIndex)) - 1; + } + + public Position(int rank, int file) { + this.rank = rank - 1; + this.file = file - 1; + } + + public int getRank() { + return rank; + } + + public int getFile() { + return file; + } + + public List getFileNeighborPosition() { + List neighborPosition = new ArrayList<>(); + + neighborPosition.add(new Position(this.rank, this.file + 1)); + neighborPosition.add(new Position(this.rank, this.file - 1)); + + return neighborPosition; + } + +} diff --git a/src/main/java/chess/pieces/Type.java b/src/main/java/chess/pieces/Type.java index e28fd853c..b6c58991e 100644 --- a/src/main/java/chess/pieces/Type.java +++ b/src/main/java/chess/pieces/Type.java @@ -1,17 +1,20 @@ package chess.pieces; public enum Type { - PAWN('p'), - ROOK('r'), - KNIGHT('n'), - BISHOP('b'), - QUEEN('q'), - KING('k'); + PAWN('p', 1.0), + ROOK('r', 5.0), + KNIGHT('n', 2.5), + BISHOP('b', 3.0), + QUEEN('q', 9.0), + KING('k', 0.0), + BLANK('.', 0.0); private final char representation; + private final double defaultPoint; - Type(char representation) { + Type(char representation, double defaultPoint) { this.representation = representation; + this.defaultPoint = defaultPoint; } public char getWhiteRepresentation() { @@ -21,4 +24,8 @@ public char getWhiteRepresentation() { public char getBlackRepresentation() { return Character.toUpperCase(representation); } + + public double getDefaultPoint() { + return defaultPoint; + } } diff --git a/src/main/java/utils/StringUtils.java b/src/main/java/utils/StringUtils.java index 9b69ec31a..faf3aa9c6 100644 --- a/src/main/java/utils/StringUtils.java +++ b/src/main/java/utils/StringUtils.java @@ -11,7 +11,7 @@ public static String addNewLine(String text) { return text + NEWLINE; } - public static String getNewLine(){ + public static String getNewLine() { return NEWLINE; } } diff --git a/src/test/java/chess/BoardTest.java b/src/test/java/chess/BoardTest.java index 9a1baeffc..eeac03395 100644 --- a/src/test/java/chess/BoardTest.java +++ b/src/test/java/chess/BoardTest.java @@ -1,5 +1,9 @@ package chess; +import chess.pieces.Color; +import chess.pieces.Piece; +import chess.pieces.Position; +import chess.pieces.Type; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -20,18 +24,80 @@ void initBoard() { @DisplayName("체스판의 초기화가 정상적으로 이루어졌는지 확인한다.") void printBoard() { board.initialize(); - String blankRank = StringUtils.addNewLine("........"); - final int TOTAL_PIECES_COUNT = 32; + String blankRank = ". . . . . . . ."; + final int totalPiecesCount = 32; assertAll( - () -> assertThat(TOTAL_PIECES_COUNT).isEqualTo(board.totalPiecesCount()), - () -> assertThat(StringUtils.addNewLine("RNBQKBNR") + - StringUtils.addNewLine("PPPPPPPP") + - blankRank + blankRank + blankRank + blankRank + - StringUtils.addNewLine("pppppppp") + - StringUtils.addNewLine("rnbqkbnr")) - .isEqualTo(board.getChessBoard()) + () -> assertThat(totalPiecesCount).isEqualTo(board.totalPiecesCount()), + () -> assertThat(StringUtils.addNewLine("R N B Q K B N R 8") + + StringUtils.addNewLine("P P P P P P P P 7") + + StringUtils.addNewLine(blankRank + " 6") + + StringUtils.addNewLine(blankRank + " 5") + + StringUtils.addNewLine(blankRank + " 4") + + StringUtils.addNewLine(blankRank + " 3") + + StringUtils.addNewLine("p p p p p p p p 2") + + StringUtils.addNewLine("r n b q k b n r 1") + + StringUtils.getNewLine() + + StringUtils.addNewLine("a b c d e f g h")) + .isEqualTo(board.getChessBoard()) ); + } + + @Test + void findPiece() { + board.initialize(); + + assertAll( + () -> verifyPieceColorAndType(Color.BLACK, Type.ROOK, "a8"), + () -> verifyPieceColorAndType(Color.BLACK, Type.ROOK, "h8"), + () -> verifyPieceColorAndType(Color.WHITE, Type.ROOK, "a1"), + () -> verifyPieceColorAndType(Color.WHITE, Type.ROOK, "h1") + ); + } + + void verifyPieceColorAndType(Color color, Type type, String index) { + assertAll( + () -> assertThat(type).isEqualTo(board.findPiece(index).getType()), + () -> assertThat(color).isEqualTo(board.findPiece(index).getColor()) + ); + } + + @Test + public void move() { + board.initializeEmpty(); + + String position = "b5"; + Piece piece = Piece.createBlackRook(new Position(position)); + board.move(position, piece); + + assertThat(piece).isEqualTo(board.findPiece(position)); + System.out.println(board.getChessBoard()); + } + + @Test + public void calculatePoint() { + board.initializeEmpty(); + + addPiece("b6", Piece.createBlackPawn(new Position("b6"))); + addPiece("e6", Piece.createBlackQueen(new Position("e6"))); + addPiece("b8", Piece.createBlackKing(new Position("b8"))); + addPiece("c8", Piece.createBlackRook(new Position("c8"))); + + addPiece("f2", Piece.createWhitePawn(new Position("f2"))); + addPiece("g2", Piece.createWhitePawn(new Position("g2"))); + addPiece("e1", Piece.createWhiteRook(new Position("e1"))); + addPiece("f1", Piece.createWhiteKing(new Position("f1"))); + + assertAll( + () -> assertThat(15.0).isEqualTo(board.calculatePointByColor(Color.BLACK)), + () -> assertThat(7.0).isEqualTo(board.calculatePointByColor(Color.WHITE)) + ); + + + System.out.println(board.getChessBoard()); + } + private void addPiece(String position, Piece piece) { + board.move(position, piece); } } diff --git a/src/test/java/chess/pieces/PieceTest.java b/src/test/java/chess/pieces/PieceTest.java index 15b09c351..49cb6fff0 100644 --- a/src/test/java/chess/pieces/PieceTest.java +++ b/src/test/java/chess/pieces/PieceTest.java @@ -1,33 +1,73 @@ package chess.pieces; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import java.util.*; + import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertAll; class PieceTest { + Position position; + + @BeforeEach + void positionInit() { + int testPositionIndex = 1; + position = new Position(testPositionIndex, testPositionIndex); + } + + @Test + void piecesSortByPoint() { + List pieces = new ArrayList<>(); + + addPiece(pieces); + + Collections.sort(pieces); + assertThat(pieces.toString()).isEqualTo("[Q, R, B, N, P, K]"); + + } + + void addPiece(List collection) { + collection.add(Piece.createBlackPawn(position)); + collection.add(Piece.createBlackRook(position)); + collection.add(Piece.createBlackKnight(position)); + collection.add(Piece.createBlackBishop(position)); + collection.add(Piece.createBlackQueen(position)); + collection.add(Piece.createBlackKing(position)); + } + @Test @DisplayName("체스말이 정상적으로 생성되는지 확인한다.") public void createPieces() { - verifyWhitePiece(Piece.createWhitePawn(), Type.PAWN); - verifyBlackPiece(Piece.createBlackPawn(), Type.PAWN); + Piece blank = Piece.createBlank(position); - verifyWhitePiece(Piece.createWhiteRook(), Type.ROOK); - verifyBlackPiece(Piece.createBlackRook(), Type.ROOK); + assertAll( + () -> verifyWhitePiece(Piece.createWhitePawn(position), Type.PAWN), + () -> verifyBlackPiece(Piece.createBlackPawn(position), Type.PAWN), + + () -> verifyWhitePiece(Piece.createWhiteRook(position), Type.ROOK), + () -> verifyBlackPiece(Piece.createBlackRook(position), Type.ROOK), - verifyWhitePiece(Piece.createWhiteKnight(), Type.KNIGHT); - verifyBlackPiece(Piece.createBlackKnight(), Type.KNIGHT); + () -> verifyWhitePiece(Piece.createWhiteKnight(position), Type.KNIGHT), + () -> verifyBlackPiece(Piece.createBlackKnight(position), Type.KNIGHT), - verifyWhitePiece(Piece.createWhiteBishop(), Type.BISHOP); - verifyBlackPiece(Piece.createBlackBishop(), Type.BISHOP); + () -> verifyWhitePiece(Piece.createWhiteBishop(position), Type.BISHOP), + () -> verifyBlackPiece(Piece.createBlackBishop(position), Type.BISHOP), - verifyWhitePiece(Piece.createWhiteQueen(), Type.QUEEN); - verifyBlackPiece(Piece.createBlackQueen(), Type.QUEEN); + () -> verifyWhitePiece(Piece.createWhiteQueen(position), Type.QUEEN), + () -> verifyBlackPiece(Piece.createBlackQueen(position), Type.QUEEN), - verifyWhitePiece(Piece.createWhiteKing(), Type.KING); - verifyBlackPiece(Piece.createBlackKing(), Type.KING); + () -> verifyWhitePiece(Piece.createWhiteKing(position), Type.KING), + () -> verifyBlackPiece(Piece.createBlackKing(position), Type.KING), + + () -> assertThat(blank.isWhite()).isEqualTo(false), + () -> assertThat(blank.isBlack()).isEqualTo(false), + () -> assertThat(blank.getColor()).isEqualTo(Color.NO_COLOR), + () -> assertThat(blank.getRepresentation()).isEqualTo(Type.BLANK.getWhiteRepresentation()) + ); } private void verifyWhitePiece(Piece piece, Type type) {