[4단계 - 체스] 미아(이종미) 미션 제출합니다.

.gitignore

@@ -30,3 +30,7 @@ out/
 
 ### VS Code ###
 .vscode/
+
+## 설정 파일 ##
+/src/main/resources
+/src/test/resources

README.md

@@ -1,5 +1,20 @@
 # java-chess
 
+## 게임 실행 방법
+- 도커를 실행한 후 어플리케이션을 실행한다.
+```
+docker-compose -p chess up -d
+```
+- 도커를 종료한다.
+```
+docker-compose -p chess down
+```
+
+## DB 스키마 다이어그램
+<div align = "center">
+  <img width="496" alt="스크린샷 2024-04-02 오후 2 35 45" src="https://github.com/jongmee/java-chess/assets/101439796/369730ad-ed12-4101-8bc4-b20eac01869a">
+</div>
+
 ## 규칙 정리
 
 - Rank: 체스판의 가로 줄 (1 ~ 8)
@@ -19,10 +34,10 @@
 
 #### 입력
 
-- [게임 준비] 시작/종료 명령어를 입력한다.
-  - start/end가 아니면 예외가 발생한다.
-- [게임 중] move, 종료, 점수 출력 명령어를 입력한다.
-  - 각각 `move (source위치) (target위치)`, `end`, `status` 형식이 아니면 예외가 발생한다.
+- [게임 준비] 시작/종료/게임로그 출력 명령어를 입력한다.
+  - start/end/logs가 아니면 예외가 발생한다.
+- [게임 중] move, 종료, 합의 무승부, 점수 출력 명령어를 입력한다.
+  - 각각 `move (source위치) (target위치)`, `end`, `tie`, `status` 형식이 아니면 예외가 발생한다.
 
 #### 출력
 
@@ -32,9 +47,12 @@
 
 - 현재 차례의 남아 있는 기물들의 점수 합을 출력한다.
 
+- 종료된 체스 게임 결과을 최신순 대로 출력한다.
+
 ### 비즈니스 기능
 
 - **[Prepare]** 체스판을 초기화한다.
+    - 이전에 승부가 나지 않은 체스가 있다면 체스판을 새로 생성하지 않고 이전 체스판을 불러온다.
     - 체스판은 8x8로 이루어져 있다.
     - 체스판에서 말의 위치 값은 가로 위치는 왼쪽부터 `a ~ h`이고, 세로는 아래부터 위로 `1 ~ 8`이다.
     - 각 진영은 검은색(대문자)과 흰색(소문자) 편으로 구분한다.
@@ -87,7 +105,7 @@
       - 자기 자신을 기준으로 상하좌우 대각선으로 움직인다.
       - 1칸씩 움직일 수 있다.
 
-- **[Run]** 현재 남아 있는 기물에 대한 점수를 구할 수 있다.
+- **[Status]** 현재 남아 있는 기물에 대한 점수를 구할 수 있다.
   - Queen: 9점
   - Rook: 5점
   - Bishop: 3점
@@ -96,3 +114,10 @@
   - Pawn: 1점 (세로줄에 같은 진영의 Pawn은 각 0.5점)
 
 - **[End]** 한 진영의 King이 잡히면 게임이 종료된다.
+  - 게임이 종료되기 전, 승패가 저장된다.
+
+- **[Tie]** 플레이어가 서로 합의하여 무승부가 될 수 있다.
+  - 두 플레이어의 King이 모두 체스 보드에 있는 상황에서 합의하여 무승부가 될 수 있다.
+
+- **[Logs]** 이전 게임 결과들을 조회할 수 있다.
+  - 최신 순대로 게임 시작 시간과 결과를 조회한다.

build.gradle

@@ -13,6 +13,7 @@ dependencies {
     testImplementation platform('org.assertj:assertj-bom:3.25.1')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+    runtimeOnly("com.mysql:mysql-connector-j:8.3.0")
 }
 
 java {

docker/db/mysql/init/ddl_prod.sql

@@ -0,0 +1,26 @@
+GRANT ALL PRIVILEGES ON *.* TO 'user'@'%';
+FLUSH PRIVILEGES;
+
+CREATE DATABASE IF NOT EXISTS `chess` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
+
+USE chess;
+
+CREATE TABLE chess_board
+(
+    id          BIGINT      NOT NULL AUTO_INCREMENT,
+    created_at  TIMESTAMP   NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    game_result VARCHAR(15) NOT NULL,
+    turn        VARCHAR(10) NOT NULL,
+    PRIMARY KEY (id)
+);
+
+CREATE TABLE piece
+(
+    file           VARCHAR(10) NOT NULL,
+    `rank`         INT         NOT NULL,
+    type           VARCHAR(10) NOT NULL,
+    chess_board_id BIGINT      NOT NULL,
+    side           VARCHAR(10) NOT NULL,
+    FOREIGN KEY (`chess_board_id`) REFERENCES `chess_board` (`id`),
+    PRIMARY KEY (file, `rank`, chess_board_id)
+);

docker/db/mysql/init/ddl_test.sql

@@ -0,0 +1,23 @@
+CREATE DATABASE IF NOT EXISTS `chess_test` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
+
+USE chess_test;
+
+CREATE TABLE chess_board
+(
+    id          BIGINT      NOT NULL AUTO_INCREMENT,
+    created_at  TIMESTAMP   NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    game_result VARCHAR(15) NOT NULL,
+    turn        VARCHAR(10) NOT NULL,
+    PRIMARY KEY (id)
+);
+
+CREATE TABLE piece
+(
+    file           VARCHAR(10) NOT NULL,
+    `rank`         INT         NOT NULL,
+    type           VARCHAR(10) NOT NULL,
+    chess_board_id BIGINT      NOT NULL,
+    side           VARCHAR(10) NOT NULL,
+    FOREIGN KEY (`chess_board_id`) REFERENCES `chess_board` (`id`),
+    PRIMARY KEY (file, `rank`, chess_board_id)
+);

docker/docker-compose.yml

@@ -0,0 +1,15 @@
+version: "3.9"
+services:
+  db:
+    image: mysql:8.0.28
+    platform: linux/x86_64
+    restart: always
+    ports:
+      - "13306:3306"
+    environment:
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+      TZ: Asia/Seoul
+    volumes:
+      - ./db/mysql/init:/docker-entrypoint-initdb.d

src/main/java/chess/Application.java

@@ -1,14 +1,10 @@
 package chess;
 
 import chess.controller.ChessGame;
-import chess.view.input.InputView;
-import chess.view.output.OutputView;
 
 public class Application {
     public static void main(String[] args) {
-        InputView inputView = new InputView();
-        OutputView outputView = new OutputView();
-        ChessGame chessGame = new ChessGame(inputView, outputView);
+        ChessGame chessGame = new ChessGame();
         chessGame.start();
     }
 }

src/main/java/chess/controller/ChessGame.java

@@ -1,31 +1,29 @@
 package chess.controller;
 
+import chess.dao.util.ProductMySqlConnector;
+import chess.service.ChessGameService;
 import chess.view.input.InputView;
 import chess.view.output.OutputView;
 
 import java.util.Objects;
 import java.util.function.Supplier;
 
 public class ChessGame {
-    private final InputView inputView;
-    private final OutputView outputView;
-
-    public ChessGame(InputView inputView, OutputView outputView) {
-        this.inputView = inputView;
-        this.outputView = outputView;
-    }
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+    private final ChessGameService chessGameService = new ChessGameService(new ProductMySqlConnector());
 
     public void start() {
         GameState gameState = retryOnException(this::prepare);
         while (gameState.canContinue()) {
             GameState currentGameState = gameState;
-            gameState = retryOnException(() -> currentGameState.run(inputView, outputView));
+            gameState = retryOnException(() -> currentGameState.run(inputView, outputView, chessGameService));
         }
     }
 
     private GameState prepare() {
         GameState prepare = new Prepare();
-        return prepare.run(inputView, outputView);
+        return prepare.run(inputView, outputView, chessGameService);
     }
 
     private <T> T retryOnException(Supplier<T> retryOperation) {

src/main/java/chess/controller/End.java

@@ -1,12 +1,13 @@
 package chess.controller;
 
+import chess.service.ChessGameService;
 import chess.view.input.InputView;
 import chess.view.output.OutputView;
 
 public class End implements GameState {
 
     @Override
-    public GameState run(InputView inputView, OutputView outputView) {
+    public GameState run(InputView inputView, OutputView outputView, ChessGameService chessGameService) {
         throw new UnsupportedOperationException("게임이 종료되어 게임을 실행할 수 없습니다.");
     }
 

src/main/java/chess/controller/GameState.java

@@ -1,9 +1,10 @@
 package chess.controller;
 
+import chess.service.ChessGameService;
 import chess.view.input.InputView;
 import chess.view.output.OutputView;
 
 public interface GameState {
-    GameState run(InputView inputView, OutputView outputView);
+    GameState run(InputView inputView, OutputView outputView, ChessGameService chessGameService);
     boolean canContinue();
 }

src/main/java/chess/controller/Move.java

@@ -0,0 +1,33 @@
+package chess.controller;
+
+import chess.model.board.ChessBoard;
+import chess.model.board.Turn;
+import chess.service.ChessGameService;
+import chess.view.input.InputView;
+import chess.view.input.MoveArguments;
+import chess.view.output.OutputView;
+
+public class Move implements GameState {
+    private final ChessBoard chessBoard;
+    private final Turn turn;
+    private final MoveArguments moveArguments;
+
+    public Move(ChessBoard chessBoard, Turn turn, MoveArguments moveArguments) {
+        this.chessBoard = chessBoard;
+        this.turn = turn;
+        this.moveArguments = moveArguments;
+    }
+
+    @Override
+    public GameState run(InputView inputView, OutputView outputView, ChessGameService chessGameService) {
+        chessGameService.move(chessBoard, turn, moveArguments);
+        outputView.printChessBoard(chessBoard);
+        Turn nextTurn = chessGameService.saveNextTurn(chessBoard, turn);
+        return new Run(chessBoard, nextTurn);
+    }
+
+    @Override
+    public boolean canContinue() {
+        return true;
+    }
+}

src/main/java/chess/controller/Prepare.java

@@ -1,33 +1,41 @@
 package chess.controller;
 
-import chess.model.board.ChessBoard;
-import chess.model.board.ChessBoardGenerator;
-import chess.model.board.ChessBoardInitializer;
-import chess.model.board.Turn;
-import chess.model.piece.Side;
+import chess.dao.dto.GameResultDto;
+import chess.dao.dto.LatestChessBoardDto;
+import chess.service.ChessGameService;
 import chess.view.input.GameCommand;
 import chess.view.input.InputView;
 import chess.view.output.OutputView;
 
+import java.util.List;
+
 public class Prepare implements GameState {
 
     @Override
-    public GameState run(InputView inputView, OutputView outputView) {
+    public GameState run(InputView inputView, OutputView outputView, ChessGameService chessGameService) {
         GameCommand gameCommand = getFirstGameCommand(inputView);
         if (gameCommand.isEnd()) {
             return new End();
         }
-        ChessBoardGenerator chessBoardInitializer = new ChessBoardInitializer();
-        ChessBoard chessBoard = new ChessBoard(chessBoardInitializer.create());
-        outputView.printChessBoard(chessBoard);
-        return Run.initializeWithFirstTurn(chessBoard);
+        if (gameCommand.isLogs()) {
+            showGameResults(outputView, chessGameService);
+            return new End();
+        }
+        LatestChessBoardDto latestChessBoardDto = chessGameService.createOrGetInitialChessBoard();
+        outputView.printChessBoard(latestChessBoardDto.chessBoard());
+        return new Run(latestChessBoardDto.chessBoard(), latestChessBoardDto.turn());
     }
 
     private GameCommand getFirstGameCommand(InputView inputView) {
         String gameCommandInput = inputView.readGameCommand();
         return GameCommand.createInPreparation(gameCommandInput);
     }
 
+    private void showGameResults(OutputView outputView, ChessGameService chessGameService) {
+        List<GameResultDto> gameResults = chessGameService.findAllGameResults();
+        outputView.printGameResults(gameResults);
+    }
+
     @Override
     public boolean canContinue() {
         return true;

src/main/java/chess/controller/Run.java

@@ -1,14 +1,12 @@
 package chess.controller;
 
 import chess.model.board.ChessBoard;
-import chess.model.evaluation.PositionEvaluation;
 import chess.model.board.Turn;
-import chess.model.piece.Side;
-import chess.model.position.Position;
+import chess.model.evaluation.PositionEvaluation;
+import chess.service.ChessGameService;
 import chess.view.input.GameArguments;
 import chess.view.input.GameCommand;
 import chess.view.input.InputView;
-import chess.view.input.MoveArguments;
 import chess.view.output.OutputView;
 
 public class Run implements GameState {
@@ -20,39 +18,37 @@ public Run(ChessBoard chessBoard, Turn turn) {
         this.turn = turn;
     }
 
-    public static Run initializeWithFirstTurn(ChessBoard chessBoard) {
-        return new Run(chessBoard, Turn.from(Side.WHITE));
-    }
-
     @Override
-    public GameState run(InputView inputView, OutputView outputView) {
+    public GameState run(InputView inputView, OutputView outputView, ChessGameService chessGameService) {
+        if (chessBoard.canNotProgress()) {
+            return new Summarize(chessBoard);
+        }
         GameArguments gameArguments = inputView.readMoveArguments();
+        return playByCommand(gameArguments, outputView);
+    }
+
+    private GameState playByCommand(GameArguments gameArguments, OutputView outputView) {
         GameCommand gameCommand = gameArguments.gameCommand();
         if (gameCommand.isEnd()) {
             return new End();
         }
+        if (gameCommand.isTie()) {
+            return new Summarize(chessBoard);
+        }
         if (gameCommand.isMove()) {
-            move(gameArguments.moveArguments(), outputView);
-            return new Run(chessBoard, turn.getNextTurn());
+            return new Move(chessBoard, turn, gameArguments.moveArguments());
         }
         evaluateCurrentBoard(outputView);
         return this;
     }
 
-    private void move(MoveArguments moveArguments, OutputView outputView) {
-        Position source = moveArguments.createSourcePosition();
-        Position target = moveArguments.createTargetPosition();
-        chessBoard.move(source, target, turn);
-        outputView.printChessBoard(chessBoard);
-    }
-
     private void evaluateCurrentBoard(OutputView outputView) {
         PositionEvaluation positionEvaluation = chessBoard.evaluateCurrentBoard();
         outputView.printPositionEvaluation(positionEvaluation);
     }
 
     @Override
     public boolean canContinue() {
-        return chessBoard.canContinue();
+        return true;
     }
 }