[체스-깜짝미션] 윌슨(박형균) 제출합니다.

src/main/java/chess/ChessApplication.java

@@ -0,0 +1,44 @@
+package chess;
+
+import chess.piece.Board;
+import chess.piece.Piece;
+import chess.view.InputView;
+import chess.view.OutputView;
+import java.util.function.Supplier;
+
+public class ChessApplication {
+
+    public static void main(String[] args) {
+        final Board board = Board.emptyBoard();
+        board.gameSetUp();
+        tryCatchLoop(() -> gameStart(board));
+    }
+
+    public static void gameStart(final Board board) {
+        OutputView.printBoard(board.getMapView());
+        final Position startPosition = tryCatchLoop(InputView::readStartPosition);
+        final Position endPosition = tryCatchLoop(InputView::readEndPosition);
+        final Piece targetPiece = board.move(startPosition, endPosition);
+        OutputView.printEndPiece(targetPiece);
+        gameStart(board);
+    }
+
+    private static void tryCatchLoop(final Runnable runnable) {
+        try {
+            runnable.run();
+        } catch (IllegalArgumentException | IllegalStateException e) {
+            System.out.println(e.getMessage());
+            runnable.run();
+        }
+    }
+
+    private static <T> T tryCatchLoop(Supplier<T> callBack) {
+        try {
+            return callBack.get();
+        } catch (IllegalStateException | IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return tryCatchLoop(callBack);
+        }
+    }
+
+}

src/main/java/chess/Column.java

@@ -1,15 +1,30 @@
 package chess;
 
+import java.util.Arrays;
+
 public enum Column {
 
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-    H;
+    A(0),
+    B(1),
+    C(2),
+    D(3),
+    E(4),
+    F(5),
+    G(6),
+    H(7);
+
+    private final int value;
+
+    Column(final int value) {
+        this.value = value;
+    }
+
+    public static Column parseToColumnByNumber(final int number) {
+        return Arrays.stream(Column.values())
+                .filter(column -> column.value == number)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 위치 : " + number));
+    }
 
     public boolean isFarLeft() {
         return ordinal() == 0;
@@ -50,4 +65,15 @@ public Column moveRight(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public boolean isAvailableColumn() {
+        return this.value >= 0 && this.value <= 7;
+    }
+
+    @Override
+    public String toString() {
+        return "Column{" +
+                "value=" + value +
+                '}';
+    }
 }

src/main/java/chess/Position.java

@@ -167,4 +167,20 @@ public Position moveHorizontal(final int step) {
         }
         return this;
     }
+
+    public Position copyOf() {
+        return new Position(this.row, this.column);
+    }
+
+    public boolean isAvailableMovePosition() {
+        return this.row.isAvailableRow() && this.column.isAvailableColumn();
+    }
+
+    @Override
+    public String toString() {
+        return "Position{" +
+                "row=" + row +
+                ", column=" + column +
+                '}';
+    }
 }

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(7),
+    SEVEN(6),
+    SIX(5),
+    FIVE(4),
+    FOUR(3),
+    THREE(2),
+    TWO(1),
+    ONE(0);
+
+    private final int value;
+
+    Row(final int value) {
+        this.value = value;
+    }
+
+    public static Row parseToRowByNumber(final int number) {
+        return Arrays.stream(Row.values())
+                .filter(row -> row.value == number)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 위치 : " + number));
+    }
 
     public boolean isTop() {
         return ordinal() == 0;
@@ -50,4 +65,19 @@ public Row moveDown(final int step) {
 
         throw new IllegalStateException("움직일 수 없는 위치입니다.");
     }
+
+    public int getValue() {
+        return value;
+    }
+
+    public boolean isAvailableRow() {
+        return this.value >= 0 && this.value <= 7;
+    }
+
+    @Override
+    public String toString() {
+        return "Row{" +
+                "value=" + value +
+                '}';
+    }
 }

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

@@ -1,5 +1,83 @@
 package chess.piece;
 
-public class Bishop {
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
 
+public class Bishop extends Piece {
+
+    private static final List<Position> WHITE_BISHOP_POSITIONS = List.of(
+            new Position(Row.ONE, Column.C), new Position(Row.ONE, Column.F)
+    );
+
+    private static final List<Position> BLACK_BISHOP_POSITIONS = List.of(
+            new Position(Row.EIGHT, Column.C), new Position(Row.EIGHT, Column.F)
+    );
+
+    private static final List<Function<Position, Position>> MOVEMENTS = List.of(
+            Position::moveLeftUp,
+            Position::moveLeftDown,
+            Position::moveRightUp,
+            Position::moveRightDown
+    );
+
+    public Bishop(final Position position, final Color color) {
+        super(position, color);
+    }
+
+    public static List<Piece> initialize() {
+        final List<Piece> pieces = new ArrayList<>();
+        final List<Bishop> whiteBishops = WHITE_BISHOP_POSITIONS.stream()
+                .map(position -> new Bishop(position, Color.WHITE))
+                .toList();
+        final List<Bishop> blackBishops = BLACK_BISHOP_POSITIONS.stream()
+                .map(position -> new Bishop(position, Color.BLACK))
+                .toList();
+        pieces.addAll(whiteBishops);
+        pieces.addAll(blackBishops);
+        return pieces;
+    }
+
+    @Override
+    public List<Position> calculateAvailablePositions(final Board board) {
+        final List<Position> positions = new ArrayList<>();
+        for (Function<Position, Position> movement : MOVEMENTS) {
+            addAvailablePositions(board, getPosition(), movement, positions);
+        }
+        return positions;
+    }
+
+    @Override
+    public Piece copyOf(final Position position) {
+        return new Bishop(position, getColor());
+    }
+
+    @Override
+    public PieceType getType() {
+        return PieceType.BISHOP;
+    }
+
+    private void addAvailablePositions(final Board board, final Position position, final Function<Position, Position> function, final List<Position> positions) {
+        Position movedPosition;
+        try {
+            movedPosition = function.apply(position);
+        } catch (IllegalStateException e) {
+            return;
+        }
+        if (!isAvailablePosition(board, movedPosition)) {
+            return;
+        }
+        if (!board.isEmptyPosition(movedPosition)) {
+            if (board.isEnemy(movedPosition, this)) {
+                positions.add(movedPosition);
+            }
+            return;
+        }
+        positions.add(movedPosition);
+        addAvailablePositions(board, movedPosition, function, positions);
+    }
 }

src/main/java/chess/piece/Board.java

@@ -0,0 +1,75 @@
+package chess.piece;
+
+import chess.Position;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Board {
+
+    private final Map<Position, Piece> mapView;
+
+    public static Board emptyBoard() {
+        return new Board(new HashMap<>());
+    }
+
+    public void gameSetUp() {
+        final List<Piece> pawns = Pawn.initialize();
+        final List<Piece> knights = Knight.initialize();
+        final List<Piece> rooks = Rook.initialize();
+        final List<Piece> bishops = Bishop.initialize();
+        final List<Piece> kings = King.initialize();
+        final List<Piece> queens = Queen.initialize();
+        locatePiece(pawns, knights, rooks, bishops, kings, queens);
+    }
+
+    private void locatePiece(final List<Piece> ...piecesGroup) {
+        for (List<Piece> pieces : piecesGroup) {
+            for (Piece piece : pieces) {
+                mapView.put(piece.getPosition(), piece);
+            }
+        }
+    }
+
+    public Board(final Map<Position, Piece> mapView) {
+        this.mapView = mapView;
+    }
+
+    public boolean isSameTeam(final Position position, final Piece piece) {
+        return mapView.get(position).getColor() == piece.getColor();
+    }
+
+    public boolean isEmptyPosition(final Position position) {
+        return mapView.get(position) == null;
+    }
+
+    public boolean isEnemy(final Position position, final Piece piece) {
+        return !isEmptyPosition(position) && (mapView.get(position).getColor() != piece.getColor());
+    }
+
+    public Map<Position, Piece> getMapView() {
+        return mapView;
+    }
+
+    public Piece move(final Position startPosition, final Position endPosition) {
+        validateStartPosition(startPosition);
+        validateEndPosition(startPosition, endPosition);
+        final Piece startPiece = mapView.remove(startPosition);
+        final Piece endPiece = mapView.get(endPosition);
+        mapView.put(endPosition, startPiece.copyOf(endPosition));
+        return endPiece;
+    }
+
+    private void validateStartPosition(final Position position) {
+        if (mapView.get(position) == null) {
+            throw new IllegalArgumentException("해당 위치에는 기물이 없습니다.");
+        }
+    }
+
+    private void validateEndPosition(final Position startPosition, final Position endPosition) {
+        final Piece startPiece = mapView.get(startPosition);
+        if (!startPiece.calculateAvailablePositions(this).contains(endPosition)) {
+            throw new IllegalArgumentException("해당 위치로는 이용할 수 없습니다.");
+        }
+    }
+}