[🚀 사이클2 - 미션 (기물 확장 + DB 적용)] 라이 미션 제출합니다.

.gitignore

@@ -30,3 +30,6 @@ out/
 
 ### VS Code ###
 .vscode/
+
+.DS_Store
+**/.DS_Store

README.md

@@ -174,13 +174,16 @@
     - [x] [규칙] 도착 위치에 같은 팀(아군) 기물이 있으면 이동할 수 없다.
     - [ ] [규칙] 이동 이후 자신의 '궁'이 상대에게 잡힐 수 있는 위험한 상태(장군)가 된다면, 그 이동은 허용되지 않는다.
 
-- [x] **[Domain]** 개별 기물의 이동 규칙을 검증한다. (※ **궁성 영역 배제** 룰 적용)
-    - [x] [규칙] **궁/사**: (궁성을 구현하지 않으므로) 현재 위치에서 상하좌우 1칸씩만 이동 가능하다.
+- [x] **[Domain]** 개별 기물의 이동 규칙을 검증한다.
+    - [x] [규칙] **궁/사**: 궁성 내에서 모든 방향으로 1칸 이동 가능하다.
     - [x] [규칙] **차**: 상하좌우로 거리 제한 없이 이동할 수 있다. 단, 이동 경로 중간에 다른 기물이 있으면 뛰어넘을 수 없다.
-    - [ ] [규칙] **포**: 이동 경로 사이에 반드시 다른 기물이 하나 이상 있어야 하며, 넘는 기물이 '포'이면 안 된다. 또한 도착 위치의 기물이 '포'인 경우에는 잡을 수 없다.
+        - [x] [규칙]: 진영 상관없이 궁성 내로 진입하는 경우, 거리 제한 없이 대각선 이동이 가능하다.
+    - [x] [규칙] **포**: 이동 경로 사이에 반드시 다른 기물이 하나 이상 있어야 하며, 넘는 기물이 '포'이면 안 된다. 또한 도착 위치의 기물이 '포'인 경우에는 잡을 수 없다.
+        - [x] [규칙]: 진영 상관없이 궁성 내로 진입하는 경우, 대각선을 포함하여 포를 제외한 기물을 뛰어넘을 수 있다.
     - [x] [규칙] **마**: 직진 한 칸 후 대각선 한 칸 이동한다. 직진하는 첫 칸에 기물이 있으면 이동할 수 없다 (멱).
     - [x] [규칙] **상**: 직진 한 칸 후 대각선으로 두 칸 이동한다. 이동 경로(직선 1칸, 대각선 1칸)가 막혀 있으면 이동할 수 없다 (멱).
     - [x] [규칙] **졸/병**: 한 칸씩 전진 및 좌우 이동만 가능하다. (후퇴 불가)
+        -[x] [규칙]: 상대방의 궁성 안으로 들어갈 경우, 대각선을 포함하여 전진 이동만 가능하다.
 
 - [x] **[UI]** 선택한 기물이 이동할 수 있는 유효한 위치 목록을 출력한다.
 
@@ -189,17 +192,57 @@
 - [x] **[Domain]** 검증을 통과하면 기물을 이동시키고 장기판을 갱신한다.
 
 
------------------------- ✂️ 1차 구현 및 PR 포인트 ------------------------
+## 4. 승패 판정 및 게임 종료 (1차 PR 이후 구현)
 
+- [x] **[Domain]** 상대의 '궁'이 잡혔는지 판단하여 게임 종료 여부를 결정한다.
+    - [x] [규칙] 기물 이동 후, 한쪽의 '궁'이 보드판에서 사라졌다면 즉시 게임이 끝난다.
 
-## 4. 승패 판정 및 게임 종료 (1차 PR 이후 구현)
+- [x] **[Domain]** 현재 남아 있는 기물의 총점을 구한다.
+    - [x] [규칙] 궁을 잡으면 게임이 끝나기 때문에, 궁의 점수는 0으로 한다.
+    - [x] [규칙] 차: 13점
+    - [x] [규칙] 포: 7점
+    - [x] [규칙] 마: 5점
+    - [x] [규칙] 상: 3점
+    - [x] [규칙] 사: 3점
+    - [x] [규칙] 졸/병: 2점
+
+- [x] **[UI]** 최종 승패 결과를 출력한다.
+    - [x] [출력] 상대방의 장을 잡은 진영(플레이어)을 승자로 출력한다.
+
+
+## 5. 데이터베이스 연동 및 영속성 관리
+
+- [x] **[Infrastructure]** JDBC를 이용해 MySQL을 연동한다. `class DBConnection`
+    - [x] [규칙] `DB_URL`, `DB_USER`, `DB_PASSWORD`를 환경 변수로 설정해 DB를 연결한다.
+
+- [x] **[Persistence]** 게임 상태 및 보드 정보를 저장한다. `class JdbcJanggiRepository`
+    - [x] [규칙] 새로운 게임 시작 시, 플레이어 정보 및 초기화된 턴을 저장한다. `public Long save(Players players)`
+    - [x] [규칙] 기물 이동 시마다 현재 장기판의 상태를 업데이트한다. `public void updateGameStatus`
+        - [x] [규칙] 턴 변경과 보드 상태 갱신이 원자적으로 이루어지도록 트랜잭션을 보장한다.
+    - [x] [규칙] 종료되지 않고, 진행 중인 가장 최근의 게임 ID를 조회한다. `public Optional<Long> findInProgressGameId`
+    - [x] [규칙] 저장된 게임 ID를 바탕으로 이전 게임의 플레이어, 턴, 보드 상태를 복원한다.
+    - [x] [규칙] 승패 결정 시, 해당 게임의 종료 상태(`is_finished`)를 반영한다. `public void finishGame`
+
+- [x] **[Database]** 게임 영속화를 위해 데이터 스키마를 설계한다.
+    - [x] `game`: 게임 기본 정보 및 현재 턴, 종료 여부 관리
+    - [x] `board_state`: 각 게임 ID별 기물의 종류, 진영, 위치, 고유 번호 관리
+
+![db_diagram.png](images/db_diagram.png)
+
+## 6. 실행 방법
+
+**✅ 프로그램을 실행하기 위해 로컬 환경에 `MySQL`이 설치되어 있어야 하며, 아래와 같은 데이터베이스 설정이 필요합니다.**
+
+1. 데이터베이스 생성: janggi_db (또는 원하는 이름)
+2. 테이블 생성: `src/main/resources/schema.sql` 파일을 실행하여 필요한 테이블을 생성
 
-- [ ] **[Domain]** 상대의 '궁'이 잡혔는지 판단하여 게임 종료 여부를 결정한다.
-    - [ ] [규칙] 기물 이동 후, 한쪽의 '궁'이 보드판에서 사라졌다면 즉시 게임이 끝난다.
+### 프로그램 실행을 위해 필요한 환경 변수
 
-- [ ] **[UI]** 최종 승패 결과를 출력한다.
-    - [ ] [출력] 상대방의 장을 잡은 진영(플레이어)을 승자로 출력한다.
+- `DB_URL`: JDBC 연결 주소 (예: jdbc:mysql://localhost:3306/janggi_db)
+- `DB_USER`: MySQL 사용자 이름
+- `DB_PASSWORD`: MySQL 비밀번호
 
+➡️ IntelliJ를 사용하는 경우, `Run/Debug Configurations`의 `Environment variables` 항목에서 편리하게 설정할 수 있습니다.
 
 ## 3️⃣ 입출력 요구 사항
 

build.gradle

@@ -9,10 +9,14 @@ repositories {
 }
 
 dependencies {
+    implementation 'com.mysql:mysql-connector-j:8.4.0'
+    implementation 'org.slf4j:slf4j-api:2.0.12'
+    implementation 'ch.qos.logback:logback-classic:1.5.3'
     testImplementation platform('org.junit:junit-bom:5.11.4')
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+    testImplementation 'com.h2database:h2:2.2.224'
 }
 
 java {

src/main/java/janggi/Application.java

@@ -1,15 +1,12 @@
 package janggi;
 
-import janggi.view.InputView;
-import janggi.view.OutputView;
+import janggi.config.AppConfig;
 
 public class Application {
 
     public static void main(String[] args) {
-        InputView inputView = new InputView();
-        OutputView outputView = new OutputView();
-        JanggiGame janggiGame = new JanggiGame(outputView, inputView);
-        janggiGame.run();
-        inputView.close();
+        AppConfig appConfig = new AppConfig();
+        GameRunner gameRunner = appConfig.gameRunner();
+        gameRunner.run();
     }
 }

src/main/java/janggi/GameRunner.java

@@ -0,0 +1,88 @@
+package janggi;
+
+import janggi.domain.board.Board;
+import janggi.domain.game.Players;
+import janggi.domain.game.PlayersSaveDTO;
+import janggi.domain.game.Side;
+import janggi.domain.repository.JanggiRepository;
+import janggi.view.InputView;
+import janggi.view.OutputView;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+public class GameRunner {
+    private final OutputView outputView;
+    private final InputView inputView;
+    private final JanggiRepository repository;
+
+    public GameRunner(OutputView outputView, InputView inputView, JanggiRepository repository) {
+        this.outputView = outputView;
+        this.inputView = inputView;
+        this.repository = repository;
+    }
+
+    public void run() {
+        Optional<Long> lastGameId = repository.findInProgressGameId();
+
+        if (lastGameId.isPresent() && isContinued()) {
+            continuallyPlay(lastGameId.get());
+            return;
+        }
+
+        startNewGame();
+        inputView.close();
+    }
+
+    private void startNewGame() {
+        Players players = initialPlayers();
+        Long gameId = repository.save(PlayersSaveDTO.from(players));
+        Board board = Board.initialize();
+
+        new JanggiGame(outputView, inputView, repository, board, gameId).play(players);
+    }
+
+    private void continuallyPlay(Long id) {
+        Board board = repository.findBoardById(id);
+        Players players = repository.findPlayersById(id);
+        outputView.printResumeNotice();
+
+        new JanggiGame(outputView, inputView, repository, board, id).play(players);
+    }
+
+    private Players initialPlayers() {
+        return retry(() -> {
+            String choPlayerName = readPlayerName(Side.CHO);
+            String hanPlayerName = readPlayerName(Side.HAN);
+            return Players.createInitial(choPlayerName, hanPlayerName);
+        });
+    }
+
+    private String readPlayerName(Side side) {
+        outputView.printPlayerNameNotice(side.getDisplayName());
+        return inputView.readPlayerName();
+    }
+
+    private boolean isContinued() {
+        return retry(() -> {
+            outputView.printContinueGameNotice();
+            return inputView.readContinueAnswer();
+        });
+    }
+
+    private <T> T retry(Supplier<T> supplier) {
+        Optional<T> result = Optional.empty();
+        while (result.isEmpty()) {
+            result = tryOnce(supplier);
+        }
+        return result.get();
+    }
+
+    private <T> Optional<T> tryOnce(Supplier<T> supplier) {
+        try {
+            return Optional.of(supplier.get());
+        } catch (IllegalArgumentException e) {
+            outputView.printLine(e.getMessage());
+            return Optional.empty();
+        }
+    }
+}

src/main/java/janggi/JanggiGame.java

@@ -2,62 +2,82 @@
 
 import janggi.domain.board.Board;
 import janggi.domain.board.PieceSelection;
+import janggi.domain.game.Player;
+import janggi.domain.game.PlayerResultDTO;
 import janggi.domain.game.Players;
 import janggi.domain.board.Position;
 import janggi.domain.game.Side;
 import janggi.domain.board.BoardDTO;
 import janggi.domain.game.PlayerDTO;
+import janggi.domain.repository.JanggiRepository;
 import janggi.view.InputView;
 import janggi.view.OutputView;
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.Supplier;
 
 public class JanggiGame {
 
     private final OutputView outputView;
     private final InputView inputView;
     private final Board board;
+    private final JanggiRepository repository;
+    private final Long gameId;
 
-    public JanggiGame(OutputView outputView, InputView inputView) {
+    public JanggiGame(OutputView outputView, InputView inputView, JanggiRepository repository, Board board,
+                      Long gameId) {
         this.outputView = outputView;
         this.inputView = inputView;
-        this.board = Board.initialize();
+        this.repository = repository;
+        this.board = board;
+        this.gameId = gameId;
     }
 
-    public void run() {
-        Players players = initialPlayers();
+    public void play(Players players) {
         printBoard();
-        play(players);
-    }
 
-    private Players initialPlayers() {
-        String choPlayerName = readPlayerName(Side.CHO);
-        String hanPlayerName = readPlayerName(Side.HAN);
+        while (true) {
+            Player current = players.getCurrentPlayer();
+            PlayerDTO currentPlayerDTO = PlayerDTO.from(current);
+            printPlayerTurnNotice(currentPlayerDTO);
+
+            playerTurn(currentPlayerDTO);
+
+            if (board.isGameOver()) {
+                handleGameOver(currentPlayerDTO, players);
+                break;
+            }
 
-        return Players.of(choPlayerName, hanPlayerName);
+            players.switchTurn();
+            repository.updateGameStatus(this.gameId, board, players.getTurn());
+        }
     }
 
     private void printBoard() {
         outputView.printBoardSettingNotice();
         outputView.printBoardStatus(BoardDTO.from(board));
     }
 
-    private void play(Players players) {
-        while (true) {
-            PlayerDTO currentPlayer = players.getCurrentPlayer();
-            printPlayerTurnNotice(currentPlayer);
-            playerTurn(currentPlayer);
-            players.switchTurn();
-        }
-    }
-
     private void playerTurn(PlayerDTO currentPlayer) {
         Side currentSide = currentPlayer.side();
         PieceSelection pieceSelection = selectMovablePiece(currentSide);
         movePiece(pieceSelection.selected(), pieceSelection.destinations());
     }
 
+    private void handleGameOver(PlayerDTO winner, Players players) {
+        repository.finishGame(this.gameId);
+        outputView.printWinnerNotice(winner.side(), winner.name());
+
+        List<PlayerResultDTO> playerResults = new ArrayList<>();
+        for (Player player : players) {
+            double score = board.calculateScore(player.getSide());
+            playerResults.add(new PlayerResultDTO(player.getName(), player.getSide(), score));
+        }
+        outputView.printTotalScores(playerResults);
+    }
+
     private PieceSelection selectMovablePiece(Side currentSide) {
         return retry(() -> {
             outputView.printSelectPiecePosition();
@@ -99,31 +119,24 @@ private Position readTargetPosition() {
         });
     }
 
-    private String readPlayerName(Side side) {
-        return retry(() -> {
-            outputView.printPlayerNameNotice(side.getDisplayName());
-            return inputView.readPlayerName();
-        });
-    }
-
     private void printPlayerTurnNotice(PlayerDTO currentPlayer) {
         outputView.printPlayerTurnNotice(currentPlayer.name(), currentPlayer.side().getDisplayName());
     }
 
     private <T> T retry(Supplier<T> supplier) {
-        T result = null;
-        while (result == null) {
+        Optional<T> result = Optional.empty();
+        while (result.isEmpty()) {
             result = tryOnce(supplier);
         }
-        return result;
+        return result.get();
     }
 
-    private <T> T tryOnce(Supplier<T> supplier) {
+    private <T> Optional<T> tryOnce(Supplier<T> supplier) {
         try {
-            return supplier.get();
+            return Optional.of(supplier.get());
         } catch (IllegalArgumentException e) {
             outputView.printLine(e.getMessage());
-            return null;
+            return Optional.empty();
         }
     }
 }