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

.gitignore

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

README.md

@@ -59,3 +59,100 @@
     - [X] 타 진영 기물 선택 시 예외
     - [X] 빈 칸 선택시 예외
     - [X] 도착 지점에 아군이 있는 경우 예외
+
+## 2.1단계 - 기물의 확장
+
+### 궁성 영역 정의
+
+- [x] 궁성(宮城) 영역 정의
+    - 궁성 좌표 범위 정의
+- [x] 궁성 내 대각선 경로 정의
+    - 궁성에는 대각선 선이 존재하며, 대각선 이동은 이 선 위의 좌표에서만 가능
+    - 대각선 허용 좌표쌍 정의
+- [x] 특정 좌표가 궁성 내부인지 판별하는 기능
+- [x] 두 좌표 간 궁성 대각선 이동 가능 여부 판별
+
+### 궁성 관련 기물 이동 규칙 변경 및 추가
+
+- [x] 장(King)
+    - 궁성 내부에서만 이동 가능
+    - 상하좌우 1칸 이동 (기존 유지)
+    - 궁성 대각선 경로에서 대각선 1칸 이동 가능
+- [x] 사(Advisor)
+    - 궁성 내부에서만 이동 가능
+    - 상하좌우 1칸 이동 (기존 유지)
+    - 궁성 대각선 경로에서 대각선 1칸 이동 가능
+- [x] 차(Tank)
+    - 기존 직선 이동 규칙 유지
+    - 궁성 내부에서 대각선 경로 이동 가능
+- [x] 포(Cannon)
+    - 기존 직선 + 1개 기물 넘기 규칙 유지
+    - 궁성 내부에서 대각선 경로 이동 가능
+- [x] 졸(Soldier)
+    - 기존 전진 + 좌우 이동 유지
+    - 궁성 내부에서 대각선 "전진" 이동 가능
+        - 후진 대각선 불가
+
+### 왕 잡힘 시 게임 종료
+
+- [x] 이동 결과 도착 칸의 기물이 왕(King)인지 판별
+- [x] 왕이 잡혔을 때 승자 진영 결정
+- [x] JanggiGame에 게임 종료 상태 반영
+
+### 점수 계산
+
+- [x] Piece에 `score()` 추상 메서드 추가
+- [x] 기물별 점수 정의
+- [x] Board에서 특정 진영 점수 합산 기능
+- [x] 양 진영 점수 조회 기능
+
+## 2.2단계 - DB 적용
+
+### 1. DB 연결 설정
+
+- [ ] SQLite JDBC 의존성 추가
+- [ ] DB 연결 관리 클래스 생성
+
+### 2. 테이블 설계 및 적용
+
+- [ ] game 테이블 — 게임 메타 정보
+- [ ] piece 테이블 — 기물 배치 정보
+
+### 3. GameRepository 구현
+
+- [ ] save
+    - 새 게임 생성
+    - 생성된 gameID 반환
+- [ ] findById
+    - 특정 게임 조회
+- [ ] findPlayingGames
+    - 진행 중인 게임 목록 조회
+- [ ] updateTurn
+    - 턴 변경 시 갱신
+- [ ] updateFinished
+    - 게임 종료 시 갱신
+
+### 4. PieceRepository 구현
+
+- [ ] saveAll
+    - 게임의 모든 기물을 DB에 일괄 저장
+
+- [ ] findByGameId
+    - 특정 게임의 모든 기물 조회
+
+- [ ] movePiece
+    - 기물 이동 반영
+        - 도착 칸 기물 삭제
+        - 출발 칸 기물 좌표 갱신
+
+### 5. Controller 흐름 변경 (새 게임 / 이어하기)
+
+- [ ] 프로그램 시작 시
+    - DB에서 진행 중인 게임 목록 조회
+        - 존재하면 → 이어하기 / 새 게임 선택
+        - 없으면 → 새 게임 시작
+- [ ] 매 턴 이동 후
+    - DB에 기물 이동 반영
+    - DB에 턴 변경 반영
+- [ ] 게임 종료 시
+    - DB에 게임 종료 상태 반영  

build.gradle

@@ -9,6 +9,9 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.xerial:sqlite-jdbc:3.45.1.0'
+    implementation 'org.slf4j:slf4j-simple:2.0.12'
+
     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/Application.java

@@ -1,9 +1,11 @@
 package janggi;
 
 import janggi.controller.JanggiController;
+import janggi.infrastructure.DBInitializer;
 
 public class Application {
     public static void main(String[] args) {
+        DBInitializer.initialize();
         JanggiController janggiController = new JanggiController();
         janggiController.run();
     }

src/main/java/janggi/controller/JanggiController.java

@@ -3,43 +3,111 @@
 import janggi.domain.Board;
 import janggi.domain.JanggiGame;
 import janggi.domain.dto.MoveCommand;
+import janggi.domain.piece.Piece;
 import janggi.domain.piece.Team;
 import janggi.domain.vo.Position;
+import janggi.repository.GameRepository;
+import janggi.repository.PieceRepository;
 import janggi.view.InputView;
+import janggi.view.OutputView;
+import java.util.List;
 
 public class JanggiController {
 
     private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+    private final GameRepository gameRepository = new GameRepository();
+    private final PieceRepository pieceRepository = new PieceRepository();
+
+    private JanggiGame janggiGame;
+    private Board board;
 
     public void run() {
-        Board board = new Board();
+        initialize();
+        playGame();
+        printResult();
+    }
+
+    private void initialize() {
+        List<JanggiGame> playingGames = gameRepository.findPlayingGames();
 
-        JanggiGame janggiGame = new JanggiGame();
+        if (playingGames.isEmpty()) {
+            startNewGame();
+            return;
+        }
+
+        int choice = inputView.readGameChoice(playingGames);
+        if (choice == playingGames.size() + 1) {
+            startNewGame();
+            return;
+        }
 
+        resumeGame(playingGames.get(choice - 1));
+    }
+
+    private void startNewGame() {
+        janggiGame = new JanggiGame();
+        Long gameId = gameRepository.save(janggiGame);
+        janggiGame.assignId(gameId);
+
+        board = new Board();
+        pieceRepository.saveAll(gameId, board);
+
+        outputView.printGameStart(gameId);
+    }
+
+    private void resumeGame(JanggiGame game) {
+        janggiGame = game;
+        board = pieceRepository.findByGameId(game.findGameId());
+
+        outputView.printResume(game.findGameId(), game.findCurrentTeam());
+    }
+
+    private void playGame() {
         while (!janggiGame.isFinished()) {
             Team currentTeam = janggiGame.findCurrentTeam();
-            attemptMove(board, currentTeam);
-            janggiGame.changeTurn();
+            outputView.printCurrentTurn(currentTeam);
+            outputView.printBoard(board);
+            attemptMove(currentTeam);
+
+            if (!janggiGame.isFinished()) {
+                janggiGame.changeTurn();
+                gameRepository.updateTurn(janggiGame);
+            }
         }
     }
 
-    private void attemptMove(Board board, Team currentTeam) {
+    private void attemptMove(Team currentTeam) {
         boolean moved = false;
         while (!moved) {
-            moved = tryMove(board, currentTeam);
+            moved = tryMove(currentTeam);
         }
     }
 
-    private boolean tryMove(Board board, Team currentTeam) {
+    private boolean tryMove(Team currentTeam) {
         try {
             MoveCommand moveCommand = inputView.readMovePositions();
             Position from = moveCommand.getFrom();
             Position to = moveCommand.getTo();
-            board.move(from, to, currentTeam);
+
+            Piece captured = board.move(from, to, currentTeam);
+            pieceRepository.movePiece(janggiGame.findGameId(), from, to);
+
+            janggiGame.processCaptured(captured);
+            if (janggiGame.isFinished()) {
+                gameRepository.updateFinished(janggiGame);
+            }
+
             return true;
         } catch (IllegalArgumentException e) {
             System.out.println(e.getMessage());
             return false;
         }
     }
+
+    private void printResult() {
+        outputView.printGameEnd(janggiGame.findWinner());
+        outputView.printScore(Team.CHO, board.calculateScore(Team.CHO));
+        outputView.printScore(Team.HAN, board.calculateScore(Team.HAN));
+    }
 }

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

@@ -4,6 +4,7 @@
 import janggi.domain.piece.Piece;
 import janggi.domain.piece.Team;
 import janggi.domain.vo.Position;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -43,7 +44,27 @@ public boolean isEmptyPosition(Position position) {
         return findByPosition(position).isEmpty();
     }
 
-    public void move(Position from, Position to, Team currentTeam) {
+    @Override
+    public boolean isInsidePalace(Position position) {
+        return Palace.isInsidePalace(position);
+    }
+
+    @Override
+    public boolean canMoveDiagonallyInPalace(Position from, Position to) {
+        return Palace.canMoveDiagonally(from, to);
+    }
+
+    @Override
+    public boolean isDiagonalInPalace(Position from, Position to) {
+        return Palace.isDiagonalInPalace(from, to);
+    }
+
+    @Override
+    public Position getDiagonalMidpointInPalace(Position from, Position to) {
+        return Palace.getDiagonalMidpoint(from, to);
+    }
+
+    public Piece move(Position from, Position to, Team currentTeam) {
         Piece fromPiece = findByPosition(from);
         Piece toPiece = findByPosition(to);
 
@@ -55,6 +76,8 @@ public void move(Position from, Position to, Team currentTeam) {
 
         place(from, new EmptyPosition(Team.OTHER));
         place(to, fromPiece);
+
+        return toPiece;
     }
 
     private void place(Position position, Piece piece) {
@@ -75,4 +98,35 @@ private void validateCommonMove(Team currentTeam, Piece fromPiece, Piece toPiece
             throw new IllegalArgumentException("이미 도착지점에 플레이어님의 진영 기물이 있습니다.");
         }
     }
+
+    public int calculateScore(Team team) {
+        int totalScore = 0;
+        for (List<Piece> row : board) {
+            for (Piece piece : row) {
+                if (piece.isSameTeam(team)) {
+                    totalScore += piece.score();
+                }
+            }
+        }
+        return totalScore;
+    }
+
+
+    // 빈곳은 db에 따로 저장안하려는데....
+    // board 자료구조 자체가 map이었으면.....
+    public Map<Position, Piece> findAllPieces() {
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (int row = 0; row < board.size(); row++) {
+            for (int col = 0; col < board.get(row).size(); col++) {
+                Position position = new Position(row, col);
+                Piece piece = findByPosition(position);
+                if (!piece.isEmpty()) {
+                    pieces.put(position, piece);
+                }
+            }
+        }
+        return pieces;
+    }
+
+
 }

src/main/java/janggi/domain/BoardView.java

@@ -9,4 +9,12 @@ public interface BoardView {
 
     boolean isEmptyPosition(Position position);
 
+    boolean isInsidePalace(Position position);
+
+    boolean canMoveDiagonallyInPalace(Position from, Position to);
+
+    boolean isDiagonalInPalace(Position from, Position to);
+
+    Position getDiagonalMidpointInPalace(Position from, Position to);
+
 }