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

README.md

@@ -16,7 +16,6 @@
 ### 장기 게임 (JanggiGame)
 - [X] 장기 게임 흐름 관리
   - [X] 게임 턴 관리
-
 - [X] 초기 장기판 셋업 (각 기물들을 정해진 초기 Point에 배치)
 
 ### ✉️ 도메인 (Domain)
@@ -50,12 +49,63 @@
 
 ### 📤 출력 (OutputView)
 #### 게임 진행 상태 출력
-- [ ] 게임 시작 안내 메시지 출력
-- [ ] 매 턴마다 현재 누구의 턴인지 출력
+- [X] 게임 시작 안내 메시지 출력
+- [X] 매 턴마다 현재 누구의 턴인지 출력
 - [X] 매 턴마다 이동 결과가 반영된 현재 장기판의 상태를 시각적으로 출력
 
 #### 게임 종료 출력
 - [X] 승리 팀 안내 및 게임 종료 메시지 출력 
 
 #### 에러 출력
-- [ ] 예외 상황 발생 시 에러 문구 출력 (반드시 [ERROR]로 시작)
+- [X] 예외 상황 발생 시 에러 문구 출력 (반드시 [ERROR]로 시작)
+
+## 추가 기능 목록
+### 궁성 규칙
+- [X] 장과 사는 궁성 안에서만 이동할 수 있다.
+- [X] 장은 궁성 대각선 이동 규칙을 따른다.
+- [X] 사는 궁성 대각선 이동 규칙을 따른다.
+- [X] 차는 궁성 대각선 이동 규칙을 따른다.
+- [X] 포는 궁성 대각선 이동 규칙을 따른다.
+- [X] 졸은 궁성 안에서 대각선 이동 규칙을 따른다.
+
+### 게임 종료
+- [X] 상대 왕이 잡히면 게임을 종료한다.
+- [X] 게임 종료 시 승자를 반환한다.
+
+### 점수 계산
+- [X] 현재 남아 있는 기물의 점수를 계산한다.
+- [X] 팀별 점수를 계산할 수 있다.
+
+### 데이터베이스 초기화
+- [X] H2 데이터베이스에 연결한다.
+- [X] 애플리케이션 시작 시 스키마를 초기화한다.
+- [X] games 테이블을 생성한다.
+- [X] game_pieces 테이블을 생성한다.
+
+### 게임 저장소
+- [X] 게임 목록을 조회할 수 있다.
+- [X] 게임 id로 게임을 조회할 수 있다.
+- [X] 새 게임을 저장할 수 있다.
+- [X] 진행 중인 게임 상태를 수정할 수 있다.
+- [X] 게임의 현재 턴 정보를 저장한다.
+- [X] 게임의 종료 여부와 승자를 저장한다.
+- [X] 현재 살아있는 기물의 위치를 저장한다.
+
+### 게임 복구
+- [X] 저장된 게임 목록을 출력한다.
+- [X] 사용자가 이어서 할 게임을 선택할 수 있다.
+- [X] 저장된 기물 위치로 장기판을 복구한다.
+- [X] 저장된 현재 턴으로 게임을 복구한다.
+- [X] 저장된 종료 상태로 게임을 복구한다.
+- [X] 저장된 게임이 없으면 새 게임을 시작한다.
+
+### 게임 진행 흐름
+- [X] 새 게임을 생성할 수 있다.
+- [X] 수를 둘 때마다 게임 상태를 저장한다.
+- [X] 게임 종료 시 최종 상태를 저장한다.
+
+### 입/출력
+- [X] 게임 시작 시 새 게임과 이어하기 메뉴를 출력한다.
+- [X] 저장된 게임 목록을 사용자에게 출력한다.
+- [X] 사용자가 선택한 게임을 불러온다.
+- [X] 현재 턴 정보를 출력한다.

build.gradle

@@ -9,6 +9,7 @@ repositories {
 }
 
 dependencies {
+    implementation 'com.h2database:h2:2.3.232'
     testImplementation platform('org.junit:junit-bom:5.11.4')
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')

src/main/java/janggi/JanggiApplication.java

@@ -1,28 +1,70 @@
 package janggi;
 
-import janggi.domain.Board;
+import janggi.domain.status.Team;
+import janggi.repository.CsvInitialBoardProvider;
+import janggi.repository.GameRepository;
+import janggi.repository.InitialBoardProvider;
+import janggi.service.JanggiGameService;
+import janggi.dto.GameSummary;
 import janggi.domain.JanggiGame;
 import janggi.domain.Point;
 import janggi.dto.GameStatusInfo;
-import janggi.dto.PositionInfo;
+import janggi.util.DatabaseInitializer;
+import janggi.util.JdbcConnectionManager;
+import janggi.repository.JdbcGameRepository;
 import janggi.ui.InputView;
 import janggi.ui.OutputView;
-import janggi.util.FileParser;
 import java.util.List;
 
 public class JanggiApplication {
+
     public static void main(String[] args) {
-        List<PositionInfo> positionInfos = FileParser.readCsvFile("/janggi.csv");
-        Board board = new Board();
-        board.init(positionInfos);
-        JanggiGame game = new JanggiGame(board);
-        OutputView.printGameStatus(GameStatusInfo.from(game.getBoardStatus()));
+        JdbcConnectionManager connectionManager = new JdbcConnectionManager(
+                "jdbc:h2:file:./storage/janggi;AUTO_SERVER=TRUE",
+                "sa",
+                ""
+        );
+        DatabaseInitializer databaseInitializer = new DatabaseInitializer(connectionManager);
+        databaseInitializer.init();
+
+        GameRepository gameRepository = new JdbcGameRepository(connectionManager);
+        InitialBoardProvider initialBoardProvider = new CsvInitialBoardProvider();
+        JanggiGameService janggiGameService =
+                new JanggiGameService(gameRepository, initialBoardProvider);
+
+        Long gameId = selectGame(janggiGameService);
+        playGame(janggiGameService, gameId);
+    }
+
+    private static Long selectGame(JanggiGameService janggiGameService) {
+        String command = InputView.readGameCommand();
+        if (InputView.isNewGameCommand(command)) {
+            return janggiGameService.createGame();
+        }
+        if (InputView.isLoadGameCommand(command)) {
+            return loadGame(janggiGameService);
+        }
+        throw new IllegalArgumentException("[ERROR] 1 또는 2를 입력해 주세요.");
+    }
+
+    private static Long loadGame(JanggiGameService janggiGameService) {
+        List<GameSummary> gameSummaries = janggiGameService.findAllGames();
+        OutputView.printSavedGames(gameSummaries);
+        return InputView.readGameId();
+    }
+
+    private static void playGame(JanggiGameService janggiGameService, Long gameId) {
+        JanggiGame janggiGame = janggiGameService.loadGame(gameId);
+        OutputView.printGameStatus(GameStatusInfo.from(janggiGame.getBoardStatus()));
 
-        while (!game.isFinished()) {
+        while (!janggiGame.isFinished()) {
+            OutputView.printCurrentTurn(janggiGame.currentTurn().getName());
             List<Point> points = InputView.readPoints();
-            game.play(points.get(0), points.get(1));
-            OutputView.printGameStatus(GameStatusInfo.from(game.getBoardStatus()));
+            janggiGameService.play(gameId, points.get(0), points.get(1));
+            janggiGame = janggiGameService.loadGame(gameId);
+            OutputView.printGameStatus(GameStatusInfo.from(janggiGame.getBoardStatus()));
         }
-        OutputView.printWinner(game.getWinner());
+        OutputView.printWinner(janggiGame.getWinner());
+        OutputView.printScore(janggiGame.scoreOf(Team.CHO), janggiGame.scoreOf(Team.HAN));
     }
 }

src/main/java/janggi/domain/Board.java

@@ -12,79 +12,63 @@
 
 public class Board {
 
-    private static final int BOARD_HEIGHT = 10;
-
-    private final Map<Point, Piece> state;
+    private final Map<Point, Piece> piecesByPoint;
 
     public Board() {
-        this.state = new LinkedHashMap<>();
+        this.piecesByPoint = new LinkedHashMap<>();
     }
 
     public void init(List<PositionInfo> positionInfos) {
-        positionInfos.forEach(info -> state.put(info.point(), info.piece()));
+        positionInfos.forEach(info -> piecesByPoint.put(info.point(), info.piece()));
     }
 
     public void move(Point from, Point to, Team team) {
         validateFromPoint(from, team);
         validateToPoint(to, team);
-        Piece piece = state.get(from);
+        Piece piece = piecesByPoint.get(from);
         List<Point> route = piece.getRoute(from, to);
-        Piece targetPiece = state.get(to);
+        Piece targetPiece = piecesByPoint.get(to);
         if (targetPiece != null && !piece.canCapture(targetPiece)) {
-            throw new IllegalArgumentException("이 기물은 해당 타겟을 잡을 수 없습니다.");
+            throw new IllegalStateException("[ERROR] 이 기물은 해당 타겟을 잡을 수 없습니다.");
         }
         if (!piece.canMove(getPieces(route))) {
-            throw new IllegalArgumentException("해당 기물의 이동 경로에 장애물이 있거나 규칙에 어긋납니다.");
-        }
-        state.remove(from);
-        state.put(to, piece);
-    }
-
-    public boolean isKingDie(Team team) {
-        return state.values().stream()
-                .noneMatch(piece -> piece.isSameType(PieceType.JANG) &&
-                        piece.isSameTeam(team));
-    }
-
-    public List<List<Piece>> getPoints() {
-        List<List<Piece>> pieces = new ArrayList<>();
-        for (int i = 0; i < BOARD_HEIGHT; i++) {
-            pieces.add(
-                    Point.getRow(i).stream()
-                            .map(state::get)
-                            .toList()
-            );
+            throw new IllegalStateException("[ERROR] 해당 기물의 이동 경로에 장애물이 있거나 규칙에 어긋납니다.");
         }
-        return pieces;
+        piecesByPoint.remove(from);
+        piecesByPoint.put(to, piece);
     }
 
     public List<Piece> getPieces(List<Point> point) {
         return point.stream()
-                .map(state::get)
+                .map(piecesByPoint::get)
                 .filter(Objects::nonNull)
                 .toList();
     }
 
+    public Map<Point, Piece> getPiecesByPoint() {
+        return piecesByPoint;
+    }
+
     private void validateFromPoint(Point from, Team team) {
         if (isEmptyPoint(from)) {
-            throw new IllegalArgumentException("출발지에 이동할 기물이 없습니다.");
+            throw new IllegalStateException("[ERROR] 출발지에 이동할 기물이 없습니다.");
         }
         if (!isSameTeam(from, team)) {
-            throw new IllegalArgumentException("상대방의 기물은 움직일 수 없습니다.");
+            throw new IllegalStateException("[ERROR] 상대방의 기물은 움직일 수 없습니다.");
         }
     }
 
     private void validateToPoint(Point to, Team team) {
         if (!isEmptyPoint(to) && isSameTeam(to, team)) {
-            throw new IllegalArgumentException("도착지에 본인의 기물이 있습니다.");
+            throw new IllegalStateException("[ERROR] 도착지에 본인의 기물이 있습니다.");
         }
     }
 
     private boolean isSameTeam(Point point, Team team) {
-        return state.get(point).isSameTeam(team);
+        return piecesByPoint.get(point).isSameTeam(team);
     }
 
     private boolean isEmptyPoint(Point point) {
-        return state.get(point) == null;
+        return piecesByPoint.get(point) == null;
     }
 }

src/main/java/janggi/domain/Boards.java

@@ -0,0 +1,52 @@
+package janggi.domain;
+
+import janggi.domain.piece.Piece;
+import janggi.domain.piece.PieceType;
+import janggi.domain.status.Team;
+import janggi.dto.PositionInfo;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Boards {
+
+    private static final int BOARD_HEIGHT = 10;
+
+    private final Board board;
+
+    public Boards(Board board) {
+        this.board = board;
+    }
+
+    public void move(Point from, Point to, Team team) {
+        board.move(from, to, team);
+    }
+
+    public int scoreOf(Team team) {
+        return board.getPiecesByPoint().values().stream()
+                .filter(piece -> piece.isSameTeam(team))
+                .mapToInt(Piece::getScore)
+                .sum();
+    }
+
+    public boolean isKingDie(Team team) {
+        return board.getPiecesByPoint().values().stream()
+                .noneMatch(piece -> piece.isSameType(PieceType.JANG) &&
+                        piece.isSameTeam(team));
+    }
+
+    public List<PositionInfo> getBoardStatus() {
+        return PositionInfo.from(board.getPiecesByPoint());
+    }
+
+    public List<List<Piece>> getPoints() {
+        List<List<Piece>> pieces = new ArrayList<>();
+        for (int i = 0; i < BOARD_HEIGHT; i++) {
+            pieces.add(
+                    Point.getPointsAtY(i).stream()
+                            .map(board.getPiecesByPoint()::get)
+                            .toList()
+            );
+        }
+        return pieces;
+    }
+}

src/main/java/janggi/domain/JanggiGame.java

@@ -4,16 +4,22 @@
 import janggi.domain.status.ChoTurn;
 import janggi.domain.status.GameStatus;
 import janggi.domain.status.Team;
+import janggi.dto.PositionInfo;
 import java.util.List;
 
 public class JanggiGame {
 
-    private final Board board;
     private GameStatus gameStatus;
+    private final Boards boards;
 
     public JanggiGame(Board board) {
-        this.board = board;
         this.gameStatus = new ChoTurn();
+        this.boards = new Boards(board);
+    }
+
+    public JanggiGame(Board board, GameStatus gameStatus) {
+        this.boards = new Boards(board);
+        this.gameStatus = gameStatus;
     }
 
     public boolean isFinished() {
@@ -22,16 +28,28 @@ public boolean isFinished() {
 
     public Team getWinner() {
         if (!gameStatus.isFinished()) {
-            throw new RuntimeException("게임이 아직 끝나지 않았습니다.");
+            throw new IllegalStateException("[ERROR] 게임이 아직 끝나지 않았습니다.");
         }
         return gameStatus.getTeam();
     }
 
     public List<List<Piece>> getBoardStatus() {
-        return board.getPoints();
+        return boards.getPoints();
     }
 
     public void play(Point from, Point to) {
-        this.gameStatus = gameStatus.move(from, to, board);
+        this.gameStatus = gameStatus.move(from, to, boards);
+    }
+
+    public Team currentTurn() {
+        return gameStatus.getTeam();
+    }
+
+    public List<PositionInfo> boardStatus() {
+        return boards.getBoardStatus();
+    }
+
+    public int scoreOf(Team team) {
+        return boards.scoreOf(team);
     }
 }