[체스] 서프(이재훈) 제출합니다.

src/main/java/chess/ChessBoard.java

@@ -0,0 +1,102 @@
+package chess;
+
+import chess.piece.Bishop;
+import chess.piece.BlackPawn;
+import chess.piece.King;
+import chess.piece.Knight;
+import chess.piece.Piece;
+import chess.piece.Queen;
+import chess.piece.Rook;
+import chess.piece.WhitePawn;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ChessBoard {
+
+    private static final List<Piece> INITIAL_PIECES = List.of(
+            new Rook(Color.BLACK, new Position(Column.A, Row.EIGHT)),
+            new Knight(Color.BLACK, new Position(Column.B, Row.EIGHT)),
+            new Bishop(Color.BLACK, new Position(Column.C, Row.EIGHT)),
+            new Queen(Color.BLACK, new Position(Column.D, Row.EIGHT)),
+            new King(Color.BLACK, new Position(Column.E, Row.EIGHT)),
+            new Bishop(Color.BLACK, new Position(Column.F, Row.EIGHT)),
+            new Knight(Color.BLACK, new Position(Column.G, Row.EIGHT)),
+            new Rook(Color.BLACK, new Position(Column.H, Row.EIGHT)),
+            new BlackPawn(new Position(Column.A, Row.SEVEN)),
+            new BlackPawn(new Position(Column.B, Row.SEVEN)),
+            new BlackPawn(new Position(Column.C, Row.SEVEN)),
+            new BlackPawn(new Position(Column.D, Row.SEVEN)),
+            new BlackPawn(new Position(Column.E, Row.SEVEN)),
+            new BlackPawn(new Position(Column.F, Row.SEVEN)),
+            new BlackPawn(new Position(Column.G, Row.SEVEN)),
+            new BlackPawn(new Position(Column.H, Row.SEVEN)),
+
+            new Rook(Color.WHITE, new Position(Column.A, Row.ONE)),
+            new Knight(Color.WHITE, new Position(Column.B, Row.ONE)),
+            new Bishop(Color.WHITE, new Position(Column.C, Row.ONE)),
+            new Queen(Color.WHITE, new Position(Column.D, Row.ONE)),
+            new King(Color.WHITE, new Position(Column.E, Row.ONE)),
+            new Bishop(Color.WHITE, new Position(Column.F, Row.ONE)),
+            new Knight(Color.WHITE, new Position(Column.G, Row.ONE)),
+            new Rook(Color.WHITE, new Position(Column.H, Row.ONE)),
+            new WhitePawn(new Position(Column.A, Row.TWO)),
+            new WhitePawn(new Position(Column.B, Row.TWO)),
+            new WhitePawn(new Position(Column.C, Row.TWO)),
+            new WhitePawn(new Position(Column.D, Row.TWO)),
+            new WhitePawn(new Position(Column.E, Row.TWO)),
+            new WhitePawn(new Position(Column.F, Row.TWO)),
+            new WhitePawn(new Position(Column.G, Row.TWO)),
+            new WhitePawn(new Position(Column.H, Row.TWO))
+    );
+
+    private List<Piece> pieces;
+
+    public ChessBoard(List<Piece> pieces) {
+        this.pieces = pieces;
+    }
+
+    public static ChessBoard initialize() {
+        return new ChessBoard(new ArrayList<>(INITIAL_PIECES));
+    }
+
+    public void move(Color color, Position from, Position to) {
+        if (isNotExistPiece(from)) {
+            throw new IllegalArgumentException("출발지에 기물이 없습니다.");
+        }
+        findPiece(from).move(this, color, to);
+    }
+
+    public boolean isExistPiece(Position position) {
+        return pieces.stream()
+                .anyMatch(piece -> piece.isPosition(position));
+    }
+
+    public boolean isNotExistPiece(Position position) {
+        return !isExistPiece(position);
+    }
+
+    public boolean isColorInPosition(Color color, Position position) {
+        if (isNotExistPiece(position)) {
+            return false;
+        }
+        return findPiece(position).isColor(color);
+    }
+
+    public Piece findPiece(Position position) {
+        return pieces.stream()
+                .filter(piece -> piece.isPosition(position))
+                .findFirst()
+                .orElse(null);
+    }
+
+    public List<Piece> getPieces() {
+        return Collections.unmodifiableList(pieces);
+    }
+
+    public void remove(Position position) {
+        pieces = pieces.stream()
+                .filter(piece -> !piece.isPosition(position))
+                .toList();
+    }
+}

src/main/java/chess/ChessGame.java

@@ -0,0 +1,65 @@
+package chess;
+
+import chess.piece.Piece;
+import java.util.Scanner;
+
+public class ChessGame {
+
+    private static final Scanner scanner = new Scanner(System.in);
+    private static final Color START_COLOR = Color.WHITE;
+
+    public static void main(String[] args) {
+        ChessGame chessGame = new ChessGame();
+        chessGame.play();
+    }
+
+    public void play() {
+        System.out.println("게임을 시작합니다.");
+        ChessBoard chessBoard = ChessBoard.initialize();
+        printChessBoard(chessBoard);
+
+        Color currentTurnColor = START_COLOR;
+        while (true) {
+            System.out.println(currentTurnColor + "의 차례입니다. 기물을 이동하세요 ex) a1 a2");
+
+            String[] commands = readLine().split(" ");
+            Position from = toPosition(commands[0]);
+            Position to = toPosition(commands[1]);
+            chessBoard.move(currentTurnColor, from, to);
+            printChessBoard(chessBoard);
+            currentTurnColor = currentTurnColor.opposite();
+        }
+    }
+
+    private void printChessBoard(ChessBoard chessBoard) {
+        StringBuilder sb = new StringBuilder();
+        for (int rowSymbol = 8; rowSymbol > 0; rowSymbol--) {
+            Row row = Row.fromSymbol(rowSymbol);
+            sb.append(row.getSymbol()).append("  ");
+            for (char col = 'A'; col <= 'H'; col++) {
+                Column column = Column.valueOf(col + "");
+                Position position = new Position(row, column);
+                Piece piece = chessBoard.findPiece(position);
+                if (piece == null) {
+                    sb.append(". ");
+                    continue;
+                }
+                sb.append(piece).append(" ");
+            }
+            sb.append("\n");
+        }
+        sb.append("   ").append("a b c d e f g h");
+
+        System.out.println(sb);
+    }
+
+    private String readLine() {
+        return scanner.nextLine().trim();
+    }
+
+    private Position toPosition(String command) {
+        Column column = Column.valueOf(Character.toString(command.charAt(0)).toUpperCase());
+        Row row = Row.fromSymbol(command.charAt(1) - '0');
+        return new Position(column, row);
+    }
+}

src/main/java/chess/Color.java

@@ -6,6 +6,7 @@ public enum Color {
     WHITE,
     EMPTY;
 
+
     public boolean isWhite() {
         return this == WHITE;
     }

src/main/java/chess/Position.java

@@ -167,4 +167,8 @@ public Position moveHorizontal(final int step) {
         }
         return this;
     }
+
+    public boolean isRow(Row row) {
+        return this.row == row;
+    }
 }

src/main/java/chess/Row.java

@@ -1,15 +1,30 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Row {
 
-    EIGHT,
-    SEVEN,
-    SIX,
-    FIVE,
-    FOUR,
-    THREE,
-    TWO,
-    ONE;
+    EIGHT(8),
+    SEVEN(7),
+    SIX(6),
+    FIVE(5),
+    FOUR(4),
+    THREE(3),
+    TWO(2),
+    ONE(1);
+
+    private final int symbol;
+
+    Row(int symbol) {
+        this.symbol = symbol;
+    }
+
+    public static Row fromSymbol(int symbol) {
+        return Arrays.stream(values())
+                .filter(row -> row.symbol == symbol)
+                .findFirst()
+                .orElseThrow(IllegalArgumentException::new);
+    }
 
     public boolean isTop() {
         return ordinal() == 0;
@@ -50,4 +65,8 @@ public Row moveDown(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public int getSymbol() {
+        return symbol;
+    }
 }

src/main/java/chess/piece/Bishop.java

@@ -1,5 +1,46 @@
 package chess.piece;
 
-public class Bishop {
+import chess.ChessBoard;
+import chess.Color;
+import chess.Movement;
+import chess.Position;
+import java.util.List;
 
+public class Bishop extends Piece {
+
+    private static final List<Movement> MOVEMENTS = List.of(
+            Movement.LEFT_UP, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.RIGHT_DOWN
+    );
+
+    public Bishop(Color color, Position position) {
+        super(color, position);
+    }
+
+    @Override
+    protected boolean isMovable(ChessBoard chessBoard, Position to) {
+        for (Movement movement : MOVEMENTS) {
+            Position curr = position;
+            while (!curr.equals(to)) {
+                if (!curr.canMove(movement)) {
+                    break;
+                }
+                curr = curr.move(movement);
+                if (chessBoard.isExistPiece(curr)) {
+                    break;
+                }
+            }
+            if (curr.equals(to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        if (isColor(Color.BLACK)) {
+            return "b";
+        }
+        return "B";
+    }
 }

src/main/java/chess/piece/BlackPawn.java

@@ -0,0 +1,42 @@
+package chess.piece;
+
+import chess.ChessBoard;
+import chess.Color;
+import chess.Movement;
+import chess.Position;
+import chess.Row;
+import java.util.Set;
+
+public class BlackPawn extends Pawn {
+
+    private static final Row INITINAL_ROW = Row.SEVEN;
+
+    public BlackPawn(Position position) {
+        super(Color.BLACK, position);
+    }
+
+    @Override
+    protected boolean isAttack(ChessBoard chessBoard, Position to) {
+        return chessBoard.isColorInPosition(Color.WHITE, to);
+    }
+
+    @Override
+    protected boolean isFirstMovement() {
+        return position.isRow(INITINAL_ROW);
+    }
+
+    @Override
+    protected Set<Movement> attackMovements() {
+        return Set.of(Movement.LEFT_DOWN, Movement.RIGHT_DOWN);
+    }
+
+    @Override
+    protected Movement movement() {
+        return Movement.DOWN;
+    }
+
+    @Override
+    public String toString() {
+        return "p";
+    }
+}

src/main/java/chess/piece/King.java

@@ -1,5 +1,42 @@
 package chess.piece;
 
-public class King {
+import chess.ChessBoard;
+import chess.Color;
+import chess.Movement;
+import chess.Position;
+import java.util.Set;
 
+public class King extends Piece {
+
+    private static final Set<Movement> MOVEMENTS = Set.of(
+            Movement.UP, Movement.DOWN, Movement.LEFT, Movement.RIGHT,
+            Movement.LEFT_UP, Movement.LEFT_DOWN, Movement.RIGHT_UP, Movement.RIGHT_DOWN
+    );
+
+    public King(Color color, Position position) {
+        super(color, position);
+    }
+
+    @Override
+    protected boolean isMovable(ChessBoard chessBoard, Position to) {
+        for (Movement movement : MOVEMENTS) {
+            Position curr = position;
+            if (!curr.canMove(movement)) {
+                continue;
+            }
+            curr = curr.move(movement);
+            if (curr.equals(to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        if (isColor(Color.BLACK)) {
+            return "k";
+        }
+        return "K";
+    }
 }