[Starve] Mission5 - 보드에 위치 부여 및 점수 계산

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,109 @@
 public class Board {
     public static final int BOARD_SIZE = 8;
 
-    private final List<Piece> whitePieces = new ArrayList<>();
-    private final List<Piece> blackPieces = new ArrayList<>();
+    private final List<Rank> 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;
-        }
-        getAddErrorMessage();
+    public int countingAllPiecesByColor(Color color){
+        int count = 0;
+        count += countPiecesByColorAndType(color, Type.PAWN);
+        count += countPiecesByColorAndType(color, Type.ROOK);
+        count += countPiecesByColorAndType(color, Type.KNIGHT);
+        count += countPiecesByColorAndType(color, Type.BISHOP);
+        count += countPiecesByColorAndType(color, Type.QUEEN);
+        count += countPiecesByColorAndType(color, Type.KING);
+        return count;
     }
 
-    private void getAddErrorMessage(){
-        System.out.println("알 수 없는 color의 piece입니다.");
-        System.out.println("add에 실패하였습니다.");
-    }
+    public int countPiecesByColorAndType(Color color, Type type) {
+        int countPiece = 0;
+        for (Rank rank : ranks) {
+            countPiece += rank.getCountPiecesByColorAndType(color, type);
+        }
 
-    public int totalPiecesCount() {
-        return whitePieces.size() + blackPieces.size();
+        return countPiece;
     }
 
-    private void appendChessPieceToSort(StringBuilder stringBuilder, Piece piece){
-        stringBuilder.append(piece.getRepresentation());
-        if (stringBuilder.length() == BOARD_SIZE) {
-            stringBuilder.append(StringUtils.getNewLine());
+    public List<Piece> findPiecesByColor(Color color) {
+        List<Piece> 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 chessBoardIndex = new Position(position);
+
+        return ranks.get((chessBoardIndex.getFile())).getPiece(chessBoardIndex.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 chessBoardIndex = 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(chessBoardIndex.getFile()).move(chessBoardIndex.getRank(), piece);
+        piece.setPosition(chessBoardIndex);
+    }
 
-        for (int i = 0; i < BOARD_SIZE; i++) {
-            addBlackPieces(Piece.createBlackPawn());
+    public double calculatePointByColor(Color color) {
+        List<Piece> 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();
     }
 }

src/main/java/chess/Rank.java

@@ -0,0 +1,134 @@
+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<Piece> pieces = new ArrayList<>(Board.BOARD_SIZE);
+    private final int RANK_INDEX = 8;
+
+    public List<Piece> 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 position, Piece piece) {
+        pieces.set(position, piece);
+    }
+
+    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<Piece> findPieceByColor(Color color) {
+        List<Piece> pieceByColor = new ArrayList<>(Board.BOARD_SIZE);
+
+        for (Piece piece : pieces) {
+            if (piece.matchColor(color)) {
+                pieceByColor.add(piece);
+            }
+        }
+
+        return pieceByColor;
+    }
+}

src/main/java/chess/pieces/Color.java

@@ -2,5 +2,6 @@
 
 public enum Color {
     WHITE,
-    BLACK
+    BLACK,
+    NO_COLOR
 }