[3, 4단계 - 체스] 페드로(류형욱) 미션 제출합니다.

.gitignore

@@ -32,4 +32,4 @@ out/
 .vscode/
 
 ### Docker ###
-/docker/
+/docker/db

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,3 +1,10 @@
+## 실행 방법
+1. 프로그램 실행 후 start 를 입력하여 새로운 게임을 시작하거나 load 를 입력하여 이전에 저장된 게임을 불러온다.
+2. 게임이 시작되면 move {source} {target} 을 입력하여 체스 말을 움직인다.
+3. 게임 진행 중 save 명령으로 현재 상태를 저장할 수 있다.
+4. 한 팀의 킹이 잡히면 게임은 종료되고, 이때 status 명령으로 각 팀의 점수와 승자를 확인할 수 있다.
+5. 어디서든 end 명령으로 게임을 종료할 수 있다.
+
 ## 기능 흐름
 
 - [x] 사용자로부터 게임 시작 여부 입력
@@ -21,6 +28,7 @@
 
 ### Piece
 - [x] 타입이 다른 기물들과 자신을 구별할 수 있는`PieceType`을 가진다.
+  - [x] `PieceType` 에는 각 기물의 평가치(점수)가 정의되어 있다. 
 - [x] 이동 가능한 위치인지 여부를 확인한다.
 - [x] 모든 말은 체스보드 안에서만 움직일 수 있다.
 - [x] 목적지까지 가는 경로에 다른 기물이 존재하면 이동할 수 없다.
@@ -44,9 +52,25 @@
 - [x] 체스의 규칙에 맞게 각 기물들을 시작 위치로 배치한다.
 - [x] 기물의 도착지에 현재 이동하는 기물과 같은 색의 기물이 존재하면 이동할 수 없다.
 - [x] 도착지에 다른 색의 기물이 존재하는 경우, 해당 기물을 제거하고 배치한다.
+- [x] 현재 보드에 남아 있는 기물들을 기반으로 각 팀의 점수를 계산할 수 있다.
+  - 각 팀의 점수는 남아 있는 팀의 기물 평가치의 합으로 계산한다.
+  - 같은 세로줄에 같은 색의 폰이 있는 경우, 각 폰들은 원래 평가치의 절반으로 계산된다.
+
+### ChessGame
+- [x] `흰 팀 차례`, `검은 팀 차례`, `게임 종료` 의 상태를 가진다.
+- [x] 게임이 진행중인 상태에서는 전달받은 출발지와 목적지에 따라 말을 이동시킨다.
+- [x] 한 팀의 킹이 잡히면 게임을 종료한다.
+- [x] 게임이 종료된 경우 승자를 판단할 수 있다.
+- [x] 상태와 무관하게 각 팀별 현재 점수를 계산할 수 있다.
+- [ ] 현재 게임 상태를 DB에 저장할 수 있다.
+- [ ] DB에 저장된 게임 상태를 다시 불러올 수 있다.
 
 ### InputView
 - [x] `start` 명령과 `end`, `move` 명령을 입력받는다.
+- [x] 게임 종료 후 `status` 명령을 입력받을 수 있다.
+- [ ] 현재 게임 상태를 저장하기 위한 `save` 명령을 입력받을 수 있다.
+- [ ] 저장된 게임 상태를 불러오기 위한 `load` 명령을 입력받을 수 있다.
 
 ### OutputView
 - [x] 현재 체스판의 상태를 출력한다.
+- [x] 각 진영의 점수를 출력하고 어느 진영이 이겼는지 출력한다.

src/main/java/Application.java

@@ -1,12 +1,14 @@
 import controller.ChessController;
+import service.DBService;
 import view.InputView;
 import view.OutputView;
 
 public class Application {
     public static void main(String[] args) {
         InputView inputView = new InputView();
         OutputView outputView = new OutputView();
-        ChessController chessController = new ChessController(inputView, outputView);
+        DBService dbService = new DBService();
+        ChessController chessController = new ChessController(inputView, outputView, dbService);
 
         chessController.run();
     }

src/main/java/controller/ChessController.java

@@ -1,29 +1,35 @@
 package controller;
 
-import domain.GameCommand;
-import domain.game.Board;
-import domain.game.BoardInitializer;
-import domain.game.Turn;
+import domain.game.ChessGame;
+import domain.game.GameRequest;
+import domain.game.Piece;
+import domain.game.TeamColor;
+import domain.position.Position;
+import service.DBService;
 import dto.BoardDto;
-import dto.RequestDto;
+import java.util.Map;
 import java.util.function.Supplier;
 import view.InputView;
 import view.OutputView;
 
 public class ChessController {
     private final InputView inputView;
     private final OutputView outputView;
+    private final DBService dbService;
 
-    public ChessController(final InputView inputView, final OutputView outputView) {
+    public ChessController(final InputView inputView, final OutputView outputView, final DBService dbService) {
         this.inputView = inputView;
         this.outputView = outputView;
+        this.dbService = dbService;
     }
 
     public void run() {
         outputView.printWelcomeMessage();
-        GameCommand command = readUserInput(inputView::inputGameStart);
-        if (command.isStart()) {
-            startGame();
+        GameRequest gameRequest = readUserInput(inputView::inputGameCommand).asRequest();
+        while (gameRequest.isStart() || gameRequest.isLoad()) {
+            startGame(gameRequest);
+            outputView.printRestartMessage();
+            gameRequest = readUserInput(inputView::inputGameCommand).asRequest();
         }
     }
 
@@ -32,35 +38,84 @@ private <T> T readUserInput(Supplier<T> inputSupplier) {
             try {
                 return inputSupplier.get();
             } catch (IllegalArgumentException e) {
-                System.out.println(e.getMessage());
+                outputView.printErrorMessage(e.getMessage());
             }
         }
     }
 
-    private void startGame() {
-        Board board = BoardInitializer.init();
-        printStatus(board);
+    private void startGame(GameRequest gameRequest) {
+        ChessGame chessGame = createGame(gameRequest);
+        printBoardStatus(chessGame.getPositionsOfPieces());
 
-        Turn turn = new Turn();
-        RequestDto requestDto = readUserInput(inputView::inputGameCommand);
-        while (requestDto.command().isContinuable()) {
-            doTurn(board, turn, requestDto);
-            printStatus(board);
-            requestDto = readUserInput(inputView::inputGameCommand);
+        while (shouldProceedGame(gameRequest, chessGame)) {
+            outputView.printCurrentTurn(chessGame.currentPlayingTeam());
+            gameRequest = readUserInput(inputView::inputGameCommand).asRequest();
+            processRequest(gameRequest, chessGame);
         }
+        finishGame(gameRequest, chessGame);
     }
 
-    private void doTurn(Board board, Turn turn, RequestDto requestDto) {
-        try {
-            board.movePiece(turn.current(), requestDto.source(), requestDto.destination());
-            turn.next();
-        } catch (IllegalArgumentException e) {
-            System.out.println("[오류] " + e.getMessage());
+    private ChessGame createGame(GameRequest gameRequest)  {
+        if (gameRequest.isStart()) {
+            return new ChessGame();
         }
+        int gameId = readUserInput(inputView::inputGameId);
+        return dbService.loadGame(gameId);
     }
 
-    private void printStatus(Board board) {
-        BoardDto boardDto = BoardDto.from(board);
+    private void printBoardStatus(Map<Position, Piece> positionOfPieces) {
+        BoardDto boardDto = BoardDto.from(positionOfPieces);
         outputView.printBoard(boardDto);
     }
+
+    private boolean shouldProceedGame(GameRequest gameRequest, ChessGame chessGame) {
+        return gameRequest.isContinuable() && !chessGame.isGameEnd();
+    }
+
+    private void processRequest(GameRequest gameRequest, ChessGame chessGame) {
+        if (gameRequest.isSave()) {
+            saveCurrentStatus(chessGame);
+            return;
+        }
+        if (gameRequest.isContinuable()) {
+            playRound(gameRequest, chessGame);
+        }
+    }
+
+    private void saveCurrentStatus(ChessGame chessGame) {
+        int gameId = dbService.saveGame(chessGame);
+        outputView.printSaveResult(gameId);
+    }
+
+    private void playRound(GameRequest gameRequest, ChessGame chessGame) {
+        try {
+            chessGame.move(gameRequest.source(), gameRequest.destination());
+            printBoardStatus(chessGame.getPositionsOfPieces());
+        } catch (IllegalArgumentException | IllegalStateException e) {
+            outputView.printErrorMessage(e.getMessage());
+        }
+    }
+
+    private void finishGame(GameRequest gameRequest, ChessGame chessGame) {
+        outputView.printGameEndMessage();
+        if (gameRequest.isEnd()) {
+            return;
+        }
+
+        outputView.printStatusInputMessage();
+        gameRequest = readUserInput(inputView::inputGameCommand).asRequest();
+        if (gameRequest.isStatus()) {
+            printGameResult(chessGame);
+        }
+    }
+
+    private void printGameResult(ChessGame chessGame) {
+        TeamColor winner = chessGame.getWinner();
+        double whiteScore = chessGame.currentScoreOf(TeamColor.WHITE);
+        double blackScore = chessGame.currentScoreOf(TeamColor.BLACK);
+
+        outputView.printWinner(winner);
+        outputView.printScore(TeamColor.WHITE, whiteScore);
+        outputView.printScore(TeamColor.BLACK, blackScore);
+    }
 }

src/main/java/dao/DBConnector.java

@@ -0,0 +1,33 @@
+package dao;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+public class DBConnector {
+    private static final String SERVER = "localhost:13306";
+    private static final String DATABASE = "chess";
+    private static final String OPTION = "?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";
+    private static final String USERNAME = "root";
+    private static final String PASSWORD = "root";
+
+    private static DBConnector instance = null;
+
+    private DBConnector() {
+    }
+
+    public static DBConnector getInstance() {
+        if (instance == null) {
+            instance = new DBConnector();
+        }
+        return instance;
+    }
+
+    public Connection getConnection() {
+        try {
+            return DriverManager.getConnection("jdbc:mysql://" + SERVER + "/" + DATABASE + OPTION, USERNAME, PASSWORD);
+        } catch (final SQLException e) {
+            throw new DBException("DB 연결 오류", e);
+        }
+    }
+}

src/main/java/dao/DBException.java

@@ -0,0 +1,17 @@
+package dao;
+
+public class DBException extends RuntimeException {
+    private static final String DEFAULT_ERROR_MESSAGE = "쿼리 실행 중 오류가 발생했습니다.";
+
+    public DBException(String message) {
+        super(message);
+    }
+
+    public DBException(Throwable cause) {
+        super(DEFAULT_ERROR_MESSAGE, cause);
+    }
+
+    public DBException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/dao/GameDao.java

@@ -0,0 +1,12 @@
+package dao;
+
+import domain.game.TeamColor;
+import java.sql.Connection;
+
+public interface GameDao {
+    int addGame(Connection connection);
+
+    TeamColor findTurn(Connection connection, int gameId);
+
+    void updateTurn(Connection connection, int gameId, TeamColor teamColor);
+}

src/main/java/dao/GameDaoImpl.java

@@ -0,0 +1,56 @@
+package dao;
+
+import domain.game.TeamColor;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class GameDaoImpl implements GameDao {
+    private static final String TABLE_NAME = "game";
+
+    @Override
+    public int addGame(Connection connection) {
+        final String query = String.format("INSERT INTO %s(turn) VALUE(?);", TABLE_NAME);
+        try (PreparedStatement preparedStatement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS)) {
+            preparedStatement.setString(1, TeamColor.WHITE.name());
+            preparedStatement.executeUpdate();
+            ResultSet resultSet = preparedStatement.getGeneratedKeys();
+            if (resultSet.next()) {
+                return resultSet.getInt(1);
+            }
+        } catch (final SQLException e) {
+            throw new DBException(e);
+        }
+        throw new DBException("게임 생성 중 오류가 발생했습니다.");
+    }
+
+    @Override
+    public TeamColor findTurn(Connection connection, int gameId) {
+        final String query = String.format("SELECT turn FROM %s WHERE `gameId` = ?", TABLE_NAME);
+        try (PreparedStatement preparedStatement = connection.prepareStatement(query)) {
+            preparedStatement.setInt(1, gameId);
+            final ResultSet resultSet = preparedStatement.executeQuery();
+            if (resultSet.next()) {
+                String turn = resultSet.getString("turn");
+                return TeamColor.valueOf(turn);
+            }
+        } catch (SQLException e) {
+            throw new DBException(e);
+        }
+        throw new DBException(gameId + " 에 해당하는 차례를 찾을 수 없습니다.");
+    }
+
+    @Override
+    public void updateTurn(Connection connection, int gameId, TeamColor teamColor) {
+        final var query = String.format("UPDATE %s SET turn = ? WHERE gameId = ?", TABLE_NAME);
+        try (PreparedStatement preparedStatement = connection.prepareStatement(query)) {
+            preparedStatement.setString(1, teamColor.name());
+            preparedStatement.setInt(2, gameId);
+            preparedStatement.executeUpdate();
+        } catch (SQLException e) {
+            throw new DBException(e);
+        }
+    }
+}

src/main/java/dao/PieceDao.java

@@ -0,0 +1,11 @@
+package dao;
+
+import dto.PieceDto;
+import java.sql.Connection;
+import java.util.List;
+
+public interface PieceDao {
+    void addAll(Connection connection, List<PieceDto> pieceDtos, int gameId);
+
+    List<PieceDto> findAllPieces(Connection connection, int gameId);
+}