다즐의 체스 게임

build.gradle

@@ -9,9 +9,6 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.sparkjava:spark-core:2.9.3'
-    implementation 'com.sparkjava:spark-template-handlebars:2.7.1'
-    implementation 'ch.qos.logback:logback-classic:1.2.10'
     testImplementation 'org.assertj:assertj-core:3.22.0'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
 }

src/docs/README.md

@@ -0,0 +1,93 @@
+## 도메인 객체 그래프
+
+```mermaid
+graph TD
+  ChessController --> InputView
+  ChessController --> OutputView
+  ChessController --> ExecuteState
+
+  ChessController --> ChessGame
+  ChessGame --> Board
+
+  Square --> File
+  Square --> Rank
+
+  BoardFactory --> Board
+
+  Board --> Square
+  Board --> PIECE
+
+  PIECE --> Color
+  PIECE --> Strategy
+
+  subgraph PIECE
+    direction BT
+    Pawn -.-> Piece
+    Rook -.-> Piece
+    Bishop -.-> Piece
+    Knight -.-> Piece
+    Queen -.-> Piece
+    King -.-> Piece
+  end
+```
+
+## 구현 기능 목록
+
+### 체스 게임
+
+- [x] 기물을 이동시킨다.
+
+### 체스 보드
+
+- [x] 체스 기물 위치를 알고 있다.
+- [x] 특정 칸에 존재하는 기물을 확인한다.
+- [x] 이동 경로로 이동할 수 있는지 확인한다.
+- [x] 폰이 이동 경로로 이동할 수 있는지 확인한다.
+- [x] 기물 위치를 업데이트한다.
+
+### 체스 칸
+
+- 세로줄 (File)
+    - [x] 왼쪽부터 a ~ h이다.
+    - [x] [예외사항] 존재하지 않는 인덱스라면 예외를 던진다.
+    - [x] 파일 간 거리를 계산한다.
+    - [x] 다음 파일을 반환한다.
+    - [x] 이전 파일을 반환한다.
+- 가로줄 (Rank)
+    - [x] 아래부터 1 ~ 8이다.
+    - [x] [예외사항] 존재하지 않는 인덱스라면 예외를 던진다.
+    - [x] 랭크 간 거리를 계산한다.
+    - [x] 다음 랭크를 반환한다.
+    - [x] 이전 랭크를 반환한다.
+
+### 체스 기물
+
+- 여러 가지 기물이 존재한다.
+    - 폰
+    - 룩
+    - 나이트
+    - 비숍
+    - 퀸
+    - 킹
+- 색을 가진다.
+    - [x] 흑과 백이 존재한다.
+    - [x] 검은색인지 확인한다.
+    - [x] 같은 색인지 확인한다.
+- [x] 움직이는 경로를 반환한다.
+- [x] 폰인지 확인한다.
+
+### 방향 벡터
+
+- [x] 움직이려는 방향으로 갈 수 있는지 확인한다.
+- [x] 방향의 다음 파일을 반환한다.
+- [x] 방향의 다음 랭크를 반환한다.
+
+### 입력
+
+- [x] 게임 실행 명령을 입력한다.
+
+### 출력
+
+- [x] 게임 시작 문구를 출력한다.
+- [x] 체스판을 출력한다.
+- [x] 에러 메시지를 출력한다.

src/main/java/chess/ChessApplication.java

@@ -0,0 +1,14 @@
+package chess;
+
+import chess.controller.ChessController;
+import chess.domain.ChessGame;
+import chess.domain.board.BoardFactory;
+
+public class ChessApplication {
+    public static void main(String[] args) {
+        final ChessController chessController = new ChessController(
+                new ChessGame(BoardFactory.create())
+        );
+        chessController.run();
+    }
+}

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

@@ -0,0 +1,104 @@
+package chess.controller;
+
+import static chess.controller.ExecuteState.END;
+import static chess.controller.ExecuteState.INIT;
+import static chess.controller.ExecuteState.MOVE;
+import static chess.controller.ExecuteState.START;
+
+import chess.domain.ChessGame;
+import chess.domain.board.Square;
+import chess.view.InputView;
+import chess.view.OutputView;
+import chess.view.dto.ChessBoardDto;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+
+public class ChessController {
+
+    private static final InputView inputView = new InputView();
+    private static final OutputView outputView = new OutputView();
+
+    private final ChessGame chessGame;
+    private ExecuteState executeState = INIT;
+    private final Map<ExecuteState, Consumer<List<String>>> actions = Map.of(
+            START, this::start,
+            MOVE, this::move,
+            END, this::end
+    );
+
+    public ChessController(final ChessGame chessGame) {
+        this.chessGame = chessGame;
+    }
+
+    public void run() {
+        outputView.printStartMessage();
+        while (executeState != END) {
+            playChessGame();
+        }
+    }
+
+    private void playChessGame() {
+        try {
+            final List<String> commands = inputView.readExecuteCommands();
+            final ExecuteState executeState = readExecuteState(commands);
+            actions.get(executeState).accept(commands);
+        } catch (IllegalArgumentException e) {
+            outputView.printErrorMessage(e.getMessage());
+        }
+    }
+
+    private ExecuteState readExecuteState(final List<String> commands) {
+        validateCommands(commands);
+        return ExecuteState.from(commands.get(0));
+    }
+
+    private void validateCommands(final List<String> commands) {
+        if (commands.size() == 0) {
+            throw new IllegalArgumentException("게임 실행을 위해서는 명령 입력이 필요합니다.");
+        }
+    }
+
+    private void start(final List<String> commands) {
+        validateForNotMove(commands);
+        validateInit();
+        executeState = START;
+        outputView.printChessBoard(ChessBoardDto.from(chessGame));
+    }
+
+    private void end(final List<String> commands) {
+        validateForNotMove(commands);
+        executeState = END;
+    }
+
+    private void move(final List<String> commands) {
+        validateForMove(commands);
+        validateStart();
+        chessGame.move(Square.from(commands.get(1)), Square.from(commands.get(2)));
+        outputView.printChessBoard(ChessBoardDto.from(chessGame));
+    }
+
+    private static void validateForNotMove(final List<String> commands) {
+        if (commands.size() != 1) {
+            throw new IllegalArgumentException("실행 명령만 정확히 입력이 필요합니다.");
+        }
+    }
+
+    private void validateInit() {
+        if (executeState != INIT) {
+            throw new IllegalArgumentException("게임 시작은 처음 상태일때만 가능합니다.");
+        }
+    }
+
+    private void validateStart() {
+        if (executeState != START) {
+            throw new IllegalArgumentException("게임 진행중일때만 가능합니다.");
+        }
+    }
+
+    private static void validateForMove(final List<String> commands) {
+        if (commands.size() != 3) {
+            throw new IllegalArgumentException("이동을 위해서는 예시와 같이 입력이 필요합니다. 예) move b2 b3");
+        }
+    }
+}

src/main/java/chess/controller/ExecuteState.java

@@ -0,0 +1,20 @@
+package chess.controller;
+
+import java.util.Arrays;
+
+public enum ExecuteState {
+
+    INIT,
+    START,
+    MOVE,
+    END,
+    ;
+
+    public static ExecuteState from(final String input) {
+        return Arrays.stream(ExecuteState.values())
+                .filter(executeState -> executeState != INIT)
+                .filter(executeState -> executeState.name().toLowerCase().equals(input))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 실행 명령입니다."));
+    }
+}

src/main/java/chess/domain/ChessGame.java

@@ -0,0 +1,49 @@
+package chess.domain;
+
+import static java.lang.String.format;
+
+import chess.domain.board.Board;
+import chess.domain.board.Square;
+import chess.domain.piece.Color;
+import chess.domain.piece.Piece;
+import java.util.List;
+
+public class ChessGame {
+
+    private final Board board;
+    private Color turnColor = Color.WHITE;
+
+    public ChessGame(final Board board) {
+        this.board = board;
+    }
+
+    public void move(final Square source, final Square destination) {
+        final Piece piece = board.findPieceOf(source)
+                .orElseThrow(() -> new IllegalArgumentException("움직일 기물이 존재하지 않습니다."));
+        validateTurn(piece);
+        moveToDestination(piece, source, destination);
+        nextTurn();
+    }
+
+    private void validateTurn(final Piece piece) {
+        if (!piece.isSameColor(turnColor)) {
+            throw new IllegalArgumentException(format("%s의 차례입니다.", turnColor));
+        }
+    }
+
+    private void moveToDestination(final Piece piece, final Square source, final Square destination) {
+        final List<Square> route = piece.findRoute(source, destination);
+        if (!piece.isMovable(source, route, board.getBoardSnapShot())) {
+            throw new IllegalArgumentException("움직일 수 없는 위치입니다.");
+        }
+        board.move(source, destination);
+    }
+
+    private void nextTurn() {
+        turnColor = turnColor.reverse();
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+}

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

@@ -0,0 +1,31 @@
+package chess.domain.board;
+
+import chess.domain.piece.Piece;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+
+public class Board {
+
+    private final Map<Square, Piece> board;
+
+    public Board(final Map<Square, Piece> board) {
+        this.board = board;
+    }
+
+    public Optional<Piece> findPieceOf(final Square square) {
+        return Optional.ofNullable(board.get(square));
+    }
+
+    public void move(final Square source, final Square destination) {
+        board.put(destination, board.remove(source));
+    }
+
+    public BoardSnapShot getBoardSnapShot() {
+        return BoardSnapShot.from(board);
+    }
+
+    public Map<Square, Piece> getBoard() {
+        return Collections.unmodifiableMap(board);
+    }
+}