[체스 - 스피드런] 한스(이현수) 제출합니다.

src/main/java/chess/Board.java

@@ -0,0 +1,41 @@
+package chess;
+
+import chess.piece.Piece;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Board {
+    private final List<Piece> pieces = new ArrayList<>();
+
+    public void put(Piece piece) {
+        pieces.add(piece);
+    }
+
+    public boolean existSameTeam(Position position, Color color) {
+        return pieces.stream().anyMatch(piece ->
+                        piece.getPosition().equals(position) &&
+                        piece.getColor() == color);
+    }
+
+    public boolean existPiece(Position position) {
+        return pieces.stream().anyMatch(piece -> piece.getPosition().equals(position));
+    }
+
+    public Piece findPiece(Position position, Color color) {
+        return pieces.stream()
+                .filter(piece -> piece.getPosition().equals(position) && piece.getColor() == color)
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("움직일 수 없는 기물입니다."));
+    }
+
+    public Piece findPiece(Position position) {
+        return pieces.stream()
+                .filter(piece -> piece.getPosition().equals(position))
+                .findFirst()
+                .get();
+    }
+
+    public void removeByPosition(Position position) {
+        pieces.removeIf(piece -> piece.getPosition().equals(position));
+    }
+}

src/main/java/chess/BoardInitializer.java

@@ -0,0 +1,61 @@
+package chess;
+
+import chess.piece.Bishop;
+import chess.piece.King;
+import chess.piece.Knight;
+import chess.piece.Pawn;
+import chess.piece.Queen;
+import chess.piece.Rook;
+import java.util.Arrays;
+
+public class BoardInitializer {
+
+    public Board generateBoard() {
+        Board board = new Board();
+        putPawn(board);
+        putRook(board);
+        putKnight(board);
+        putBishop(board);
+        putQueen(board);
+        putKing(board);
+        return board;
+    }
+
+    private static void putKing(Board board) {
+        board.put(new King(new Position(Row.EIGHT, Column.D), board, Color.BLACK));
+        board.put(new King(new Position(Row.ONE, Column.D), board, Color.WHITE));
+    }
+
+    private static void putQueen(Board board) {
+        board.put(new Queen(new Position(Row.EIGHT, Column.E), board, Color.BLACK));
+        board.put(new Queen(new Position(Row.ONE, Column.E), board, Color.WHITE));
+    }
+
+    private static void putBishop(Board board) {
+        board.put(new Bishop(new Position(Row.EIGHT, Column.C), board, Color.BLACK));
+        board.put(new Bishop(new Position(Row.ONE, Column.C), board, Color.WHITE));
+        board.put(new Bishop(new Position(Row.EIGHT, Column.F), board, Color.BLACK));
+        board.put(new Bishop(new Position(Row.ONE, Column.F), board, Color.WHITE));
+    }
+
+    private static void putKnight(Board board) {
+        board.put(new Knight(new Position(Row.EIGHT, Column.B), board, Color.BLACK));
+        board.put(new Knight(new Position(Row.ONE, Column.B), board, Color.WHITE));
+        board.put(new Knight(new Position(Row.EIGHT, Column.G), board, Color.BLACK));
+        board.put(new Knight(new Position(Row.ONE, Column.G), board, Color.WHITE));
+    }
+
+    private static void putRook(Board board) {
+        board.put(new Rook(new Position(Row.EIGHT, Column.A), board, Color.BLACK));
+        board.put(new Rook(new Position(Row.ONE, Column.A), board, Color.WHITE));
+        board.put(new Rook(new Position(Row.EIGHT, Column.H), board, Color.BLACK));
+        board.put(new Rook(new Position(Row.ONE, Column.H), board, Color.WHITE));
+    }
+
+    private void putPawn(Board board) {
+        Arrays.stream(Column.values()).forEach(column -> {
+            board.put(new Pawn(new Position(Row.SEVEN, column), board, Color.BLACK));
+            board.put(new Pawn(new Position(Row.TWO, column), board, Color.WHITE));
+        });
+    }
+}

src/main/java/chess/ChessApplication.java

@@ -0,0 +1,15 @@
+package chess;
+
+import chess.controller.Controller;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class ChessApplication {
+
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        Controller controller = new Controller(inputView, outputView);
+        controller.run();
+    }
+}

src/main/java/chess/Column.java

@@ -1,15 +1,31 @@
 package chess;
 
+import java.util.Arrays;
+import javax.lang.model.element.NestingKind;
+
 public enum Column {
 
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-    H;
+    A("A"),
+    B("B"),
+    C("C"),
+    D("D"),
+    E("E"),
+    F("F"),
+    G("G"),
+    H("H");
+
+    private final String index;
+
+    Column(String index) {
+        this.index = index;
+    }
+
+    public static Column from(String index) {
+        return Arrays.stream(Column.values())
+                .filter(column -> column.index.equals(index))
+                .findFirst()
+                .get();
+    }
 
     public boolean isFarLeft() {
         return ordinal() == 0;

src/main/java/chess/Movement.java

@@ -45,4 +45,16 @@ public boolean isVertical() {
     public boolean isDiagonal() {
         return x != 0 && y != 0 && Math.abs(x) == Math.abs(y);
     }
+
+    public boolean isStraightOneStep() {
+        return (x == 0 && Math.abs(y) == 1) || (y == 0 && Math.abs(x) == 1);
+    }
+
+    public boolean isCrossOneStep() {
+        return Math.abs(x) + Math.abs(y) == 2 && Math.abs(x) == 1 && Math.abs(y) == 1;
+    }
+
+    public boolean isMoveThreeStep() {
+        return Math.abs(x) + Math.abs(y) == 3;
+    }
 }

src/main/java/chess/Row.java

@@ -1,15 +1,35 @@
 package chess;
 
+import java.lang.module.FindException;
+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 index;
+
+    Row(int index) {
+        this.index = index;
+    }
+
+    public static Row from(int index) {
+        return Arrays.stream(Row.values())
+                .filter(row -> row.index == index)
+                .findFirst()
+                .get();
+    }
+
+    public String getRowName() {
+        return String.valueOf(index);
+    }
 
     public boolean isTop() {
         return ordinal() == 0;

src/main/java/chess/controller/Controller.java

@@ -0,0 +1,61 @@
+package chess.controller;
+
+import chess.Board;
+import chess.BoardInitializer;
+import chess.Color;
+import chess.Column;
+import chess.Position;
+import chess.Row;
+import chess.piece.Piece;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class Controller {
+    private final InputView inputView;
+    private final OutputView outputView;
+    Color turn = Color.BLACK;
+
+    public Controller(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        BoardInitializer boardInitializer = new BoardInitializer();
+        Board board = boardInitializer.generateBoard();
+        retry(() -> processe(board, turn));
+    }
+
+    private void processe(Board board, Color turn) {
+        outputView.printBoard(board);
+        String command = inputView.inputMoveCommand(turn);
+        if (command.equals("Q")) {
+            System.exit(0);
+        }
+        String[] positions = command.split(", ");
+        Position movePiecePosition = parsePosition(positions[0]);
+        Position targetPosition = parsePosition(positions[1]);
+        Piece piece = board.findPiece(movePiecePosition, turn);
+        piece.move(targetPosition);
+        turn = turn.opposite();
+        processe(board, turn);
+    }
+
+    private Position parsePosition(String position) {
+        String[] splited = position.split("");
+        return new Position(
+                Row.from(Integer.parseInt(splited[0])),
+                Column.from(splited[1])
+        );
+    }
+
+    private void retry(Runnable runnable) {
+        try {
+            runnable.run();
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+            retry(runnable);
+        }
+    }
+
+}

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

@@ -1,5 +1,41 @@
 package chess.piece;
 
-public class Bishop {
+import chess.Board;
+import chess.Color;
+import chess.Movement;
+import chess.Position;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
 
+public class Bishop extends Piece {
+
+    public Bishop(Position position, Board board, Color color) {
+        super(position, board, color);
+    }
+
+    @Override
+    protected Set<Position> getMovablePositions() {
+        Set<Position> movablePositions = new HashSet<>();
+        Arrays.stream(Movement.values())
+                .filter(Movement::isCrossOneStep)
+                .forEach(movement -> {
+                    Position currPosition = getPosition();
+                    while(currPosition.canMove(movement)) {
+                        currPosition = currPosition.move(movement);
+                        if (!board.existSameTeam(currPosition, getColor())) {
+                            movablePositions.add(currPosition);
+                        }
+                        if (board.existPiece(currPosition)) {
+                            break;
+                        }
+                    }
+                });
+        return movablePositions;
+    }
+
+    @Override
+    public String toString() {
+        return "BI";
+    }
 }

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

@@ -1,5 +1,38 @@
 package chess.piece;
 
-public class King {
+import chess.Board;
+import chess.Color;
+import chess.Movement;
+import chess.Position;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
 
+public class King extends Piece {
+
+    public King(Position position, Board board, Color color) {
+        super(position, board, color);
+    }
+
+    @Override
+    public Set<Position> getMovablePositions() {
+        return Arrays.stream(Movement.values())
+                .filter(this::isOneStepMovement)
+                .filter(movement -> canMove(movement, getPosition()))
+                .map(getPosition()::move)
+                .collect(Collectors.toSet());
+    }
+
+    private boolean canMove(Movement movement, Position currentPosition) {
+        return currentPosition.canMove(movement) && !board.existSameTeam(currentPosition.move(movement), getColor());
+    }
+
+    private boolean isOneStepMovement(Movement movement) {
+        return movement.isCrossOneStep() || movement.isStraightOneStep();
+    }
+
+    @Override
+    public String toString() {
+        return "KI";
+    }
 }