레디 미션 제출

.gitignore

@@ -30,3 +30,6 @@ out/
 
 ### VS Code ###
 .vscode/
+
+### dockder ###
+docker/

README.md

@@ -2,6 +2,18 @@
 
 체스 미션 저장소
 
+
+### [기능 요구 사항 바로가기](https://github.com/reddevilmidzy/java-chess/blob/62e632aa09435db4f69502e663a0cc7ef78a31bb/docs/README.md)
+
+<br>
+
+### [product db 스키마](https://github.com/reddevilmidzy/java-chess/blob/0f6324e83c0fef95c84bd95c5dba8df742a8b613/src/main/resources0)
+
+<br>
+
+### [test db 스키마](https://github.com/reddevilmidzy/java-chess/blob/0f6324e83c0fef95c84bd95c5dba8df742a8b613/src/test/resources)
+
+
 ## 우아한테크코스 코드리뷰
 
 - [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)

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/docker-compose.yml

@@ -0,0 +1,18 @@
+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_DATABASE: chess
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+      TZ: Asia/Seoul
+    volumes:
+      - ./db/mysql/data:/var/lib/mysql
+      - ./db/mysql/config:/etc/mysql/conf.d
+      - ./db/mysql/init:/docker-entrypoint-initdb.d

docs/README.md

@@ -1,5 +1,48 @@
 # 체스 미션
 
+## DB 연동
+
+### Docker 실행하기
+
+```bash
+docker-compose -p chess up -d
+```
+
+### DB 스키마
+
+```sql
+use chess;
+
+drop table if exists board;
+
+create table board
+(
+    position   varchar(2)  not null,
+    piece_type varchar(6) not null,
+    camp       varchar(5)  not null
+
+);
+
+drop table if exists moving;
+
+create table moving
+(
+  movement_id INT primary key auto_increment,
+  camp        varchar(5)  not null,
+  start       varchar(2) not null,
+  destination varchar(2) not null
+);
+
+drop table if exists turn;
+
+create table turn
+(
+  camp varchar(5) not null,
+  count int not null
+);
+```
+
+
 ## 기능 요구 사항
 
 * [x] 8 * 8 의 체스 판 생성
@@ -16,7 +59,22 @@
   * [x] 기물의 이동 규칙을 벗어나는 경우 예외 발생
   * [x] 현재 위치로 빈 칸을 입력받은 경우 예외 발생
   * [x] 현재 턴이 아닌 기물을 이동하는 경우 예외 발생
+* [x] status 기능 구현
+  * [x] 남아있는 기물의 점수 계산
+    * queen: 9
+    * rook: 5
+    * bishop 3
+    * knight: 2.5
+    * pawn: 1
+    * [x] 같은 세로줄에 있는 같은 pawn인 경우 0.5
+  * [x] 진영의 점수를 출력
+  * [x] 승리한 진영의 결과 확인
+* [x] 킹이 잡히면 게임 종료
 * [x] end 가 입력되면 프로그램 종료
+* [x] 예외 시 재입력
+* [x] 진행중인 게임 end 입력 후 재시작시 이전 게임 실행
+* [x] quit 입력시 저장하지 않고 게임 종료
+* [x] db 예외 처리
 
 ## 기물의 이동 기능
 
@@ -37,18 +95,12 @@
 
 * start: 게임을 시작하는 명령어
   * 게임 시작은 start 명령어만 가능하다
-* end: 게임을 종료하는 명령어
+* end: 게임을 저장 후 종료하는 명령어
+* quit: 게임을 저장하지 않고 종료하는 명령어
 * move: 게임 중 기물을 움직이는 명령어
   * 게임이 시작되지 않았는데 move 명령어를 입력한다면 예외가 발생한다.
   * 형식은 move [a-h1-8] [a-h1-8] 형태이고 아닐시 예외가 발생한다.
-
-
-## 리팩터링
-
-* [x] 테스트 코드 보충
-* [x] 프로그래밍 요구 사항 지키기
-* [x] 예외 메시지를 커스텀 예외로 만들기
-* [x] 예외 시 재입력 구현하기
+* status: 현재 점수를 확인하는 명령어
 
 ## 우선순위가 낮지만 구현해보고 싶은 기능
 
@@ -57,5 +109,5 @@
   * [ ] 프로모션
   * [ ] 캐슬링
 * 체크 상황
-  * [ ] 체크 메이트면 자동으로 게임 종료
   * [ ] 체크 상황이면 체크를 피하는 방향으로만 이동 가능
+* [ ] log 입력시 현재까지 기보 출력

src/main/java/application/Application.java

@@ -1,6 +1,7 @@
 package application;
 
 import controller.ChessController;
+import db.exception.DBException;
 import java.util.Scanner;
 import view.InputView;
 import view.OutputView;
@@ -12,6 +13,10 @@ public static void main(String[] args) {
         final OutputView outputView = new OutputView();
 
         final ChessController chessController = new ChessController(inputView, outputView);
-        chessController.run();
+        try {
+            chessController.run();
+        } catch (DBException exception) {
+            outputView.printException(exception.getErrorCode());
+        }
     }
 }

src/main/java/constant/ErrorCode.java

@@ -1,15 +1,24 @@
 package constant;
 
 public enum ErrorCode {
-
     INVALID_INPUT,
     INVALID_STATUS,
     INVALID_COMMAND,
     INVALID_POSITION,
-    INVALID_MOVEMENT_RULE,
+    INVALID_PAWN_MOVEMENT,
+    INVALID_KING_MOVEMENT,
+    INVALID_BISHOP_MOVEMENT,
+    INVALID_KNIGHT_MOVEMENT,
+    INVALID_QUEEN_MOVEMENT,
+    INVALID_ROOK_MOVEMENT,
     PIECE_EXIST_IN_ROUTE,
+    OWN_PIECE_EXIST_POSITION,
     PIECE_DOES_NOT_EXIST_POSITION,
     INVALID_CAMP_PIECE,
-    NO_MESSAGE;
-
+    KING_DEAD,
+    CONNECTION,
+    FAIL_SAVE,
+    FAIL_FIND,
+    FAIL_DELETE,
+    NO_MESSAGE
 }

src/main/java/controller/ChessController.java

@@ -1,76 +1,118 @@
 package controller;
 
+import db.Repository;
+import db.dto.BoardDto;
+import db.dto.MovingDto;
+import db.dto.TurnDto;
 import dto.ChessBoardDto;
+import dto.ScoreDto;
 import exception.CustomException;
-import java.util.Collections;
 import java.util.List;
-import model.ChessBoard;
-import model.Command;
+import model.Board;
+import model.Camp;
+import model.ChessGame;
+import model.Turn;
+import model.command.CommandLine;
 import model.status.GameStatus;
-import model.status.Initialization;
+import model.status.StatusFactory;
 import view.InputView;
 import view.OutputView;
 
 public class ChessController {
 
     private final InputView inputView;
     private final OutputView outputView;
+    private final Repository repository = new Repository("chess");
 
     public ChessController(final InputView inputView, final OutputView outputView) {
         this.inputView = inputView;
         this.outputView = outputView;
     }
 
     public void run() {
-        final ChessBoard chessBoard = ChessBoard.setupStartingPosition();
         outputView.printStartMessage();
         GameStatus gameStatus = initGame();
-
+        final ChessGame chessGame = create();
+        if (gameStatus.isRunning()) {
+            outputView.printChessBoard(ChessBoardDto.from(chessGame));
+        }
         while (gameStatus.isRunning()) {
-            printCurrentStatus(chessBoard);
-            gameStatus = play(gameStatus, chessBoard);
+            gameStatus = play(gameStatus, chessGame);
         }
+        save(gameStatus, chessGame);
+    }
+
+    private void save(final GameStatus gameStatus, final ChessGame chessGame) {
+        if (gameStatus.isCheck() || gameStatus.isQuit()) {
+            repository.removeAll();
+            return;
+        }
+        final Board board = chessGame.getBoard();
+        final Camp camp = chessGame.getCamp();
+        final Turn turn = chessGame.getTurn();
+        final BoardDto boardDto = BoardDto.from(board);
+        final TurnDto turnDto = TurnDto.from(camp, turn);
+        repository.save(boardDto, turnDto);
+    }
+
+    private ChessGame create() {
+        if (repository.hasGame()) {
+            return repository.findGame();
+        }
+        return ChessGame.setupStartingPosition();
     }
 
     private GameStatus initGame() {
         try {
-            return Initialization.gameSetting(getCommand());
+            return StatusFactory.create(readCommandLine());
         } catch (final CustomException exception) {
             outputView.printException(exception.getErrorCode());
             return initGame();
         }
     }
 
-    private GameStatus play(final GameStatus gameStatus, final ChessBoard chessBoard) {
+    private GameStatus play(final GameStatus preStatus, final ChessGame chessGame) {
         try {
-            return gameStatus.play(getCommand(), chessBoard);
-        } catch (CustomException exception) {
+            final CommandLine commandLine = readCommandLine();
+            final GameStatus status = preStatus.play(commandLine, chessGame);
+            saveMoving(chessGame, commandLine);
+            print(status, commandLine, chessGame);
+            return status;
+        } catch (final CustomException exception) {
             outputView.printException(exception.getErrorCode());
-            return play(gameStatus, chessBoard);
+            return play(preStatus, chessGame);
         }
     }
 
-    private void printCurrentStatus(final ChessBoard chessBoard) {
-        outputView.printChessBoard(ChessBoardDto.from(chessBoard));
-        outputView.printCamp(chessBoard.getCamp());
+    private void saveMoving(final ChessGame chessGame, final CommandLine commandLine) {
+        if (commandLine.isMove()) {
+            final List<String> body = commandLine.getBody();
+            final Camp camp = chessGame.getCamp().toggle();
+            final MovingDto movingDto = MovingDto.from(body, camp);
+            repository.saveMoving(movingDto);
+        }
     }
 
-    private List<String> getCommand() {
-        List<String> command = Collections.emptyList();
-        while (command.isEmpty()) {
-            command = readCommand();
+    private void print(final GameStatus gameStatus, final CommandLine commandLine, final ChessGame chessGame) {
+        if (gameStatus.isCheck()) {
+            outputView.printWinner(chessGame.getCamp().toString());
+            return;
+        }
+        if (commandLine.isStatus()) {
+            outputView.printScore(ScoreDto.from(chessGame));
+        }
+        if (commandLine.isStart() || commandLine.isMove()) {
+            outputView.printChessBoard(ChessBoardDto.from(chessGame));
         }
-        return command;
     }
 
-    private List<String> readCommand() {
+    private CommandLine readCommandLine() {
         try {
-            List<String> command = inputView.readCommandList();
-            Command.validate(command);
-            return command;
-        } catch (CustomException exception) {
+            final List<String> command = inputView.readCommandList();
+            return CommandLine.from(command);
+        } catch (final CustomException exception) {
             outputView.printException(exception.getErrorCode());
         }
-        return Collections.emptyList();
+        return readCommandLine();
     }
 }