[1, 2단계 - 체스] 망고(고재철) 미션 제출합니다.

src/docs/READMD.md

@@ -0,0 +1,138 @@
+
+## 클래스 다이어그램
+
+### 주요 클래스 구조
+
+```mermaid
+classDiagram
+  class ChessBoard {
+    -List~Piece~ pieces
+  }
+
+  class Piece
+  <<Abstract>> Piece
+
+  class Color
+  <<Enumeration>> Color
+
+  class Direction
+  <<Enumeration>> Direction
+
+  ChessController ..> ChessBoard
+  ChessController ..> ChessState
+
+  ChessBoard --> Piece
+  ChessBoard ..> PiecePosition
+  ChessBoard ..> WayPoints
+  ChessBoard ..> Turn
+
+  Piece --> Color
+  Piece --> PiecePosition
+  Piece ..> Path
+는
+
+  Path --> PiecePosition
+  WayPoints --> PiecePosition
+
+  PiecePosition --> Rank
+  PiecePosition --> File
+  PiecePosition ..> Direction
+```
+
+### Piece 추상 클래스
+```mermaid
+classDiagram
+  class Piece
+  <<Abstract>> Piece
+
+  Piece <|-- King
+  Piece <|-- Queen
+  Piece <|-- Bishop
+  Piece <|-- Rook
+  Piece <|-- Knight
+  Piece <|-- Pawn
+```
+
+### 상태 패턴
+```mermaid
+classDiagram
+  class ChessState
+  <<Interface>> ChessState
+
+  class AbstractChessState
+  <<Abstract>> AbstractChessState
+
+  ChessState ..> Command
+  ChessState <|.. AbstractChessState
+  AbstractChessState <|-- Initialize
+  AbstractChessState <|-- Running
+  AbstractChessState <|-- End
+  Command --> Type
+```
+
+---
+
+## 1단계 기능 요구 사항
+
+- [x] 게임 시작 메세지 출력
+- [x] 커맨드 입력 메세지 출력
+- [x] 커맨드 입력 기능
+- [x] 체스판 출력
+- [x] 체스판 만드는 기능
+
+### 기물
+
+- [x] 위치를 갖는다.
+- [x] 종류는 킹, 퀸, 룩, 나이트, 비숍, 폰 이 있다.
+
+### 체스 판
+
+- [x] 가로는 Rank 이다.
+- [x] 세로는 File 이다.
+- [x] 8 X 8 이다.
+
+---
+
+## 2단계 기능 요구 사항
+
+- [x] 게임 시작 및 커맨드 메세지 출력
+- [x] 이동 커맨드 입력 기능 추가
+- [x] White, Black 턴 반복 기능 추가
+- [x] start, move, end 커맨드에 대한 로직 구현
+
+### 기물 이동
+
+- 공통
+  - [x] 도착지에 아군 기물이 있을 경우, 이동 불가능
+  - [x] 도착지에 상대 기물이 있을 경우, 이동 후 상대 기물 제거(Pawn 예외)
+  - [x] 도착지까지 가는 경로에 기물이 있을 경우, 이동 불가능(Knight 예외)
+  - [x] 상대 말 이동 불가능
+- King
+  - [x] 주변 한 칸만 이동 가능
+- Queen
+  - [x] 직선 거리 or 대각선 거리로 이동 가능
+- Bishop
+  - [x] 대각선 거리로 이동 가능
+- Rook
+  - [x] 직선 거리로 이동 가능
+- Knight
+  - [x] 앞으로 두 칸 -> 옆으로 한 칸 이동 가능 (8개)
+- Pawn
+  - [x] 첫 이동인 경우, 앞으로 두 칸까지 이동 가능
+  - [x] 첫 이동이 아닌 경우, 앞으로 한 칸만 이동 가능
+  - [x] 앞에 상대 기물이 있는 경우, 이동 불가능
+  - [x] 대각선 위치에 상대 기물이 있는 경우, 이동 후 상대 기물 제거 가능
+
+---
+
+## 1, 2단계 리팩토링 요구 사항
+
+- [x] `createExclusivePawn` 메서드 명 변경
+- [x] 생성자에서 방어적 복사 하도록 변경
+- [x] `PiecePosition`에서 File, Rank 순서 변경
+- [x] 상태가 기물을 직접 움직이지 않도록 변경
+- [x] 정적 팩토리 메서드와 생성자 사이에 기준 정하기
+- [x] 부정 연산자 사용하지 않도록 수정
+- [x] `incorrect` 메서드 명 변경 및 메서드 순서 변경
+- [x] 한 줄에 점 하나만 찍도록 수정
+- [x] getter 사용 지양하기

src/main/java/chess/ChessApplication.java

@@ -0,0 +1,9 @@
+package chess;
+
+import chess.controller.ChessController;
+
+public class ChessApplication {
+    public static void main(String[] args) {
+        new ChessController().start();
+    }
+}

src/main/java/chess/controller/ChessController.java

@@ -0,0 +1,54 @@
+package chess.controller;
+
+import chess.domain.board.ChessBoard;
+import chess.domain.board.ChessBoardFactory;
+import chess.domain.piece.position.PiecePosition;
+import chess.domain.state.ChessState;
+import chess.domain.state.Initialize;
+import chess.domain.state.command.Command;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+import java.util.ArrayList;
+
+public class ChessController {
+
+    public void start() {
+        OutputView.printStartMessage();
+        final ChessBoard chessBoard = ChessBoardFactory.create();
+        final ChessState state = new Initialize();
+        run(chessBoard, state);
+    }
+
+    private void run(final ChessBoard chessBoard, ChessState state) {
+        while (state.isRunnable()) {
+            state = chessState(chessBoard, state);
+        }
+    }
+
+    private ChessState chessState(final ChessBoard chessBoard, ChessState state) {
+        try {
+            final Command command = Command.parse(new ArrayList<>(InputView.readCommand()));
+            state = changeState(chessBoard, command, state);
+            OutputView.showBoard(chessBoard.pieces());
+        } catch (Exception e) {
+            System.out.println("[ERROR] " + e.getMessage());
+        }
+        return state;
+    }
+
+    private ChessState changeState(final ChessBoard chessBoard, final Command command, ChessState state) {
+        state = state.changeStateByCommand(command);
+        if (command.isMove()) {
+            state = movePiece(chessBoard, command, state);
+        }
+        return state;
+    }
+
+    private ChessState movePiece(final ChessBoard chessBoard, final Command command, ChessState state) {
+        final PiecePosition from = PiecePosition.of(command.getFromParameter());
+        final PiecePosition to = PiecePosition.of(command.getToParameter());
+        chessBoard.movePiece(state, from, to);
+        return state.changeTurn();
+    }
+}

src/main/java/chess/domain/board/ChessBoard.java

@@ -0,0 +1,67 @@
+package chess.domain.board;
+
+import chess.domain.piece.Piece;
+import chess.domain.piece.position.PiecePosition;
+import chess.domain.piece.position.WayPoints;
+
+import chess.domain.state.ChessState;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ChessBoard {
+
+    private final List<Piece> pieces;
+
+    public ChessBoard(final List<Piece> pieces) {
+        this.pieces = new ArrayList<>(pieces);
+    }
+
+    public void movePiece(final ChessState state, final PiecePosition source, final PiecePosition destination) {
+        final Piece from = get(source);
+        validateCorrectTurn(state, from);
+        validateNonBlock(destination, from);
+        moveOrKill(destination, from);
+    }
+
+    private void validateCorrectTurn(final ChessState state, final Piece from) {
+        if (state.isInCorrectTurn(from.color())) {
+            throw new IllegalArgumentException("상대 말 선택하셨습니다.");
+        }
+    }
+
+    private void validateNonBlock(final PiecePosition destination, final Piece from) {
+        final WayPoints wayPoints = from.wayPointsWithCondition(destination);
+        if (wayPoints.isBlocking(pieces)) {
+            throw new IllegalArgumentException("경로 상에 말이 있어서 이동할 수 없습니다.");
+        }
+    }
+
+    private void moveOrKill(final PiecePosition destination, final Piece from) {
+        if (existByPosition(destination)) {
+            final Piece to = get(destination);
+            from.moveAndKill(to);
+            pieces.remove(to);
+            return;
+        }
+        from.move(destination);
+    }
+
+    private boolean existByPosition(final PiecePosition piecePosition) {
+        return pieces.stream()
+                .anyMatch(piece -> piece.existIn(piecePosition));
+    }
+
+    public Piece get(final PiecePosition piecePosition) {
+        return pieces.stream()
+                .filter(piece -> piece.existIn(piecePosition))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("해당 위치에 존재하는 피스가 없습니다."));
+    }
+
+    public List<Piece> pieces() {
+        return pieces.stream()
+                .map(Piece::clone)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/chess/domain/board/ChessBoardFactory.java

@@ -0,0 +1,51 @@
+package chess.domain.board;
+
+import chess.domain.piece.Color;
+import chess.domain.piece.Piece;
+import chess.domain.piece.position.File;
+import chess.domain.piece.position.PiecePosition;
+import chess.domain.piece.type.Bishop;
+import chess.domain.piece.type.King;
+import chess.domain.piece.type.Knight;
+import chess.domain.piece.type.Pawn;
+import chess.domain.piece.type.Queen;
+import chess.domain.piece.type.Rook;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ChessBoardFactory {
+
+    private static final List<Piece> pieces = new ArrayList<>();
+
+    static {
+        createPieceExcludingPawn(1, Color.WHITE);
+        createPieceExcludingPawn(8, Color.BLACK);
+        createPawns(2, Color.WHITE);
+        createPawns(7, Color.BLACK);
+    }
+
+    private static void createPawns(final int rank, final Color color) {
+        for (char file = File.MIN; file <= File.MAX; file++) {
+            pieces.add(new Pawn(color, PiecePosition.of(file, rank)));
+        }
+    }
+
+    private static void createPieceExcludingPawn(final int rank, final Color color) {
+        pieces.add(new Rook(color, PiecePosition.of('a', rank)));
+        pieces.add(new Knight(color, PiecePosition.of('b', rank)));
+        pieces.add(new Bishop(color, PiecePosition.of('c', rank)));
+        pieces.add(new Queen(color, PiecePosition.of('d', rank)));
+        pieces.add(new King(color, PiecePosition.of('e', rank)));
+        pieces.add(new Bishop(color, PiecePosition.of('f', rank)));
+        pieces.add(new Knight(color, PiecePosition.of('g', rank)));
+        pieces.add(new Rook(color, PiecePosition.of('h', rank)));
+    }
+
+    public static ChessBoard create() {
+        return new ChessBoard(pieces.stream()
+                .map(Piece::clone)
+                .collect(Collectors.toList()));
+    }
+}

src/main/java/chess/domain/board/Turn.java

@@ -0,0 +1,40 @@
+package chess.domain.board;
+
+import chess.domain.piece.Color;
+
+import java.util.Objects;
+
+public class Turn {
+    private static final Turn whiteTurn = new Turn(Color.WHITE);
+    private static final Turn blackTurn = new Turn(Color.BLACK);
+
+    private final Color turn;
+
+    public Turn(final Color turn) {
+        this.turn = turn;
+    }
+
+    public Turn change() {
+        if (equals(whiteTurn)) {
+            return blackTurn;
+        }
+        return whiteTurn;
+    }
+
+    public boolean isIncorrect(final Color color) {
+        return turn != color;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Turn)) return false;
+        final Turn turn1 = (Turn) o;
+        return turn == turn1.turn;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(turn);
+    }
+}

src/main/java/chess/domain/piece/Color.java

@@ -0,0 +1,6 @@
+package chess.domain.piece;
+
+public enum Color {
+    WHITE,
+    BLACK;
+}