다즐의 체스 게임

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,82 @@
+## 도메인 객체 그래프
+
+```mermaid
+graph TD
+    ChessController --> InputView
+    ChessController --> OutputView
+
+    ChessController --> ChessGame
+    ChessGame --> Board
+
+    Square --> File
+    Square --> Rank
+
+    Board --> Square
+    Board --> PIECE
+
+    PIECE --> Color
+
+    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] 체스판을 출력한다.

src/main/java/chess/ChessApplication.java

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

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

@@ -0,0 +1,54 @@
+package chess.controller;
+
+import static chess.controller.ChessStartCommand.START;
+
+import chess.controller.dto.ChessBoardDto;
+import chess.domain.ChessGame;
+import chess.view.InputView;
+import chess.view.OutputView;
+
+public class ChessController {
+
+    private static final InputView inputView = new InputView();
+    private static final OutputView outputView = new OutputView();
+
+    private final ChessGame chessGame = new ChessGame();
+
+    public void run() {
+        outputView.printStartMessage();
+        if (readChessStartCommand() == START) {
+            outputView.printChessBoard(ChessBoardDto.from(chessGame));
+            playChessGame();
+        }
+    }
+
+    private ChessStartCommand readChessStartCommand() {
+        while (true) {
+            try {
+                return ChessStartCommand.from(inputView.readChessExecuteCommand());
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private void playChessGame() {
+        while (true) {
+            try {
+                repeatMove();
+                return;
+            } catch (IllegalArgumentException e) {
+                outputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private void repeatMove() {
+        ChessGameCommand chessGameCommand = ChessGameCommand.from(inputView.readChessGameCommand());
+        while (chessGameCommand.getChessExecuteCommand() == ChessExecuteCommand.MOVE) {
+            chessGame.move(chessGameCommand.getSource(), chessGameCommand.getDestination());
+            outputView.printChessBoard(ChessBoardDto.from(chessGame));
+            chessGameCommand = ChessGameCommand.from(inputView.readChessGameCommand());
+        }
+    }
+}

src/main/java/chess/controller/ChessExecuteCommand.java

@@ -0,0 +1,29 @@
+package chess.controller;
+
+import static java.lang.String.format;
+
+import java.util.Arrays;
+
+public enum ChessExecuteCommand {
+
+    MOVE("move"),
+    STOP("end");
+
+    private final String input;
+
+    ChessExecuteCommand(final String input) {
+        this.input = input;
+    }
+
+    @Override
+    public String toString() {
+        return input;
+    }
+
+    public static ChessExecuteCommand from(final String input) {
+        return Arrays.stream(ChessExecuteCommand.values())
+                .filter(chessExecuteCommand -> chessExecuteCommand.input.equals(input))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(format("%s나 %s 중 입력해야 합니다.", MOVE, STOP)));
+    }
+}

src/main/java/chess/controller/ChessGameCommand.java

@@ -0,0 +1,84 @@
+package chess.controller;
+
+import chess.domain.board.Square;
+import java.util.List;
+
+public class ChessGameCommand {
+
+    private final ChessExecuteCommand chessExecuteCommand;
+    private final Square source;
+    private final Square destination;
+
+    private ChessGameCommand(final ChessExecuteCommand chessExecuteCommand) {
+        this(chessExecuteCommand, null, null);
+    }
+
+    private ChessGameCommand(
+            final ChessExecuteCommand chessExecuteCommand,
+            final Square source,
+            final Square destination
+    ) {
+        this.chessExecuteCommand = chessExecuteCommand;
+        this.source = source;
+        this.destination = destination;
+    }
+
+    public static ChessGameCommand initMove() {
+        return new ChessGameCommand(ChessExecuteCommand.MOVE);
+    }
+
+    public static ChessGameCommand from(final List<String> inputs) {
+        validateEmpty(inputs);
+        final ChessExecuteCommand chessExecuteCommand = ChessExecuteCommand.from(inputs.get(0));
+        if (chessExecuteCommand == ChessExecuteCommand.STOP) {
+            return getEndCommand(inputs, chessExecuteCommand);
+        }
+        return getMoveCommand(inputs, chessExecuteCommand);
+    }
+
+    private static void validateEmpty(final List<String> inputs) {
+        if (inputs.isEmpty()) {
+            throw new IllegalArgumentException("move랑 end 중 입력하세요.");
+        }
+    }
+
+    private static ChessGameCommand getEndCommand(
+            final List<String> inputs,
+            final ChessExecuteCommand chessExecuteCommand
+    ) {
+        validateEnd(inputs);
+        return new ChessGameCommand(chessExecuteCommand);
+    }
+
+    private static void validateEnd(final List<String> inputs) {
+        if (inputs.size() != 1) {
+            throw new IllegalArgumentException("end만 입력해야 합니다.");
+        }
+    }
+
+    private static ChessGameCommand getMoveCommand(
+            final List<String> inputs,
+            final ChessExecuteCommand chessExecuteCommand
+    ) {
+        validateMove(inputs);
+        return new ChessGameCommand(chessExecuteCommand, Square.from(inputs.get(1)), Square.from(inputs.get(2)));
+    }
+
+    private static void validateMove(final List<String> inputs) {
+        if (inputs.size() != 3) {
+            throw new IllegalArgumentException("(예. move b2 b3)와 같이 입력해야 합니다.");
+        }
+    }
+
+    public ChessExecuteCommand getChessExecuteCommand() {
+        return chessExecuteCommand;
+    }
+
+    public Square getSource() {
+        return source;
+    }
+
+    public Square getDestination() {
+        return destination;
+    }
+}

src/main/java/chess/controller/ChessStartCommand.java

@@ -0,0 +1,29 @@
+package chess.controller;
+
+import static java.lang.String.format;
+
+import java.util.Arrays;
+
+public enum ChessStartCommand {
+
+    START("start"),
+    END("end");
+
+    private final String input;
+
+    ChessStartCommand(final String input) {
+        this.input = input;
+    }
+
+    @Override
+    public String toString() {
+        return input;
+    }
+
+    public static ChessStartCommand from(final String input) {
+        return Arrays.stream(ChessStartCommand.values())
+                .filter(chessStartCommand -> chessStartCommand.input.equals(input))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(format("%s나 %s 중 입력해야 합니다.", START, END)));
+    }
+}