[3,4 단계 - 체스] 제나(위예나) 미션 제출합니다.

.gitignore

@@ -30,3 +30,6 @@ out/
 
 ### VS Code ###
 .vscode/
+
+### docker ###
+./src/main/java/chess/docker/db.mysql

README.md

@@ -2,7 +2,55 @@
 
 ## Pair: 져니 [⛄️](http://github.com/cl8d), 제나 [❤️](https://github.com/yenawee)
 
-## 1단계 피드백 사항 및 추가 수정 사항
+### 프로그램 실행방법
+./java-chess/src/main/java/chess/docker 경로에서 아래 명령어를 입력해주세요
+
+```
+docker-compose -p chess up -d 
+```
+
+정지 시에는 아래 명령어를 입력해주세요
+```
+docker-compose -p chess down
+```
+
+## 3, 4 단계 피드백 사항 및 추가 수정사항
+- [x] Readme 에 도커 환경 세팅 설명 추가
+- [x] DB connect 연결 에러 발생 시 처리
+- [x] 매직 넘버 상수화 및 메소드 이름 구체화
+- [ ] Command 처리 로직 수정
+- [x] 하나의 요청에 대해 하나의 Connection 으로 처리하도록 수정
+- [ ] update 쿼리 수정
+
+
+## ✔ 4단계 기능 요구사항
+
+- [x] 애플리케이션 재시작 시 이전에 하던 체스 게임을 재시작할 수 있어야 한다
+- [x] table
+    - [x] Piece 정보 : piece_type, team_color, rank, file
+    - [x] Chessgame 정보 : turn (chessGame id 는 추후 적용 필요)
+        - [x] CRUD
+            - [x] Create
+                - [x] DB에서 불러 올 체스 게임이 없으면 만든다
+            - [x] Read
+                - [x] DB에 체스 게임 정보가 저장되어 있다면 DB에서 읽어온다
+            - [x] Update
+                - [x] 기물을 움직일 때마다 DB 업데이트 해준다
+                - [x] 우선 delete 후 save 로 구현 (UPDATE 쿼리 사용으로 변경 필요)
+            - [x] Delete
+              - [x] King 이 죽으면 DB 초기화 해준다
+
+## ✔ 3단계 기능 요구사항
+
+- [x] King 이 잡혔을 때 게임 종료
+- [x] status 명령 입력 시 점수 출력, 어느 진영이 이겼는지 출력
+    - [x] commandType 에 status 추가
+- [x] 점수 계산
+    - [x] Queen : 9, Rook : 5, Bishop : 3, Knight : 2.5
+    - [x] Pawn : 기본 1. 같은 세로 줄에 같은 색의 폰이 있으면 0.5
+
+## 1, 2단계 피드백 사항 및 추가 수정 사항
+
 - [x] 출력 시 View 와 Domain 의존성 제거 - DTO 도입
 - [x] 매직 넘버 상수화
 - [x] 클래스 및 메소드 네이밍 의미있는 표현으로 변경
@@ -13,8 +61,7 @@
 - [ ] Readme 에 네이밍 사전, 클래스 다이어그램, 프로그래밍 흐름도 정리하기
 - [x] 예외 발생 시 재입력
 
-
-## ✔ 기능 요구사항
+## ✔ 1, 2단계 기능 요구사항
 
 ### ChessBoard
 
@@ -30,7 +77,7 @@
 
 - [x] 체스 게임을 진행한다.
 
-### CampType
+### TeamColor
 
 - [x] 사용자의 진영을 관리한다.
     - [x] 입력받은 위치의 열이 소문자면 WHITE, 대문자면 BLACK 진영으로 나눈다.

src/main/java/chess/ChessApplication.java

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

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

@@ -1,38 +1,44 @@
 package chess.controller;
 
-import chess.controller.status.Start;
-import chess.controller.status.Status;
-import chess.domain.chess.ChessGame;
+import chess.controller.state.Start;
+import chess.controller.state.State;
+import chess.dao.ChessGameDao;
+import chess.dao.ChessGameLoader;
+import chess.domain.game.ChessGame;
 import chess.domain.piece.Piece;
 import chess.domain.position.Position;
 import chess.view.InputView;
 import chess.view.OutputView;
 
 import java.util.List;
 import java.util.Map;
-import java.util.function.Consumer;
 
 public class ChessController {
+    private final ChessGameDao chessGameDao;
+
+    public ChessController(final ChessGameDao chessGameDao) {
+        this.chessGameDao = chessGameDao;
+    }
 
     public void run() {
         OutputView.printStartMessage();
-        final ChessGame chessGame = new ChessGame();
-        play(chessGame, gameStatus -> {
-            if (gameStatus.isRun()) {
-                printChessBoard(chessGame.getChessBoard());
-            }
-        });
+        ChessGame chessGame = ChessGameLoader.load(chessGameDao);
+        State gameStatus = new Start(chessGame);
+        play(chessGame, gameStatus);
     }
 
-    private void play(final ChessGame chessGame, Consumer<Status> consumer) {
-        Status gameStatus = new Start(chessGame);
-        while (gameStatus.isRun()) {
+    private void play(ChessGame chessGame, State gameStatus) {
+        while (!chessGame.isEnd() && gameStatus.isRun()) {
             gameStatus = getStatus(gameStatus);
-            consumer.accept(gameStatus);
+            chessGameDao.update(chessGame);
+            printChessBoard(gameStatus, chessGame.getChessBoard());
+        }
+        if (chessGame.isEnd()) {
+            chessGameDao.init(chessGame);
         }
     }
 
-    private Status getStatus(Status gameStatus) {
+    private State getStatus(State gameStatus) {
         try {
             List<String> commands = InputView.getCommand();
             final Command command = Command.findCommand(commands);
@@ -43,8 +49,10 @@ private Status getStatus(Status gameStatus) {
         }
     }
 
-    private void printChessBoard(Map<Position, Piece> board) {
-        ChessBoardDto chessBoardDTO = new ChessBoardDto(board);
-        OutputView.print(chessBoardDTO.getBoardMessage().toString());
+    private void printChessBoard(State gameStatus, Map<Position, Piece> board) {
+        if (gameStatus.isRun()) {
+            ChessBoardDto chessBoardDTO = new ChessBoardDto(board);
+            OutputView.print(chessBoardDTO.getBoardMessage().toString());
+        }
     }
 }

src/main/java/chess/controller/Command.java

@@ -1,6 +1,6 @@
 package chess.controller;
 
-import chess.controller.status.CommandType;
+import chess.controller.state.CommandType;
 
 import java.util.Arrays;
 import java.util.List;
@@ -9,7 +9,7 @@ public final class Command {
     public static final int COMMAND_INDEX = 0;
     public static final int MOVE_COMMAND_SIZE = 3;
     private static final String COMMAND_ERROR_MESSAGE = "잘못된 명령어 입력입니다.";
-    
+
     private final CommandType type;
     private final List<String> commands;
 
@@ -38,6 +38,10 @@ public boolean isEnd() {
         return type == CommandType.END;
     }
 
+    public boolean isStatus() {
+        return type == CommandType.STATUS;
+    }
+
     public boolean isCorrectWhenMove() {
         return commands.size() == MOVE_COMMAND_SIZE;
     }

src/main/java/chess/controller/ScoreDto.java

@@ -0,0 +1,22 @@
+package chess.controller;
+
+import chess.domain.piece.TeamColor;
+import chess.domain.result.Score;
+
+public class ScoreDto {
+    private final Double whiteScore;
+    private final Double blackScore;
+
+    public ScoreDto(Score score) {
+        whiteScore = score.getScore(TeamColor.WHITE);
+        blackScore = score.getScore(TeamColor.BLACK);
+    }
+
+    public Double getWhiteScore() {
+        return whiteScore;
+    }
+
+    public Double getBlackScore() {
+        return blackScore;
+    }
+}

src/main/java/chess/controller/state/CommandType.java

@@ -0,0 +1,5 @@
+package chess.controller.state;
+
+public enum CommandType {
+    START, MOVE, END, STATUS
+}

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

@@ -0,0 +1,30 @@
+package chess.controller.state;
+
+import chess.controller.Command;
+import chess.controller.ScoreDto;
+import chess.domain.game.ChessGame;
+import chess.domain.piece.TeamColor;
+import chess.domain.result.Score;
+import chess.view.OutputView;
+
+public final class End implements State {
+    @Override
+    public State checkCommand(final Command command) {
+        throw new IllegalArgumentException("게임이 끝났습니다.");
+    }
+
+    @Override
+    public boolean isRun() {
+        return false;
+    }
+
+    public State run(ChessGame chessGame) {
+        Score score = Score.calculate(chessGame.getChessBoard());
+        OutputView.printStatus(new ScoreDto(score));
+        if (chessGame.isEnd()) {
+            TeamColor winner = chessGame.getCurrentTeamColor();
+            OutputView.print(winner.name());
+        }
+        return new End();
+    }
+}

src/main/java/chess/controller/status/Move.java → src/main/java/chess/controller/state/Move.java

@@ -1,14 +1,14 @@
-package chess.controller.status;
+package chess.controller.state;
 
 import chess.controller.Command;
-import chess.domain.chess.ChessGame;
+import chess.domain.game.ChessGame;
 import chess.domain.piece.TeamColor;
 import chess.domain.position.Position;
 import chess.domain.position.PositionConverter;
 
 import java.util.List;
 
-public final class Move implements Status {
+public final class Move implements State {
     public static final int SOURCE_INDEX = 1;
     public static final int TARGET_INDEX = 2;
 
@@ -21,22 +21,28 @@ public Move(final ChessGame chessGame, final TeamColor teamColor) {
     }
 
     @Override
-    public Status checkCommand(final Command command) {
+    public State checkCommand(final Command command) {
         if (command.isStart()) {
             throw new IllegalArgumentException("이미 시작이 완료되었습니다.");
         }
         if (command.isEnd()) {
-            return new End();
+            return new End().run(chessGame);
+        }
+        if (command.isStatus()) {
+            return new Status(chessGame, teamColor).run();
         }
         validateCommand(command);
         return move(command);
     }
 
-    private Status move(final Command command) {
+    private State move(final Command command) {
         final List<String> commands = command.getCommands();
         final Position source = PositionConverter.convert(commands.get(SOURCE_INDEX));
         final Position target = PositionConverter.convert(commands.get(TARGET_INDEX));
         chessGame.setUp(source, target, teamColor);
+        if (chessGame.isEnd()) {
+            return new End().run(chessGame);
+        }
         return new Move(chessGame, teamColor.changeTurn());
     }
 

src/main/java/chess/controller/state/Start.java

@@ -0,0 +1,29 @@
+package chess.controller.state;
+
+import chess.controller.Command;
+import chess.domain.game.ChessGame;
+
+public final class Start implements State {
+
+    private final ChessGame chessGame;
+
+    public Start(final ChessGame chessGame) {
+        this.chessGame = chessGame;
+    }
+
+    @Override
+    public State checkCommand(final Command command) {
+        if (command.isStart()) {
+            return new Move(chessGame, chessGame.getCurrentTeamColor());
+        }
+        if (command.isEnd()) {
+            return new End();
+        }
+        throw new IllegalArgumentException("게임이 시작되지 않았습니다.");
+    }
+
+    @Override
+    public boolean isRun() {
+        return true;
+    }
+}

src/main/java/chess/controller/state/State.java

@@ -0,0 +1,9 @@
+package chess.controller.state;
+
+import chess.controller.Command;
+
+public interface State {
+    State checkCommand(final Command command);
+
+    boolean isRun();
+}

src/main/java/chess/controller/state/Status.java

@@ -0,0 +1,44 @@
+package chess.controller.state;
+
+import chess.controller.Command;
+import chess.controller.ScoreDto;
+import chess.domain.game.ChessGame;
+import chess.domain.piece.TeamColor;
+import chess.domain.result.Score;
+import chess.view.OutputView;
+
+public class Status implements State {
+    private final ChessGame chessGame;
+    private final TeamColor teamColor;
+
+    public Status(ChessGame chessGame, TeamColor teamColor) {
+        this.chessGame = chessGame;
+        this.teamColor = teamColor;
+    }
+
+    State run() {
+        Score score = Score.calculate(chessGame.getChessBoard());
+        OutputView.printStatus(new ScoreDto(score));
+        return new Status(chessGame, teamColor);
+    }
+
+    @Override
+    public State checkCommand(Command command) {
+        if (command.isEnd()) {
+            return new End().run(chessGame);
+        }
+        if (command.isMove()) {
+            Move move = new Move(chessGame, teamColor);
+            return move.checkCommand(command);
+        }
+        if (command.isStatus()) {
+            return run();
+        }
+        throw new UnsupportedOperationException("end, move 명령어만 입력 가능합니다.");
+    }
+
+    @Override
+    public boolean isRun() {
+        return true;
+    }
+}