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

README.md

@@ -4,6 +4,58 @@
 
 ---
 
+## 실행 방법
+
+### DB 설정
+
+1. MySQL 설치 후 접속
+```bash
+mysql -u root -p
+```
+
+2. 아래 SQL 실행:
+```sql
+CREATE DATABASE janggi;
+USE janggi;
+
+CREATE TABLE janggi_game (
+    id   BIGINT NOT NULL AUTO_INCREMENT,
+    turn VARCHAR(8) NOT NULL,
+    PRIMARY KEY (id)
+);
+
+CREATE TABLE piece (
+    id             BIGINT NOT NULL AUTO_INCREMENT,
+    janggi_game_id BIGINT NOT NULL,
+    row_pos        INT NOT NULL,
+    col_pos        INT NOT NULL,
+    team           VARCHAR(8) NOT NULL,
+    type           VARCHAR(16) NOT NULL,
+    PRIMARY KEY (id)
+);
+```
+
+3. `src/main/java/janggi/infrastructure/DBConnector.java`의 `USER`, `PASSWORD`를 본인 환경에 맞게 수정
+
+```java
+private static final String URL = "jdbc:mysql://localhost:3306/janggi";
+private static final String USER = "root";       // 본인 MySQL 사용자명
+private static final String PASSWORD = "";        // 본인 MySQL 비밀번호
+```
+
+### 게임 실행
+
+IntelliJ에서 `JanggiApplication.java`의 `main` 메서드를 실행한다.
+
+### 게임 방법
+
+- 새 게임: `1` 입력 → 차림 선택 → 게임 시작
+- 이어하기: `2` 입력 → 게임 번호 입력 → 게임 재개
+- 이동: `출발좌표 도착좌표` 형식으로 입력 (예: `11 21`)
+- 종료: `end` 입력
+
+---
+
 ## 구현할 기능 목록
 
 ### 열 좌표 (Column)
@@ -44,25 +96,29 @@
 5. 검증 통과 시 보드 위 기물의 실제 이동 실행
 
 ### 장(General) / 사(Guard)
-- [X] 궁성 내에서 지정된 선을 따라 직선 1칸 이동 시 올바른 경로를 반환한다.
-- [X] 궁성 내 지정된 선이 아닌 대각선으로 이동하려 하면 예외가 발생한다.
-- [X] 1칸을 초과하여 이동하려 하면 예외가 발생한다.
+- [X] 궁성 내에서 직선으로 1칸 이동 시 올바른 경로를 반환한다.
+- [X] 궁성 내 대각선 선을 따라 1칸 이동 시 올바른 경로를 반환한다.
+- [X] 궁성 밖으로 이동하려 하면 예외가 발생한다.
+- [X] 대각선 선 위가 아닌 곳으로 대각선 이동하려 하면 예외가 발생한다.
 - [X] 도착할 위치에 아군 기물이 있으면 예외가 발생한다.
 - [X] 도착할 위치에 적군 기물이 있으면 정상적으로 이동(공격) 가능하다.
 
 ### 차 (Chariot)
 - [X] 상하좌우 직선 방향으로 이동 시 출발지부터 도착지까지의 경로를 반환한다.
+- [X] 궁성 대각선 선을 따라 1칸 이동 시 빈 경로를 반환한다.
+- [X] 궁성 대각선 선을 따라 2칸 이동 시 중심 위치를 경로로 반환한다.
 - [X] 한 번에 여러 방향(대각선, 꺾임 등)으로 이동하려 하면 예외가 발생한다.
-- [X] 이동하는 도중의 경로(List) 안에 빈칸(EmptyPiece)이 아닌 다른 기물이 존재하면 예외가 발생한다.
+- [X] 이동하는 도중의 경로에 빈칸이 아닌 기물이 존재하면 예외가 발생한다.
 - [X] 도착할 위치에 아군 기물이 있으면 예외가 발생한다.
 
 ### 포 (Cannon)
 - [X] 상하좌우 직선 방향이 아닌 방향으로 이동하려 하면 예외가 발생한다.
-- [X] 이동하는 도중의 경로에 뛰어넘을 기물이 없거나(0개) 2개 이상 존재하면 예외가 발생한다. (반드시 1개만 넘어야 함)
+- [X] 궁성 대각선 2칸 이동 시 중심 위치를 경로로 반환한다.
+- [X] 궁성 대각선 1칸 이동은 넘을 기물이 없어 예외가 발생한다.
+- [X] 이동하는 도중의 경로에 뛰어넘을 기물이 없거나(0개) 2개 이상 존재하면 예외가 발생한다.
 - [X] 뛰어넘어야 하는 기물이 같은 '포'일 경우 예외가 발생한다.
 - [X] 도착할 위치에 아군 기물이 있으면 예외가 발생한다.
 - [X] 도착할 위치(잡으려는 대상)가 상대방의 '포'일 경우 예외가 발생한다.
-- [X] 위의 모든 제약 조건을 지키며 한 방향 직선으로 이동 시 정상적으로 경로를 반환한다.
 
 ### 마 (Horse)
 - [X] 직선 방향으로 1칸, 이어서 대각선 방향으로 1칸 이동 시 (마밭 이동) 올바른 경로를 반환한다.
@@ -81,6 +137,8 @@
 
 ### 졸/병 (Soldier)
 - [X] 전진 또는 좌우로 직선 1칸 이동 시 정상적인 경로를 반환한다.
+- [X] 궁성 내 대각선 선 위에서 전진 방향 대각선 1칸 이동 시 정상적인 경로를 반환한다.
+- [X] 궁성 내에서 후진 대각선으로 이동하려 하면 예외가 발생한다.
 - [X] 대각선으로 이동하려 하면 예외가 발생한다.
 - [X] 자신의 진영 기준으로 뒤로 후퇴하려 하면 예외가 발생한다.
 - [X] 한 번에 1칸을 초과하여 이동하려 하면 예외가 발생한다.
@@ -94,6 +152,25 @@
 - [X] 모든 검증을 통과하고 이동이 완료되면, 기존 출발 좌표의 위치는 빈칸(EmptyPiece) 상태가 된다.
 - [X] 기존 출발 좌표에 있던 기물 객체는 도착 좌표의 위치로 갱신된다.
 
+### 궁성 (Palace)
+- [X] 궁성 범위 내 위치를 올바르게 판별한다.
+- [X] 궁성 대각선 선 위의 위치(꼭짓점, 중심)를 올바르게 판별한다.
+- [X] 대각선 선 위 1칸/2칸 이동 가능 여부를 올바르게 판별한다.
+- [X] 2칸 대각선 이동 시 중심 위치를 경로로 반환한다.
+- [X] 1칸 대각선 이동 시 빈 경로를 반환한다.
+
+### 점수 (Score)
+- [X] 기물별 점수를 합산하여 팀의 점수를 계산한다.
+- [X] 한나라 점수에는 덤(1.5점)이 적용된다.
+- [X] 초나라 점수에는 덤이 적용되지 않는다.
+- [X] 점수가 더 높은 팀을 올바르게 판별한다.
+
+### 게임 종료 (승패 판정)
+- [X] 장이 잡히면 즉시 게임을 종료하고 잡은 팀을 승리자로 출력한다.
+- [X] 장이 잡히면 최종 점수를 출력한다.
+- [X] end 입력 시 현재 점수를 출력하고 점수 우세 팀을 출력한다.
+- [X] 점수가 동일하면 무승부를 출력한다.
+
 ---
 
 ## 프로그래밍 요구사항

build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'java'
+    id 'application'
 }
 
 version '1.0-SNAPSHOT'
@@ -13,6 +14,11 @@ dependencies {
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+    implementation 'mysql:mysql-connector-java:8.0.33'
+}
+
+application {
+    mainClass = 'janggi.JanggiApplication'
 }
 
 java {

src/main/java/janggi/JanggiApplication.java

@@ -1,8 +1,12 @@
 package janggi;
 
+import janggi.domain.GameRepository;
+import janggi.infrastructure.GameRepositoryImpl;
+
 public class JanggiApplication {
 
     public static void main(String[] args) {
-        JanggiGame.initialize().start();
+        GameRepository gameRepository = new GameRepositoryImpl();
+        JanggiGame.from(gameRepository).start();
     }
 }

src/main/java/janggi/JanggiGame.java

@@ -1,6 +1,8 @@
 package janggi;
 
+import janggi.domain.GameRepository;
 import janggi.domain.GameState;
+import janggi.domain.ScoreResult;
 import janggi.domain.Team;
 import janggi.domain.board.Board;
 import janggi.domain.board.BoardFactory;
@@ -17,15 +19,37 @@ public class JanggiGame {
     private static final int POSITION_INPUT_SIZE = 2;
 
     private final Board board;
+    private final GameRepository gameRepository;
+    private final long gameId;
 
-    private JanggiGame(Board board) {
+    private JanggiGame(Board board, GameRepository gameRepository, long gameId) {
         this.board = board;
+        this.gameRepository = gameRepository;
+        this.gameId = gameId;
     }
 
-    public static JanggiGame initialize() {
+    public static JanggiGame from(GameRepository gameRepository) {
+        String mode = InputView.readGameMode();
+        if (mode.equals("1")) {
+            return initialize(gameRepository);
+        }
+        return load(gameRepository);
+    }
+
+    private static JanggiGame initialize(GameRepository gameRepository) {
         String hanSetup = InputView.readHanSetup();
         String choSetup = InputView.readChoSetup();
-        return new JanggiGame(BoardFactory.create(hanSetup, choSetup));
+        Board board = BoardFactory.create(hanSetup, choSetup);
+        long gameId = gameRepository.save(board, Team.CHO);
+        OutputView.printGameId(gameId);
+        return new JanggiGame(board, gameRepository, gameId);
+    }
+
+    private static JanggiGame load(GameRepository gameRepository) {
+        long gameId = InputView.readGameId();
+        Board board = gameRepository.findBoardById(gameId)
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 게임을 찾을 수 없습니다: " + gameId));
+        return new JanggiGame(board, gameRepository, gameId);
     }
 
     public void start() {
@@ -34,19 +58,21 @@ public void start() {
     }
 
     private void play() {
-        Team currentTeam = Team.CHO;
-        GameState state = GameState.TURN_SUCCESS;
+        Team currentTeam = gameRepository.findTurnById(gameId);
+        GameState state = GameState.PLAYING;
         while (state.isPlaying()) {
             String input = InputView.readPosition(currentTeam.getDisplayName());
             state = progressTurn(input, currentTeam);
             if (state.isTurnSuccess()) {
                 currentTeam = currentTeam.convert();
+                gameRepository.update(gameId, board, currentTeam);
             }
         }
     }
 
     private GameState progressTurn(String input, Team currentTeam) {
         if (input.equals(END_COMMAND)) {
+            printScoreResult();
             OutputView.printGameEnd();
             return GameState.FINISHED;
         }
@@ -58,6 +84,7 @@ private GameState processTurn(String input, Team currentTeam) {
             Map<Position, Piece> updatedBoard = movePiece(input, currentTeam);
             if (board.isGeneralCaptured()) {
                 OutputView.printBoard(updatedBoard);
+                printScoreResult();
                 OutputView.printWinner(currentTeam);
                 return GameState.FINISHED;
             }
@@ -69,12 +96,32 @@ private GameState processTurn(String input, Team currentTeam) {
         }
     }
 
+    private void printScoreResult() {
+        ScoreResult result = board.calculateScoreResult();
+        OutputView.printScore(result.hanScore(), result.choScore());
+        if (result.isHanWin()) {
+            OutputView.printScoreWinner(Team.HAN);
+            return;
+        }
+        if (result.isChoWin()) {
+            OutputView.printScoreWinner(Team.CHO);
+            return;
+        }
+        OutputView.printDraw();
+    }
+
     private Map<Position, Piece> movePiece(String input, Team currentTeam) {
+        List<String> positions = parsePositions(input);
+        return board.move(
+                Position.from(positions.getFirst()),
+                Position.from(positions.getLast()),
+                currentTeam);
+    }
+
+    private List<String> parsePositions(String input) {
         List<String> positions = List.of(input.split(" "));
         validateInputSize(positions);
-        Position from = Position.from(positions.getFirst());
-        Position to = Position.from(positions.getLast());
-        return board.move(from, to, currentTeam);
+        return positions;
     }
 
     private void validateInputSize(List<String> positions) {

src/main/java/janggi/domain/GameRepository.java

@@ -0,0 +1,11 @@
+package janggi.domain;
+
+import janggi.domain.board.Board;
+import java.util.Optional;
+
+public interface GameRepository {
+    long save(Board board, Team currentTeam);
+    void update(long gameId, Board board, Team currentTeam);
+    Optional<Board> findBoardById(long gameId);
+    Team findTurnById(long gameId);
+}

src/main/java/janggi/domain/GameState.java

@@ -1,6 +1,7 @@
 package janggi.domain;
 
 public enum GameState {
+    PLAYING,
     TURN_SUCCESS,
     TURN_FAILED,
     FINISHED,

src/main/java/janggi/domain/Score.java

@@ -0,0 +1,28 @@
+package janggi.domain;
+
+public class Score {
+
+    private static final double HAN_BONUS = 1.5;
+
+    private final double value;
+
+    private Score(double value) {
+        this.value = value;
+    }
+
+    public static Score of(double value) {
+        return new Score(value);
+    }
+
+    public Score applyHanBonus() {
+        return new Score(value + HAN_BONUS);
+    }
+
+    public boolean isHigherThan(Score other) {
+        return this.value > other.value;
+    }
+
+    public double getValue() {
+        return value;
+    }
+}

src/main/java/janggi/domain/ScoreResult.java

@@ -0,0 +1,32 @@
+package janggi.domain;
+
+public class ScoreResult {
+
+    private final Score hanScore;
+    private final Score choScore;
+
+    public ScoreResult(Score hanScore, Score choScore) {
+        this.hanScore = hanScore;
+        this.choScore = choScore;
+    }
+
+    public Score hanScore() {
+        return hanScore;
+    }
+
+    public Score choScore() {
+        return choScore;
+    }
+
+    public boolean isHanWin() {
+        return hanScore.isHigherThan(choScore);
+    }
+
+    public boolean isChoWin() {
+        return choScore.isHigherThan(hanScore);
+    }
+
+    public boolean isDraw() {
+        return !isHanWin() && !isChoWin();
+    }
+}