[3, 4단계 - 체스] 제이(이재윤) 미션 제출합니다.

README.md

@@ -14,6 +14,12 @@
 - [x] 초기 체스판을 생성한다.
 - [x] 자기 위치로는 움직일 수 없다.
 - [x] 경로 내 장애물이 있는 지 검증한다.
+- [x] 게임에서 남아있는 말에 대한 점수를 구해야한다.
+
+- [x] King이 잡히는 경우 게임에서 진다. (게임 종료)
+- [x] `status` 명령어를 입력하면 각 진영의 점수를 출력하고 어느 진영이 이겼는지 결과를 볼 수 있어야한다. (게임 종료)
+- [x] `end` 명령어를 입력하면 프로그램이 종료한다. (프로그램 종료)
+- [x] 초기 게임 상태 명령어를 받아서 체스 게임을 새로 시작할지 혹은 기존 게임을 불러올지 정할 수 있다.
 
 ### 기물 
 - [x] 체스판을 구성하는 요소이다.
@@ -45,3 +51,13 @@
 ### 출력
 - [x] 게임 시작 문구를 출력한다.
 - [x] 체스판 현황을 출력한다.
+
+### DB
+- DB 계획도
+  - Room (room_id, game_id, user1, user2) --> 추가 미션 예정
+  - Game (game_id, board_id) --> 추가 미션 예정
+  - board (board_id, position(String), piece(String), isLowerTeamTurn) --> isLowerTeamTurn은 추가 미션 때 Game 테이블로 옮길 예정입니다.
+
+
+
+

src/main/java/chess/Application.java

@@ -1,15 +1,19 @@
 package chess;
 
 import chess.controller.ChessGameController;
+import chess.service.BoardService;
 import chess.view.InputView;
 import chess.view.OutputView;
+import chess.view.ResultView;
 
 public class Application {
 
     public static void main(String[] args) {
         ChessGameController chessGameController = new ChessGameController(
                 new InputView(),
-                new OutputView()
+                new OutputView(),
+                new ResultView(),
+                new BoardService()
         );
 
         chessGameController.run();

src/main/java/chess/controller/ChessGameController.java

@@ -1,66 +1,142 @@
 package chess.controller;
 
+import chess.domain.commnad.Command;
+import chess.domain.commnad.LoadGameCommand;
 import chess.domain.game.ChessGame;
 import chess.factory.BoardFactory;
+import chess.service.BoardService;
 import chess.view.InputView;
 import chess.view.OutputView;
-import java.util.List;
+import chess.view.ResultView;
 
 public class ChessGameController {
 
-    private static final String START_COMMAND = "start";
-    private static final String MOVE_COMMAND = "move";
-    private static final String END_COMMAND = "end";
-    private static final int COMMAND_INDEX = 0;
-    private static final int SELECTED_PIECE = 1;
-    private static final int DESTINATION = 2;
+    private static final int BOARD_ID = 1;
 
     private final InputView inputView;
     private final OutputView outputView;
+    private final ResultView resultView;
+    private final BoardService boardService;
 
-    public ChessGameController(final InputView inputView, final OutputView outputView) {
+    public ChessGameController(final InputView inputView,
+                               final OutputView outputView,
+                               final ResultView resultView,
+                               final BoardService boardService) {
         this.inputView = inputView;
         this.outputView = outputView;
+        this.resultView = resultView;
+        this.boardService = boardService;
     }
 
     public void run() {
-        ChessGame chessGame = new ChessGame(BoardFactory.createBoard());
+        LoadGameCommand loadGameCommand = inputView.readStatusOfGame();
+        ChessGame chessGame = loadGame(loadGameCommand);
 
         outputView.printStartMessage();
+        playChess(chessGame);
 
-        List<String> inputCommand = inputView.readGameCommand();
+        resultView.printGameEnd();
+    }
+
+    private ChessGame loadGame(final LoadGameCommand loadCommand) {
+        if (loadCommand.isSavedGame()) {
+            ChessGame chessGame = new ChessGame(boardService.findById(BOARD_ID), boardService.isLowerTeamTurnByBoardId(BOARD_ID));
+            outputView.printBoard(chessGame.getBoard());
+            return chessGame;
+        }
 
-        playChess(chessGame, inputCommand);
+        return new ChessGame(BoardFactory.createBoard(), true);
     }
 
-    private void playChess(ChessGame chessGame, List<String> inputCommand) {
-        while (isNotEnd(inputCommand)) {
-            try {
-                chessGame = createNewChessGame(chessGame, inputCommand);
-                tryChessMove(chessGame, inputCommand);
-                outputView.printBoard(chessGame.getBoard());
-                inputCommand = inputView.readGameCommand();
-            } catch (IllegalArgumentException exception) {
-                System.out.println(exception.getMessage());
-                inputCommand = inputView.readGameCommand();
+
+    private void playChess(ChessGame chessGame) {
+        Command command = inputView.readGameCommand();
+
+        while (!isGameEndCase(chessGame, command)) {
+            chessGame = checkCreateNewGame(chessGame, command);
+
+            checkMovePiece(chessGame, command);
+            outputView.printBoard(chessGame.getBoard());
+
+            if (isGameDone(chessGame)) {
+                break;
             }
+
+            command = inputView.readGameCommand();
         }
     }
 
-    private boolean isNotEnd(final List<String> inputCommand) {
-        return !inputCommand.get(COMMAND_INDEX).equals(END_COMMAND);
+    private boolean isGameEndCase(final ChessGame chessGame, final Command command) {
+        if (isGameEnd(chessGame, command)) {
+            resultView.printGameEndWithSaving();
+            boardService.delete(BOARD_ID);
+            boardService.save(BOARD_ID, chessGame.getBoard(), chessGame.isLowerTeamTurn());
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean isGameEnd(final ChessGame chessGame, final Command command) {
+        if (isCommandStatus(chessGame, command) || command.isGameStop()) {
+            return true;
+        }
+
+        return false;
     }
 
-    private void tryChessMove(final ChessGame chessGame, final List<String> inputCommand) {
-        if (inputCommand.get(COMMAND_INDEX).startsWith(MOVE_COMMAND)) {
-            chessGame.move(inputCommand.get(SELECTED_PIECE), inputCommand.get(DESTINATION));
+    private boolean isCommandStatus(final ChessGame chessGame, final Command command) {
+        if (command.isStatus()) {
+            resultView.printScore(chessGame.calculateScoreOfUpperTeam(), chessGame.calculateScoreOfLowerTeam());
+            resultView.printWinner(chessGame.calculateScoreOfUpperTeam(),
+                    chessGame.calculateScoreOfLowerTeam());
+            return true;
         }
+
+        return false;
     }
 
-    private ChessGame createNewChessGame(ChessGame chessGame, final List<String> inputCommand) {
-        if (inputCommand.get(COMMAND_INDEX).equals(START_COMMAND)) {
-            chessGame = new ChessGame(BoardFactory.createBoard());
+    private ChessGame checkCreateNewGame(final ChessGame chessGame, final Command command) {
+        if (command.isCreateNewGame()) {
+            chessGame.initGame();
         }
+
         return chessGame;
     }
+
+    private boolean isGameDone(final ChessGame chessGame) {
+        if (isKingDead(chessGame)) {
+            resultView.printGameEndWithDeleting();
+            boardService.delete(BOARD_ID);
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean isKingDead(final ChessGame chessGame) {
+        if (chessGame.isKingDead() && chessGame.isUpperTeamWin()) {
+            resultView.printWinnerIsUpperTeam();
+            return true;
+        }
+
+        if (chessGame.isKingDead() && !chessGame.isUpperTeamWin()) {
+            resultView.printWinnerIsLowerTeam();
+            return true;
+        }
+
+        return false;
+    }
+
+    private void checkMovePiece(final ChessGame chessGame, final Command command) {
+        if (!command.isMove()) {
+            return;
+        }
+
+        try {
+            chessGame.move(command.findSelectedPiece(), command.findDestination());
+        } catch (IllegalArgumentException exception) {
+            System.out.println(exception.getMessage());
+        }
+    }
 }

src/main/java/chess/dao/board/BoardDao.java

@@ -0,0 +1,14 @@
+package chess.dao.board;
+
+import java.util.Map;
+
+public interface BoardDao {
+
+    void save(final int boardId, final Map<String, String> board, final boolean isLowerTeamTurn);
+
+    Map<String, String> findById(final int boardId);
+
+    boolean isLowerTeamTurnByBoardId(final int boardId);
+
+    void remove(int boardId);
+}

src/main/java/chess/dao/board/BoardDaoImpl.java

@@ -0,0 +1,105 @@
+package chess.dao.board;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class BoardDaoImpl implements BoardDao {
+
+    private static final String SERVER = "localhost:13306";
+    private static final String DATABASE = "chess";
+    private static final String OPTION = "?useSSL=false&serverTimezone=UTC";
+    private static final String USERNAME = "root";
+    private static final String PASSWORD = "root";
+
+    public Connection getConnection() {
+        try {
+            return DriverManager.getConnection("jdbc:mysql://" + SERVER + "/" + DATABASE + OPTION, USERNAME, PASSWORD);
+        } catch (final SQLException e) {
+            System.err.println("DB 연결 오류:" + e.getMessage());
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    public void save(final int boardId, final Map<String, String> board, final boolean isLowerTeamTurn) {
+        final String query = "INSERT INTO board (board_id, position, piece, isLowerTeamTurn) VALUES (?, ?, ?, ?)";
+
+        try (final PreparedStatement preparedStatement = getConnection().prepareStatement(query)) {
+
+            for (final Entry<String, String> boardEntry : board.entrySet()) {
+                final String position = boardEntry.getKey();
+                final String piece = boardEntry.getValue();
+
+                preparedStatement.setInt(1, boardId);
+                preparedStatement.setString(2, position);
+                preparedStatement.setString(3, piece);
+                preparedStatement.setBoolean(4, isLowerTeamTurn);
+                preparedStatement.addBatch();
+            }
+            preparedStatement.executeBatch();
+        } catch (SQLException e) {
+            e.printStackTrace();
+            throw new RuntimeException("board 저장 실패");
+        }
+    }
+
+    @Override
+    public Map<String, String> findById(final int boardId) {
+        final String query = "SELECT position, piece FROM board WHERE board_id = ?";
+        final Map<String, String> board = new HashMap<>();
+        try (final var connection = getConnection();
+             final var preparedStatement = connection.prepareStatement(query)) {
+
+            preparedStatement.setString(1, String.valueOf(boardId));
+            ResultSet result = preparedStatement.executeQuery();
+
+            while (result.next()) {
+                board.put(result.getString("position"), result.getString("piece"));
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+
+        return board;
+    }
+
+    @Override
+    public boolean isLowerTeamTurnByBoardId(final int boardId) {
+        final String query = "SELECT isLowerTeamTurn FROM board WHERE board_id = ?";
+
+        try (final var connection = getConnection();
+             final var preparedStatement = connection.prepareStatement(query)) {
+
+            preparedStatement.setString(1, String.valueOf(boardId));
+
+            final ResultSet result = preparedStatement.executeQuery();
+
+            while (result.next()) {
+                return result.getBoolean("isLowerTeamTurn");
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    @Override
+    public void remove(final int boardId) {
+        final String query = "DELETE FROM board WHERE board_id = ?";
+
+        try (final var connection = getConnection();
+             final var preparedStatement = connection.prepareStatement(query)) {
+            preparedStatement.setString(1, String.valueOf(boardId));
+            preparedStatement.executeUpdate();
+        } catch (final SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}